text: /* ***** BEGIN LICENSE BLOCK *****
   * Distributed under the BSD license:
   *
   * Copyright (c) 2010, Ajax.org B.V.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *     * Redistributions of source code must retain the above copyright
   *       notice, this list of conditions and the following disclaimer.
   *     * Redistributions in binary form must reproduce the above copyright
   *       notice, this list of conditions and the following disclaimer in the
   *       documentation and/or other materials provided with the distribution.
   *     * Neither the name of Ajax.org B.V. nor the
   *       names of its contributors may be used to endorse or promote products
   *       derived from this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
   * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * ***** END LICENSE BLOCK ***** */
  
  define(function (require, exports, module) {
      "use strict";
  
      var oop = require("./lib/oop");
      var lang = require("./lib/lang");
      var config = require("./config");
      var EventEmitter = require("./lib/event_emitter").EventEmitter;
      var Selection = require("./selection").Selection;
      var TextMode = require("./mode/text").Mode;
      var Range = require("./range").Range;
      var Document = require("./document").Document;
      var BackgroundTokenizer = require("./background_tokenizer").BackgroundTokenizer;
      var SearchHighlight = require("./search_highlight").SearchHighlight;
  
      /**
       * Stores all the data about [[Editor `Editor`]] state providing easy way to change editors state.
       *
       * `EditSession` can be attached to only one [[Document `Document`]]. Same `Document` can be attached to several `EditSession`s.
       * @class EditSession
       **/
  
  //{ events
      /**
       *
       * Emitted when the document changes.
       * @event change
       * @param {Object} e An object containing a `delta` of information about the change.
       **/
      /**
       * Emitted when the tab size changes, via [[EditSession.setTabSize]].
       *
       * @event changeTabSize
       **/
      /**
       * Emitted when the ability to overwrite text changes, via [[EditSession.setOverwrite]].
       *
       * @event changeOverwrite
       **/
      /**
       * Emitted when the gutter changes, either by setting or removing breakpoints, or when the gutter decorations change.
       *
       * @event changeBreakpoint
       **/
      /**
       * Emitted when a front marker changes.
       *
       * @event changeFrontMarker
       **/
      /**
       * Emitted when a back marker changes.
       *
       * @event changeBackMarker
       **/
      /**
       * Emitted when an annotation changes, like through [[EditSession.setAnnotations]].
       *
       * @event changeAnnotation
       **/
      /**
       * Emitted when a background tokenizer asynchronously processes new rows.
       * @event tokenizerUpdate
       *
       * @param {Object} e An object containing one property, `"data"`, that contains information about the changing rows
       *
       **/
      /**
       * Emitted when the current mode changes.
       *
       * @event changeMode
       *
       **/
      /**
       * Emitted when the wrap mode changes.
       *
       * @event changeWrapMode
       *
       **/
      /**
       * Emitted when the wrapping limit changes.
       *
       * @event changeWrapLimit
       *
       **/
      /**
       * Emitted when a code fold is added or removed.
       *
       * @event changeFold
       *
       **/
      /**
       * Emitted when the scroll top changes.
       * @event changeScrollTop
       *
       * @param {Number} scrollTop The new scroll top value
       **/
      /**
       * Emitted when the scroll left changes.
       * @event changeScrollLeft
       *
       * @param {Number} scrollLeft The new scroll left value
       **/
  //}
  
      /**
       * Sets up a new `EditSession` and associates it with the given `Document` and `TextMode`.
       * @param {Document | String} text [If `text` is a `Document`, it associates the `EditSession` with it. Otherwise, a new `Document` is created, with the initial text]{: #textParam}
       * @param {TextMode} mode [The inital language mode to use for the document]{: #modeParam}
       *
       * @constructor
       **/
  
      var EditSession = function (text, mode) {
          this.$breakpoints = [];
          this.$decorations = [];
          this.$frontMarkers = {};
          this.$backMarkers = {};
          this.$markerId = 1;
          this.$undoSelect = true;
  
          this.$foldData = [];
          this.id = "session" + (++EditSession.$uid);
          this.$foldData.toString = function () {
              return this.join("\n");
          };
          this.on("changeFold", this.onChangeFold.bind(this));
          this.$onChange = this.onChange.bind(this);
  
          if (typeof text != "object" || !text.getLine)
              text = new Document(text);
  
          this.setDocument(text);
          this.selection = new Selection(this);
  
          config.resetOptions(this);
          this.setMode(mode);
          config._signal("session", this);
      };
  
  
      (function () {
  
          oop.implement(this, EventEmitter);
  
          /**
           * Sets the `EditSession` to point to a new `Document`. If a `BackgroundTokenizer` exists, it also points to `doc`.
           *
           * @param {Document} doc The new `Document` to use
           *
           **/
          this.setDocument = function (doc) {
              if (this.doc)
                  this.doc.removeListener("change", this.$onChange);
  
              this.doc = doc;
              doc.on("change", this.$onChange);
  
              if (this.bgTokenizer)
                  this.bgTokenizer.setDocument(this.getDocument());
  
              this.resetCaches();
          };
  
          /**
           * Returns the `Document` associated with this session.
           * @return {Document}
           **/
          this.getDocument = function () {
              return this.doc;
          };
  
          /**
           * @param {Number} row The row to work with
           *
           **/
          this.$resetRowCache = function (docRow) {
              if (!docRow) {
                  this.$docRowCache = [];
                  this.$screenRowCache = [];
                  return;
              }
              var l = this.$docRowCache.length;
              var i = this.$getRowCacheIndex(this.$docRowCache, docRow) + 1;
              if (l > i) {
                  this.$docRowCache.splice(i, l);
                  this.$screenRowCache.splice(i, l);
              }
          };
  
          this.$getRowCacheIndex = function (cacheArray, val) {
              var low = 0;
              var hi = cacheArray.length - 1;
  
              while (low <= hi) {
                  var mid = (low + hi) >> 1;
                  var c = cacheArray[mid];
  
                  if (val > c)
                      low = mid + 1;
                  else if (val < c)
                      hi = mid - 1;
                  else
                      return mid;
              }
  
              return low - 1;
          };
  
          this.resetCaches = function () {
              this.$modified = true;
              this.$wrapData = [];
              this.$rowLengthCache = [];
              this.$resetRowCache(0);
              if (this.bgTokenizer)
                  this.bgTokenizer.start(0);
          };
  
          this.onChangeFold = function (e) {
              var fold = e.data;
              this.$resetRowCache(fold.start.row);
          };
  
          this.onChange = function (delta) {
              this.$modified = true;
  
              this.$resetRowCache(delta.start.row);
  
              var removedFolds = this.$updateInternalDataOnChange(delta);
              if (!this.$fromUndo && this.$undoManager && !delta.ignore) {
                  this.$deltasDoc.push(delta);
                  if (removedFolds && removedFolds.length != 0) {
                      this.$deltasFold.push({
                          action: "removeFolds",
                          folds: removedFolds
                      });
                  }
  
                  this.$informUndoManager.schedule();
              }
  
              this.bgTokenizer && this.bgTokenizer.$updateOnChange(delta);
              this._signal("change", delta);
          };
  
          /**
           * Sets the session text.
           * @param {String} text The new text to place
           *
           **/
          this.setValue = function (text) {
              this.doc.setValue(text);
              this.selection.moveTo(0, 0);
  
              this.$resetRowCache(0);
              this.$deltas = [];
              this.$deltasDoc = [];
              this.$deltasFold = [];
              this.setUndoManager(this.$undoManager);
              this.getUndoManager().reset();
          };
  
          /**
           * Returns the current [[Document `Document`]] as a string.
           * @method toString
           * @returns {String}
           * @alias EditSession.getValue
           *
           **/
  
          /**
           * Returns the current [[Document `Document`]] as a string.
           * @method getValue
           * @returns {String}
           * @alias EditSession.toString
           **/
          this.getValue =
              this.toString = function () {
                  return this.doc.getValue();
              };
  
          /**
           * Returns selection object.
           **/
          this.getSelection = function () {
              return this.selection;
          };
  
          /**
           * {:BackgroundTokenizer.getState}
           * @param {Number} row The row to start at
           *
           * @related BackgroundTokenizer.getState
           **/
          this.getState = function (row) {
              return this.bgTokenizer.getState(row);
          };
  
          /**
           * Starts tokenizing at the row indicated. Returns a list of objects of the tokenized rows.
           * @param {Number} row The row to start at
           *
           *
           *
           **/
          this.getTokens = function (row) {
              return this.bgTokenizer.getTokens(row);
          };
  
          /**
           * Returns an object indicating the token at the current row. The object has two properties: `index` and `start`.
           * @param {Number} row The row number to retrieve from
           * @param {Number} column The column number to retrieve from
           *
           *
           **/
          this.getTokenAt = function (row, column) {
              var tokens = this.bgTokenizer.getTokens(row);
              var token, c = 0;
              if (column == null) {
                  i = tokens.length - 1;
                  c = this.getLine(row).length;
              } else {
                  for (var i = 0; i < tokens.length; i++) {
                      c += tokens[i].value.length;
                      if (c >= column)
                          break;
                  }
              }
              token = tokens[i];
              if (!token)
                  return null;
              token.index = i;
              token.start = c - token.value.length;
              return token;
          };
  
          /**
           * Sets the undo manager.
           * @param {UndoManager} undoManager The new undo manager
           *
           *
           **/
          this.setUndoManager = function (undoManager) {
              this.$undoManager = undoManager;
              this.$deltas = [];
              this.$deltasDoc = [];
              this.$deltasFold = [];
  
              if (this.$informUndoManager)
                  this.$informUndoManager.cancel();
  
              if (undoManager) {
                  var self = this;
  
                  this.$syncInformUndoManager = function () {
                      self.$informUndoManager.cancel();
  
                      if (self.$deltasFold.length) {
                          self.$deltas.push({
                              group: "fold",
                              deltas: self.$deltasFold
                          });
                          self.$deltasFold = [];
                      }
  
                      if (self.$deltasDoc.length) {
                          self.$deltas.push({
                              group: "doc",
                              deltas: self.$deltasDoc
                          });
                          self.$deltasDoc = [];
                      }
  
                      if (self.$deltas.length > 0) {
                          undoManager.execute({
                              action: "aceupdate",
                              args: [self.$deltas, self],
                              merge: self.mergeUndoDeltas
                          });
                      }
                      self.mergeUndoDeltas = false;
                      self.$deltas = [];
                  };
                  this.$informUndoManager = lang.delayedCall(this.$syncInformUndoManager);
              }
          };
  
          /**
           * starts a new group in undo history
           **/
          this.markUndoGroup = function () {
              if (this.$syncInformUndoManager)
                  this.$syncInformUndoManager();
          };
  
          this.$defaultUndoManager = {
              undo: function () {
              },
              redo: function () {
              },
              reset: function () {
              }
          };
  
          /**
           * Returns the current undo manager.
           **/
          this.getUndoManager = function () {
              return this.$undoManager || this.$defaultUndoManager;
          };
  
          /**
           * Returns the current value for tabs. If the user is using soft tabs, this will be a series of spaces (defined by [[EditSession.getTabSize `getTabSize()`]]); otherwise it's simply `'\t'`.
           **/
          this.getTabString = function () {
              if (this.getUseSoftTabs()) {
                  return lang.stringRepeat(" ", this.getTabSize());
              } else {
                  return "\t";
              }
          };
  
          /**
           * Pass `true` to enable the use of soft tabs. Soft tabs means you're using spaces instead of the tab character (`'\t'`).
           * @param {Boolean} useSoftTabs Value indicating whether or not to use soft tabs
           **/
          this.setUseSoftTabs = function (val) {
              this.setOption("useSoftTabs", val);
          };
          /**
           * Returns `true` if soft tabs are being used, `false` otherwise.
           * @returns {Boolean}
           **/
          this.getUseSoftTabs = function () {
              // todo might need more general way for changing settings from mode, but this is ok for now
              return this.$useSoftTabs && !this.$mode.$indentWithTabs;
          };
          /**
           * Set the number of spaces that define a soft tab; for example, passing in `4` transforms the soft tabs to be equivalent to four spaces. This function also emits the `changeTabSize` event.
           * @param {Number} tabSize The new tab size
           **/
          this.setTabSize = function (tabSize) {
              this.setOption("tabSize", tabSize);
          };
          /**
           * Returns the current tab size.
           **/
          this.getTabSize = function () {
              return this.$tabSize;
          };
  
          /**
           * Returns `true` if the character at the position is a soft tab.
           * @param {Object} position The position to check
           *
           **/
          this.isTabStop = function (position) {
              return this.$useSoftTabs && (position.column % this.$tabSize === 0);
          };
  
          this.$overwrite = false;
          /**
           * Pass in `true` to enable overwrites in your session, or `false` to disable.
           *
           * If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event.
           *
           * @param {Boolean} overwrite Defines wheter or not to set overwrites
           *
           *
           **/
          this.setOverwrite = function (overwrite) {
              this.setOption("overwrite", overwrite);
          };
  
          /**
           * Returns `true` if overwrites are enabled; `false` otherwise.
           **/
          this.getOverwrite = function () {
              return this.$overwrite;
          };
  
          /**
           * Sets the value of overwrite to the opposite of whatever it currently is.
           **/
          this.toggleOverwrite = function () {
              this.setOverwrite(!this.$overwrite);
          };
  
          /**
           * Adds `className` to the `row`, to be used for CSS stylings and whatnot.
           * @param {Number} row The row number
           * @param {String} className The class to add
           *
           **/
          this.addGutterDecoration = function (row, className) {
              if (!this.$decorations[row])
                  this.$decorations[row] = "";
              this.$decorations[row] += " " + className;
              this._signal("changeBreakpoint", {});
          };
  
          /**
           * Removes `className` from the `row`.
           * @param {Number} row The row number
           * @param {String} className The class to add
           *
           **/
          this.removeGutterDecoration = function (row, className) {
              this.$decorations[row] = (this.$decorations[row] || "").replace(" " + className, "");
              this._signal("changeBreakpoint", {});
          };
  
          /**
           * Returns an array of strings, indicating the breakpoint class (if any) applied to each row.
           * @returns {[String]}
           **/
          this.getBreakpoints = function () {
              return this.$breakpoints;
          };
  
          /**
           * Sets a breakpoint on every row number given by `rows`. This function also emites the `'changeBreakpoint'` event.
           * @param {Array} rows An array of row indices
           *
           **/
          this.setBreakpoints = function (rows) {
              this.$breakpoints = [];
              for (var i = 0; i < rows.length; i++) {
                  this.$breakpoints[rows[i]] = "ace_breakpoint";
              }
              this._signal("changeBreakpoint", {});
          };
  
          /**
           * Removes all breakpoints on the rows. This function also emites the `'changeBreakpoint'` event.
           **/
          this.clearBreakpoints = function () {
              this.$breakpoints = [];
              this._signal("changeBreakpoint", {});
          };
  
          /**
           * Sets a breakpoint on the row number given by `row`. This function also emites the `'changeBreakpoint'` event.
           * @param {Number} row A row index
           * @param {String} className Class of the breakpoint
           *
           **/
          this.setBreakpoint = function (row, className) {
              if (className === undefined)
                  className = "ace_breakpoint";
              if (className)
                  this.$breakpoints[row] = className;
              else
                  delete this.$breakpoints[row];
              this._signal("changeBreakpoint", {});
          };
  
          /**
           * Removes a breakpoint on the row number given by `row`. This function also emites the `'changeBreakpoint'` event.
           * @param {Number} row A row index
           *
           **/
          this.clearBreakpoint = function (row) {
              delete this.$breakpoints[row];
              this._signal("changeBreakpoint", {});
          };
  
          /**
           * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires.
           * @param {Range} range Define the range of the marker
           * @param {String} clazz Set the CSS class for the marker
           * @param {Function | String} type Identify the type of the marker
           * @param {Boolean} inFront Set to `true` to establish a front marker
           *
           * @return {Number} The new marker id
           **/
          this.addMarker = function (range, clazz, type, inFront) {
              var id = this.$markerId++;
  
              var marker = {
                  range: range,
                  type: type || "line",
                  renderer: typeof type == "function" ? type : null,
                  clazz: clazz,
                  inFront: !!inFront,
                  id: id
              };
  
              if (inFront) {
                  this.$frontMarkers[id] = marker;
                  this._signal("changeFrontMarker");
              } else {
                  this.$backMarkers[id] = marker;
                  this._signal("changeBackMarker");
              }
  
              return id;
          };
  
          /**
           * Adds a dynamic marker to the session.
           * @param {Object} marker object with update method
           * @param {Boolean} inFront Set to `true` to establish a front marker
           *
           * @return {Object} The added marker
           **/
          this.addDynamicMarker = function (marker, inFront) {
              if (!marker.update)
                  return;
              var id = this.$markerId++;
              marker.id = id;
              marker.inFront = !!inFront;
  
              if (inFront) {
                  this.$frontMarkers[id] = marker;
                  this._signal("changeFrontMarker");
              } else {
                  this.$backMarkers[id] = marker;
                  this._signal("changeBackMarker");
              }
  
              return marker;
          };
  
          /**
           * Removes the marker with the specified ID. If this marker was in front, the `'changeFrontMarker'` event is emitted. If the marker was in the back, the `'changeBackMarker'` event is emitted.
           * @param {Number} markerId A number representing a marker
           *
           **/
          this.removeMarker = function (markerId) {
              var marker = this.$frontMarkers[markerId] || this.$backMarkers[markerId];
              if (!marker)
                  return;
  
              var markers = marker.inFront ? this.$frontMarkers : this.$backMarkers;
              if (marker) {
                  delete (markers[markerId]);
                  this._signal(marker.inFront ? "changeFrontMarker" : "changeBackMarker");
              }
          };
  
          /**
           * Returns an object containing all of the markers, either front or back.
           * @param {Boolean} inFront If `true`, indicates you only want front markers; `false` indicates only back markers
           *
           * @returns {Object}
           **/
          this.getMarkers = function (inFront) {
              return inFront ? this.$frontMarkers : this.$backMarkers;
          };
  
          this.highlight = function (re) {
              if (!this.$searchHighlight) {
                  var highlight = new SearchHighlight(null, "ace_selected-word", "text");
                  this.$searchHighlight = this.addDynamicMarker(highlight);
              }
              this.$searchHighlight.setRegexp(re);
          };
  
          // experimental
          this.highlightLines = function (startRow, endRow, clazz, inFront) {
              if (typeof endRow != "number") {
                  clazz = endRow;
                  endRow = startRow;
              }
              if (!clazz)
                  clazz = "ace_step";
  
              var range = new Range(startRow, 0, endRow, Infinity);
              range.id = this.addMarker(range, clazz, "fullLine", inFront);
              return range;
          };
  
          /*
           * Error:
           *  {
           *    row: 12,
           *    column: 2, //can be undefined
           *    text: "Missing argument",
           *    type: "error" // or "warning" or "info"
           *  }
           */
          /**
           * Sets annotations for the `EditSession`. This functions emits the `'changeAnnotation'` event.
           * @param {Array} annotations A list of annotations
           *
           **/
          this.setAnnotations = function (annotations) {
              this.$annotations = annotations;
              this._signal("changeAnnotation", {});
          };
  
          /**
           * Returns the annotations for the `EditSession`.
           * @returns {Array}
           **/
          this.getAnnotations = function () {
              return this.$annotations || [];
          };
  
          /**
           * Clears all the annotations for this session. This function also triggers the `'changeAnnotation'` event.
           **/
          this.clearAnnotations = function () {
              this.setAnnotations([]);
          };
  
          /**
           * If `text` contains either the newline (`\n`) or carriage-return ('\r') characters, `$autoNewLine` stores that value.
           * @param {String} text A block of text
           *
           **/
          this.$detectNewLine = function (text) {
              var match = text.match(/^.*?(\r?\n)/m);
              if (match) {
                  this.$autoNewLine = match[1];
              } else {
                  this.$autoNewLine = "\n";
              }
          };
  
          /**
           * Given a starting row and column, this method returns the `Range` of the first word boundary it finds.
           * @param {Number} row The row to start at
           * @param {Number} column The column to start at
           *
           * @returns {Range}
           **/
          this.getWordRange = function (row, column) {
              var line = this.getLine(row);
  
              var inToken = false;
              if (column > 0)
                  inToken = !!line.charAt(column - 1).match(this.tokenRe);
  
              if (!inToken)
                  inToken = !!line.charAt(column).match(this.tokenRe);
  
              if (inToken)
                  var re = this.tokenRe;
              else if (/^\s+$/.test(line.slice(column - 1, column + 1)))
                  var re = /\s/;
              else
                  var re = this.nonTokenRe;
  
              var start = column;
              if (start > 0) {
                  do {
                      start--;
                  }
                  while (start >= 0 && line.charAt(start).match(re));
                  start++;
              }
  
              var end = column;
              while (end < line.length && line.charAt(end).match(re)) {
                  end++;
              }
  
              return new Range(row, start, row, end);
          };
  
          /**
           * Gets the range of a word, including its right whitespace.
           * @param {Number} row The row number to start from
           * @param {Number} column The column number to start from
           *
           * @return {Range}
           **/
          this.getAWordRange = function (row, column) {
              var wordRange = this.getWordRange(row, column);
              var line = this.getLine(wordRange.end.row);
  
              while (line.charAt(wordRange.end.column).match(/[ \t]/)) {
                  wordRange.end.column += 1;
              }
              return wordRange;
          };
  
          /**
           * {:Document.setNewLineMode.desc}
           * @param {String} newLineMode {:Document.setNewLineMode.param}
           *
           *
           * @related Document.setNewLineMode
           **/
          this.setNewLineMode = function (newLineMode) {
              this.doc.setNewLineMode(newLineMode);
          };
  
          /**
           *
           * Returns the current new line mode.
           * @returns {String}
           * @related Document.getNewLineMode
           **/
          this.getNewLineMode = function () {
              return this.doc.getNewLineMode();
          };
  
          /**
           * Identifies if you want to use a worker for the `EditSession`.
           * @param {Boolean} useWorker Set to `true` to use a worker
           *
           **/
          this.setUseWorker = function (useWorker) {
              this.setOption("useWorker", useWorker);
          };
  
          /**
           * Returns `true` if workers are being used.
           **/
          this.getUseWorker = function () {
              return this.$useWorker;
          };
  
          /**
           * Reloads all the tokens on the current session. This function calls [[BackgroundTokenizer.start `BackgroundTokenizer.start ()`]] to all the rows; it also emits the `'tokenizerUpdate'` event.
           **/
          this.onReloadTokenizer = function (e) {
              var rows = e.data;
              this.bgTokenizer.start(rows.first);
              this._signal("tokenizerUpdate", e);
          };
  
          this.$modes = {};
  
          /**
           * Sets a new text mode for the `EditSession`. This method also emits the `'changeMode'` event. If a [[BackgroundTokenizer `BackgroundTokenizer`]] is set, the `'tokenizerUpdate'` event is also emitted.
           * @param {TextMode} mode Set a new text mode
           * @param {cb} optional callback
           *
           **/
          this.$mode = null;
          this.$modeId = null;
          this.setMode = function (mode, cb) {
              if (mode && typeof mode === "object") {
                  if (mode.getTokenizer)
                      return this.$onChangeMode(mode);
                  var options = mode;
                  var path = options.path;
              } else {
                  path = mode || "ace/mode/text";
              }
  
              // this is needed if ace isn't on require path (e.g tests in node)
              if (!this.$modes["ace/mode/text"])
                  this.$modes["ace/mode/text"] = new TextMode();
  
              if (this.$modes[path] && !options) {
                  this.$onChangeMode(this.$modes[path]);
                  cb && cb();
                  return;
              }
              // load on demand
              this.$modeId = path;
              config.loadModule(["mode", path], function (m) {
                  if (this.$modeId !== path)
                      return cb && cb();
                  if (this.$modes[path] && !options) {
                      this.$onChangeMode(this.$modes[path]);
                  } else if (m && m.Mode) {
                      m = new m.Mode(options);
                      if (!options) {
                          this.$modes[path] = m;
                          m.$id = path;
                      }
                      this.$onChangeMode(m);
                  }
                  cb && cb();
              }.bind(this));
  
              // set mode to text until loading is finished
              if (!this.$mode)
                  this.$onChangeMode(this.$modes["ace/mode/text"], true);
          };
  
          this.$onChangeMode = function (mode, $isPlaceholder) {
              if (!$isPlaceholder)
                  this.$modeId = mode.$id;
              if (this.$mode === mode)
                  return;
  
              this.$mode = mode;
  
              this.$stopWorker();
  
              if (this.$useWorker)
                  this.$startWorker();
  
              var tokenizer = mode.getTokenizer();
  
              if (tokenizer.addEventListener !== undefined) {
                  var onReloadTokenizer = this.onReloadTokenizer.bind(this);
                  tokenizer.addEventListener("update", onReloadTokenizer);
              }
  
              if (!this.bgTokenizer) {
                  this.bgTokenizer = new BackgroundTokenizer(tokenizer);
                  var _self = this;
                  this.bgTokenizer.addEventListener("update", function (e) {
                      _self._signal("tokenizerUpdate", e);
                  });
              } else {
                  this.bgTokenizer.setTokenizer(tokenizer);
              }
  
              this.bgTokenizer.setDocument(this.getDocument());
  
              this.tokenRe = mode.tokenRe;
              this.nonTokenRe = mode.nonTokenRe;
  
  
              if (!$isPlaceholder) {
                  // experimental method, used by c9 findiniles
                  if (mode.attachToSession)
                      mode.attachToSession(this);
                  this.$options.wrapMethod.set.call(this, this.$wrapMethod);
                  this.$setFolding(mode.foldingRules);
                  this.bgTokenizer.start(0);
                  this._emit("changeMode");
              }
          };
  
          this.$stopWorker = function () {
              if (this.$worker) {
                  this.$worker.terminate();
                  this.$worker = null;
              }
          };
  
          this.$startWorker = function () {
              try {
                  this.$worker = this.$mode.createWorker(this);
              } catch (e) {
                  config.warn("Could not load worker", e);
                  this.$worker = null;
              }
          };
  
          /**
           * Returns the current text mode.
           * @returns {TextMode} The current text mode
           **/
          this.getMode = function () {
              return this.$mode;
          };
  
          this.$scrollTop = 0;
          /**
           * This function sets the scroll top value. It also emits the `'changeScrollTop'` event.
           * @param {Number} scrollTop The new scroll top value
           *
           **/
          this.setScrollTop = function (scrollTop) {
              // TODO: should we force integer lineheight instead? scrollTop = Math.round(scrollTop); 
              if (this.$scrollTop === scrollTop || isNaN(scrollTop))
                  return;
  
              this.$scrollTop = scrollTop;
              this._signal("changeScrollTop", scrollTop);
          };
  
          /**
           * [Returns the value of the distance between the top of the editor and the topmost part of the visible content.]{: #EditSession.getScrollTop}
           * @returns {Number}
           **/
          this.getScrollTop = function () {
              return this.$scrollTop;
          };
  
          this.$scrollLeft = 0;
          /**
           * [Sets the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.setScrollLeft}
           **/
          this.setScrollLeft = function (scrollLeft) {
              // scrollLeft = Math.round(scrollLeft);
              if (this.$scrollLeft === scrollLeft || isNaN(scrollLeft))
                  return;
  
              this.$scrollLeft = scrollLeft;
              this._signal("changeScrollLeft", scrollLeft);
          };
  
          /**
           * [Returns the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.getScrollLeft}
           * @returns {Number}
           **/
          this.getScrollLeft = function () {
              return this.$scrollLeft;
          };
  
          /**
           * Returns the width of the screen.
           * @returns {Number}
           **/
          this.getScreenWidth = function () {
              this.$computeWidth();
              if (this.lineWidgets)
                  return Math.max(this.getLineWidgetMaxWidth(), this.screenWidth);
              return this.screenWidth;
          };
  
          this.getLineWidgetMaxWidth = function () {
              if (this.lineWidgetsWidth != null) return this.lineWidgetsWidth;
              var width = 0;
              this.lineWidgets.forEach(function (w) {
                  if (w && w.screenWidth > width)
                      width = w.screenWidth;
              });
              return this.lineWidgetWidth = width;
          };
  
          this.$computeWidth = function (force) {
              if (this.$modified || force) {
                  this.$modified = false;
  
                  if (this.$useWrapMode)
                      return this.screenWidth = this.$wrapLimit;
  
                  var lines = this.doc.getAllLines();
                  var cache = this.$rowLengthCache;
                  var longestScreenLine = 0;
                  var foldIndex = 0;
                  var foldLine = this.$foldData[foldIndex];
                  var foldStart = foldLine ? foldLine.start.row : Infinity;
                  var len = lines.length;
  
                  for (var i = 0; i < len; i++) {
                      if (i > foldStart) {
                          i = foldLine.end.row + 1;
                          if (i >= len)
                              break;
                          foldLine = this.$foldData[foldIndex++];
                          foldStart = foldLine ? foldLine.start.row : Infinity;
                      }
  
                      if (cache[i] == null)
                          cache[i] = this.$getStringScreenWidth(lines[i])[0];
  
                      if (cache[i] > longestScreenLine)
                          longestScreenLine = cache[i];
                  }
                  this.screenWidth = longestScreenLine;
              }
          };
  
          /**
           * Returns a verbatim copy of the given line as it is in the document
           * @param {Number} row The row to retrieve from
           *
           * @returns {String}
           **/
          this.getLine = function (row) {
              return this.doc.getLine(row);
          };
  
          /**
           * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`.
           * @param {Number} firstRow The first row index to retrieve
           * @param {Number} lastRow The final row index to retrieve
           *
           * @returns {[String]}
           *
           **/
          this.getLines = function (firstRow, lastRow) {
              return this.doc.getLines(firstRow, lastRow);
          };
  
          /**
           * Returns the number of rows in the document.
           * @returns {Number}
           **/
          this.getLength = function () {
              return this.doc.getLength();
          };
  
          /**
           * {:Document.getTextRange.desc}
           * @param {Range} range The range to work with
           *
           * @returns {String}
           **/
          this.getTextRange = function (range) {
              return this.doc.getTextRange(range || this.selection.getRange());
          };
  
          /**
           * Inserts a block of `text` and the indicated `position`.
           * @param {Object} position The position {row, column} to start inserting at
           * @param {String} text A chunk of text to insert
           * @returns {Object} The position of the last line of `text`. If the length of `text` is 0, this function simply returns `position`.
           *
           *
           **/
          this.insert = function (position, text) {
              return this.doc.insert(position, text);
          };
  
          /**
           * Removes the `range` from the document.
           * @param {Range} range A specified Range to remove
           * @returns {Object} The new `start` property of the range, which contains `startRow` and `startColumn`. If `range` is empty, this function returns the unmodified value of `range.start`.
           *
           * @related Document.remove
           *
           **/
          this.remove = function (range) {
              return this.doc.remove(range);
          };
  
          /**
           * Removes a range of full lines. This method also triggers the `'change'` event.
           * @param {Number} firstRow The first row to be removed
           * @param {Number} lastRow The last row to be removed
           * @returns {[String]} Returns all the removed lines.
           *
           * @related Document.removeFullLines
           *
           **/
          this.removeFullLines = function (firstRow, lastRow) {
              return this.doc.removeFullLines(firstRow, lastRow);
          };
  
          /**
           * Reverts previous changes to your document.
           * @param {Array} deltas An array of previous changes
           * @param {Boolean} dontSelect [If `true`, doesn't select the range of where the change occured]{: #dontSelect}
           *
           * @returns {Range}
           **/
          this.undoChanges = function (deltas, dontSelect) {
              if (!deltas.length)
                  return;
  
              this.$fromUndo = true;
              var lastUndoRange = null;
              for (var i = deltas.length - 1; i != -1; i--) {
                  var delta = deltas[i];
                  if (delta.group == "doc") {
                      this.doc.revertDeltas(delta.deltas);
                      lastUndoRange =
                          this.$getUndoSelection(delta.deltas, true, lastUndoRange);
                  } else {
                      delta.deltas.forEach(function (foldDelta) {
                          this.addFolds(foldDelta.folds);
                      }, this);
                  }
              }
              this.$fromUndo = false;
              lastUndoRange &&
              this.$undoSelect &&
              !dontSelect &&
              this.selection.setSelectionRange(lastUndoRange);
              return lastUndoRange;
          };
  
          /**
           * Re-implements a previously undone change to your document.
           * @param {Array} deltas An array of previous changes
           * @param {Boolean} dontSelect {:dontSelect}
           *
           * @returns {Range}
           **/
          this.redoChanges = function (deltas, dontSelect) {
              if (!deltas.length)
                  return;
  
              this.$fromUndo = true;
              var lastUndoRange = null;
              for (var i = 0; i < deltas.length; i++) {
                  var delta = deltas[i];
                  if (delta.group == "doc") {
                      this.doc.applyDeltas(delta.deltas);
                      lastUndoRange =
                          this.$getUndoSelection(delta.deltas, false, lastUndoRange);
                  }
              }
              this.$fromUndo = false;
              lastUndoRange &&
              this.$undoSelect &&
              !dontSelect &&
              this.selection.setSelectionRange(lastUndoRange);
              return lastUndoRange;
          };
  
          /**
           * Enables or disables highlighting of the range where an undo occured.
           * @param {Boolean} enable If `true`, selects the range of the reinserted change
           *
           **/
          this.setUndoSelect = function (enable) {
              this.$undoSelect = enable;
          };
  
          this.$getUndoSelection = function (deltas, isUndo, lastUndoRange) {
              function isInsert(delta) {
                  return isUndo ? delta.action !== "insert" : delta.action === "insert";
              }
  
              var delta = deltas[0];
              var range, point;
              var lastDeltaIsInsert = false;
              if (isInsert(delta)) {
                  range = Range.fromPoints(delta.start, delta.end);
                  lastDeltaIsInsert = true;
              } else {
                  range = Range.fromPoints(delta.start, delta.start);
                  lastDeltaIsInsert = false;
              }
  
              for (var i = 1; i < deltas.length; i++) {
                  delta = deltas[i];
                  if (isInsert(delta)) {
                      point = delta.start;
                      if (range.compare(point.row, point.column) == -1) {
                          range.setStart(point);
                      }
                      point = delta.end;
                      if (range.compare(point.row, point.column) == 1) {
                          range.setEnd(point);
                      }
                      lastDeltaIsInsert = true;
                  } else {
                      point = delta.start;
                      if (range.compare(point.row, point.column) == -1) {
                          range = Range.fromPoints(delta.start, delta.start);
                      }
                      lastDeltaIsInsert = false;
                  }
              }
  
              // Check if this range and the last undo range has something in common.
              // If true, merge the ranges.
              if (lastUndoRange != null) {
                  if (Range.comparePoints(lastUndoRange.start, range.start) === 0) {
                      lastUndoRange.start.column += range.end.column - range.start.column;
                      lastUndoRange.end.column += range.end.column - range.start.column;
                  }
  
                  var cmp = lastUndoRange.compareRange(range);
                  if (cmp == 1) {
                      range.setStart(lastUndoRange.start);
                  } else if (cmp == -1) {
                      range.setEnd(lastUndoRange.end);
                  }
              }
  
              return range;
          };
  
          /**
           * Replaces a range in the document with the new `text`.
           *
           * @param {Range} range A specified Range to replace
           * @param {String} text The new text to use as a replacement
           * @returns {Object} An object containing the final row and column, like this:
           * ```
           * {row: endRow, column: 0}
           * ```
           * If the text and range are empty, this function returns an object containing the current `range.start` value.
           * If the text is the exact same as what currently exists, this function returns an object containing the current `range.end` value.
           *
           * @related Document.replace
           **/
          this.replace = function (range, text) {
              return this.doc.replace(range, text);
          };
  
          /**
           * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this:
           *  ```json
           *    { row: newRowLocation, column: newColumnLocation }
           *  ```
           * @param {Range} fromRange The range of text you want moved within the document
           * @param {Object} toPosition The location (row and column) where you want to move the text to
           * @returns {Range} The new range where the text was moved to.
           **/
          this.moveText = function (fromRange, toPosition, copy) {
              var text = this.getTextRange(fromRange);
              var folds = this.getFoldsInRange(fromRange);
  
              var toRange = Range.fromPoints(toPosition, toPosition);
              if (!copy) {
                  this.remove(fromRange);
                  var rowDiff = fromRange.start.row - fromRange.end.row;
                  var collDiff = rowDiff ? -fromRange.end.column : fromRange.start.column - fromRange.end.column;
                  if (collDiff) {
                      if (toRange.start.row == fromRange.end.row && toRange.start.column > fromRange.end.column)
                          toRange.start.column += collDiff;
                      if (toRange.end.row == fromRange.end.row && toRange.end.column > fromRange.end.column)
                          toRange.end.column += collDiff;
                  }
                  if (rowDiff && toRange.start.row >= fromRange.end.row) {
                      toRange.start.row += rowDiff;
                      toRange.end.row += rowDiff;
                  }
              }
  
              toRange.end = this.insert(toRange.start, text);
              if (folds.length) {
                  var oldStart = fromRange.start;
                  var newStart = toRange.start;
                  var rowDiff = newStart.row - oldStart.row;
                  var collDiff = newStart.column - oldStart.column;
                  this.addFolds(folds.map(function (x) {
                      x = x.clone();
                      if (x.start.row == oldStart.row)
                          x.start.column += collDiff;
                      if (x.end.row == oldStart.row)
                          x.end.column += collDiff;
                      x.start.row += rowDiff;
                      x.end.row += rowDiff;
                      return x;
                  }));
              }
  
              return toRange;
          };
  
          /**
           * Indents all the rows, from `startRow` to `endRow` (inclusive), by prefixing each row with the token in `indentString`.
           *
           * If `indentString` contains the `'\t'` character, it's replaced by whatever is defined by [[EditSession.getTabString `getTabString()`]].
           * @param {Number} startRow Starting row
           * @param {Number} endRow Ending row
           * @param {String} indentString The indent token
           *
           *
           **/
          this.indentRows = function (startRow, endRow, indentString) {
              indentString = indentString.replace(/\t/g, this.getTabString());
              for (var row = startRow; row <= endRow; row++)
                  this.doc.insertInLine({row: row, column: 0}, indentString);
          };
  
          /**
           * Outdents all the rows defined by the `start` and `end` properties of `range`.
           * @param {Range} range A range of rows
           *
           **/
          this.outdentRows = function (range) {
              var rowRange = range.collapseRows();
              var deleteRange = new Range(0, 0, 0, 0);
              var size = this.getTabSize();
  
              for (var i = rowRange.start.row; i <= rowRange.end.row; ++i) {
                  var line = this.getLine(i);
  
                  deleteRange.start.row = i;
                  deleteRange.end.row = i;
                  for (var j = 0; j < size; ++j)
                      if (line.charAt(j) != ' ')
                          break;
                  if (j < size && line.charAt(j) == '\t') {
                      deleteRange.start.column = j;
                      deleteRange.end.column = j + 1;
                  } else {
                      deleteRange.start.column = 0;
                      deleteRange.end.column = j;
                  }
                  this.remove(deleteRange);
              }
          };
  
          this.$moveLines = function (firstRow, lastRow, dir) {
              firstRow = this.getRowFoldStart(firstRow);
              lastRow = this.getRowFoldEnd(lastRow);
              if (dir < 0) {
                  var row = this.getRowFoldStart(firstRow + dir);
                  if (row < 0) return 0;
                  var diff = row - firstRow;
              } else if (dir > 0) {
                  var row = this.getRowFoldEnd(lastRow + dir);
                  if (row > this.doc.getLength() - 1) return 0;
                  var diff = row - lastRow;
              } else {
                  firstRow = this.$clipRowToDocument(firstRow);
                  lastRow = this.$clipRowToDocument(lastRow);
                  var diff = lastRow - firstRow + 1;
              }
  
              var range = new Range(firstRow, 0, lastRow, Number.MAX_VALUE);
              var folds = this.getFoldsInRange(range).map(function (x) {
                  x = x.clone();
                  x.start.row += diff;
                  x.end.row += diff;
                  return x;
              });
  
              var lines = dir == 0
                  ? this.doc.getLines(firstRow, lastRow)
                  : this.doc.removeFullLines(firstRow, lastRow);
              this.doc.insertFullLines(firstRow + diff, lines);
              folds.length && this.addFolds(folds);
              return diff;
          };
          /**
           * Shifts all the lines in the document up one, starting from `firstRow` and ending at `lastRow`.
           * @param {Number} firstRow The starting row to move up
           * @param {Number} lastRow The final row to move up
           * @returns {Number} If `firstRow` is less-than or equal to 0, this function returns 0. Otherwise, on success, it returns -1.
           *
           **/
          this.moveLinesUp = function (firstRow, lastRow) {
              return this.$moveLines(firstRow, lastRow, -1);
          };
  
          /**
           * Shifts all the lines in the document down one, starting from `firstRow` and ending at `lastRow`.
           * @param {Number} firstRow The starting row to move down
           * @param {Number} lastRow The final row to move down
           * @returns {Number} If `firstRow` is less-than or equal to 0, this function returns 0. Otherwise, on success, it returns -1.
           **/
          this.moveLinesDown = function (firstRow, lastRow) {
              return this.$moveLines(firstRow, lastRow, 1);
          };
  
          /**
           * Duplicates all the text between `firstRow` and `lastRow`.
           * @param {Number} firstRow The starting row to duplicate
           * @param {Number} lastRow The final row to duplicate
           * @returns {Number} Returns the number of new rows added; in other words, `lastRow - firstRow + 1`.
           *
           *
           **/
          this.duplicateLines = function (firstRow, lastRow) {
              return this.$moveLines(firstRow, lastRow, 0);
          };
  
  
          this.$clipRowToDocument = function (row) {
              return Math.max(0, Math.min(row, this.doc.getLength() - 1));
          };
  
          this.$clipColumnToRow = function (row, column) {
              if (column < 0)
                  return 0;
              return Math.min(this.doc.getLine(row).length, column);
          };
  
  
          this.$clipPositionToDocument = function (row, column) {
              column = Math.max(0, column);
  
              if (row < 0) {
                  row = 0;
                  column = 0;
              } else {
                  var len = this.doc.getLength();
                  if (row >= len) {
                      row = len - 1;
                      column = this.doc.getLine(len - 1).length;
                  } else {
                      column = Math.min(this.doc.getLine(row).length, column);
                  }
              }
  
              return {
                  row: row,
                  column: column
              };
          };
  
          this.$clipRangeToDocument = function (range) {
              if (range.start.row < 0) {
                  range.start.row = 0;
                  range.start.column = 0;
              } else {
                  range.start.column = this.$clipColumnToRow(
                      range.start.row,
                      range.start.column
                  );
              }
  
              var len = this.doc.getLength() - 1;
              if (range.end.row > len) {
                  range.end.row = len;
                  range.end.column = this.doc.getLine(len).length;
              } else {
                  range.end.column = this.$clipColumnToRow(
                      range.end.row,
                      range.end.column
                  );
              }
              return range;
          };
  
          // WRAPMODE
          this.$wrapLimit = 80;
          this.$useWrapMode = false;
          this.$wrapLimitRange = {
              min: null,
              max: null
          };
  
          /**
           * Sets whether or not line wrapping is enabled. If `useWrapMode` is different than the current value, the `'changeWrapMode'` event is emitted.
           * @param {Boolean} useWrapMode Enable (or disable) wrap mode
           *
           **/
          this.setUseWrapMode = function (useWrapMode) {
              if (useWrapMode != this.$useWrapMode) {
                  this.$useWrapMode = useWrapMode;
                  this.$modified = true;
                  this.$resetRowCache(0);
  
                  // If wrapMode is activaed, the wrapData array has to be initialized.
                  if (useWrapMode) {
                      var len = this.getLength();
                      this.$wrapData = Array(len);
                      this.$updateWrapData(0, len - 1);
                  }
  
                  this._signal("changeWrapMode");
              }
          };
  
          /**
           * Returns `true` if wrap mode is being used; `false` otherwise.
           * @returns {Boolean}
           **/
          this.getUseWrapMode = function () {
              return this.$useWrapMode;
          };
  
          // Allow the wrap limit to move freely between min and max. Either
          // parameter can be null to allow the wrap limit to be unconstrained
          // in that direction. Or set both parameters to the same number to pin
          // the limit to that value.
          /**
           * Sets the boundaries of wrap. Either value can be `null` to have an unconstrained wrap, or, they can be the same number to pin the limit. If the wrap limits for `min` or `max` are different, this method also emits the `'changeWrapMode'` event.
           * @param {Number} min The minimum wrap value (the left side wrap)
           * @param {Number} max The maximum wrap value (the right side wrap)
           *
           **/
          this.setWrapLimitRange = function (min, max) {
              if (this.$wrapLimitRange.min !== min || this.$wrapLimitRange.max !== max) {
                  this.$wrapLimitRange = {min: min, max: max};
                  this.$modified = true;
                  // This will force a recalculation of the wrap limit
                  if (this.$useWrapMode)
                      this._signal("changeWrapMode");
              }
          };
  
          /**
           * This should generally only be called by the renderer when a resize is detected.
           * @param {Number} desiredLimit The new wrap limit
           * @returns {Boolean}
           *
           * @private
           **/
          this.adjustWrapLimit = function (desiredLimit, $printMargin) {
              var limits = this.$wrapLimitRange;
              if (limits.max < 0)
                  limits = {min: $printMargin, max: $printMargin};
              var wrapLimit = this.$constrainWrapLimit(desiredLimit, limits.min, limits.max);
              if (wrapLimit != this.$wrapLimit && wrapLimit > 1) {
                  this.$wrapLimit = wrapLimit;
                  this.$modified = true;
                  if (this.$useWrapMode) {
                      this.$updateWrapData(0, this.getLength() - 1);
                      this.$resetRowCache(0);
                      this._signal("changeWrapLimit");
                  }
                  return true;
              }
              return false;
          };
  
          this.$constrainWrapLimit = function (wrapLimit, min, max) {
              if (min)
                  wrapLimit = Math.max(min, wrapLimit);
  
              if (max)
                  wrapLimit = Math.min(max, wrapLimit);
  
              return wrapLimit;
          };
  
          /**
           * Returns the value of wrap limit.
           * @returns {Number} The wrap limit.
           **/
          this.getWrapLimit = function () {
              return this.$wrapLimit;
          };
  
          /**
           * Sets the line length for soft wrap in the editor. Lines will break
           *  at a minimum of the given length minus 20 chars and at a maximum
           *  of the given number of chars.
           * @param {number} limit The maximum line length in chars, for soft wrapping lines.
           */
          this.setWrapLimit = function (limit) {
              this.setWrapLimitRange(limit, limit);
          };
  
          /**
           * Returns an object that defines the minimum and maximum of the wrap limit; it looks something like this:
           *
           *     { min: wrapLimitRange_min, max: wrapLimitRange_max }
           *
           * @returns {Object}
           **/
          this.getWrapLimitRange = function () {
              // Avoid unexpected mutation by returning a copy
              return {
                  min: this.$wrapLimitRange.min,
                  max: this.$wrapLimitRange.max
              };
          };
  
          this.$updateInternalDataOnChange = function (delta) {
              var useWrapMode = this.$useWrapMode;
              var action = delta.action;
              var start = delta.start;
              var end = delta.end;
              var firstRow = start.row;
              var lastRow = end.row;
              var len = lastRow - firstRow;
              var removedFolds = null;
  
              this.$updating = true;
              if (len != 0) {
                  if (action === "remove") {
                      this[useWrapMode ? "$wrapData" : "$rowLengthCache"].splice(firstRow, len);
  
                      var foldLines = this.$foldData;
                      removedFolds = this.getFoldsInRange(delta);
                      this.removeFolds(removedFolds);
  
                      var foldLine = this.getFoldLine(end.row);
                      var idx = 0;
                      if (foldLine) {
                          foldLine.addRemoveChars(end.row, end.column, start.column - end.column);
                          foldLine.shiftRow(-len);
  
                          var foldLineBefore = this.getFoldLine(firstRow);
                          if (foldLineBefore && foldLineBefore !== foldLine) {
                              foldLineBefore.merge(foldLine);
                              foldLine = foldLineBefore;
                          }
                          idx = foldLines.indexOf(foldLine) + 1;
                      }
  
                      for (idx; idx < foldLines.length; idx++) {
                          var foldLine = foldLines[idx];
                          if (foldLine.start.row >= end.row) {
                              foldLine.shiftRow(-len);
                          }
                      }
  
                      lastRow = firstRow;
                  } else {
                      var args = Array(len);
                      args.unshift(firstRow, 0);
                      var arr = useWrapMode ? this.$wrapData : this.$rowLengthCache
                      arr.splice.apply(arr, args);
  
                      // If some new line is added inside of a foldLine, then split
                      // the fold line up.
                      var foldLines = this.$foldData;
                      var foldLine = this.getFoldLine(firstRow);
                      var idx = 0;
                      if (foldLine) {
                          var cmp = foldLine.range.compareInside(start.row, start.column);
                          // Inside of the foldLine range. Need to split stuff up.
                          if (cmp == 0) {
                              foldLine = foldLine.split(start.row, start.column);
                              if (foldLine) {
                                  foldLine.shiftRow(len);
                                  foldLine.addRemoveChars(lastRow, 0, end.column - start.column);
                              }
                          } else
                          // Infront of the foldLine but same row. Need to shift column.
                          if (cmp == -1) {
                              foldLine.addRemoveChars(firstRow, 0, end.column - start.column);
                              foldLine.shiftRow(len);
                          }
                          // Nothing to do if the insert is after the foldLine.
                          idx = foldLines.indexOf(foldLine) + 1;
                      }
  
                      for (idx; idx < foldLines.length; idx++) {
                          var foldLine = foldLines[idx];
                          if (foldLine.start.row >= firstRow) {
                              foldLine.shiftRow(len);
                          }
                      }
                  }
              } else {
                  // Realign folds. E.g. if you add some new chars before a fold, the
                  // fold should "move" to the right.
                  len = Math.abs(delta.start.column - delta.end.column);
                  if (action === "remove") {
                      // Get all the folds in the change range and remove them.
                      removedFolds = this.getFoldsInRange(delta);
                      this.removeFolds(removedFolds);
  
                      len = -len;
                  }
                  var foldLine = this.getFoldLine(firstRow);
                  if (foldLine) {
                      foldLine.addRemoveChars(firstRow, start.column, len);
                  }
              }
  
              if (useWrapMode && this.$wrapData.length != this.doc.getLength()) {
                  console.error("doc.getLength() and $wrapData.length have to be the same!");
              }
              this.$updating = false;
  
              if (useWrapMode)
                  this.$updateWrapData(firstRow, lastRow);
              else
                  this.$updateRowLengthCache(firstRow, lastRow);
  
              return removedFolds;
          };
  
          this.$updateRowLengthCache = function (firstRow, lastRow, b) {
              this.$rowLengthCache[firstRow] = null;
              this.$rowLengthCache[lastRow] = null;
          };
  
          this.$updateWrapData = function (firstRow, lastRow) {
              var lines = this.doc.getAllLines();
              var tabSize = this.getTabSize();
              var wrapData = this.$wrapData;
              var wrapLimit = this.$wrapLimit;
              var tokens;
              var foldLine;
  
              var row = firstRow;
              lastRow = Math.min(lastRow, lines.length - 1);
              while (row <= lastRow) {
                  foldLine = this.getFoldLine(row, foldLine);
                  if (!foldLine) {
                      tokens = this.$getDisplayTokens(lines[row]);
                      wrapData[row] = this.$computeWrapSplits(tokens, wrapLimit, tabSize);
                      row++;
                  } else {
                      tokens = [];
                      foldLine.walk(function (placeholder, row, column, lastColumn) {
                              var walkTokens;
                              if (placeholder != null) {
                                  walkTokens = this.$getDisplayTokens(
                                      placeholder, tokens.length);
                                  walkTokens[0] = PLACEHOLDER_START;
                                  for (var i = 1; i < walkTokens.length; i++) {
                                      walkTokens[i] = PLACEHOLDER_BODY;
                                  }
                              } else {
                                  walkTokens = this.$getDisplayTokens(
                                      lines[row].substring(lastColumn, column),
                                      tokens.length);
                              }
                              tokens = tokens.concat(walkTokens);
                          }.bind(this),
                          foldLine.end.row,
                          lines[foldLine.end.row].length + 1
                      );
  
                      wrapData[foldLine.start.row] = this.$computeWrapSplits(tokens, wrapLimit, tabSize);
                      row = foldLine.end.row + 1;
                  }
              }
          };
  
          // "Tokens"
          var CHAR = 1,
              CHAR_EXT = 2,
              PLACEHOLDER_START = 3,
              PLACEHOLDER_BODY = 4,
              PUNCTUATION = 9,
              SPACE = 10,
              TAB = 11,
              TAB_SPACE = 12;
  
  
          this.$computeWrapSplits = function (tokens, wrapLimit, tabSize) {
              if (tokens.length == 0) {
                  return [];
              }
  
              var splits = [];
              var displayLength = tokens.length;
              var lastSplit = 0, lastDocSplit = 0;
  
              var isCode = this.$wrapAsCode;
  
              var indentedSoftWrap = this.$indentedSoftWrap;
              var maxIndent = wrapLimit <= Math.max(2 * tabSize, 8)
              || indentedSoftWrap === false ? 0 : Math.floor(wrapLimit / 2);
  
              function getWrapIndent() {
                  var indentation = 0;
                  if (maxIndent === 0)
                      return indentation;
                  if (indentedSoftWrap) {
                      for (var i = 0; i < tokens.length; i++) {
                          var token = tokens[i];
                          if (token == SPACE)
                              indentation += 1;
                          else if (token == TAB)
                              indentation += tabSize;
                          else if (token == TAB_SPACE)
                              continue;
                          else
                              break;
                      }
                  }
                  if (isCode && indentedSoftWrap !== false)
                      indentation += tabSize;
                  return Math.min(indentation, maxIndent);
              }
  
              function addSplit(screenPos) {
                  var displayed = tokens.slice(lastSplit, screenPos);
  
                  // The document size is the current size - the extra width for tabs
                  // and multipleWidth characters.
                  var len = displayed.length;
                  displayed.join("")
                  // Get all the TAB_SPACEs.
                      .replace(/12/g, function () {
                          len -= 1;
                      })
                      // Get all the CHAR_EXT/multipleWidth characters.
                      .replace(/2/g, function () {
                          len -= 1;
                      });
  
                  if (!splits.length) {
                      indent = getWrapIndent();
                      splits.indent = indent;
                  }
                  lastDocSplit += len;
                  splits.push(lastDocSplit);
                  lastSplit = screenPos;
              }
  
              var indent = 0;
              while (displayLength - lastSplit > wrapLimit - indent) {
                  // This is, where the split should be.
                  var split = lastSplit + wrapLimit - indent;
  
                  // If there is a space or tab at this split position, then making
                  // a split is simple.
                  if (tokens[split - 1] >= SPACE && tokens[split] >= SPACE) {
                      /* disabled see https://github.com/ajaxorg/ace/issues/1186
                       // Include all following spaces + tabs in this split as well.
                       while (tokens[split] >= SPACE) {
                       split ++;
                       } */
                      addSplit(split);
                      continue;
                  }
  
                  // === ELSE ===
                  // Check if split is inside of a placeholder. Placeholder are
                  // not splitable. Therefore, seek the beginning of the placeholder
                  // and try to place the split beofre the placeholder's start.
                  if (tokens[split] == PLACEHOLDER_START || tokens[split] == PLACEHOLDER_BODY) {
                      // Seek the start of the placeholder and do the split
                      // before the placeholder. By definition there always
                      // a PLACEHOLDER_START between split and lastSplit.
                      for (split; split != lastSplit - 1; split--) {
                          if (tokens[split] == PLACEHOLDER_START) {
                              // split++; << No incremental here as we want to
                              //  have the position before the Placeholder.
                              break;
                          }
                      }
  
                      // If the PLACEHOLDER_START is not the index of the
                      // last split, then we can do the split
                      if (split > lastSplit) {
                          addSplit(split);
                          continue;
                      }
  
                      // If the PLACEHOLDER_START IS the index of the last
                      // split, then we have to place the split after the
                      // placeholder. So, let's seek for the end of the placeholder.
                      split = lastSplit + wrapLimit;
                      for (split; split < tokens.length; split++) {
                          if (tokens[split] != PLACEHOLDER_BODY) {
                              break;
                          }
                      }
  
                      // If spilt == tokens.length, then the placeholder is the last
                      // thing in the line and adding a new split doesn't make sense.
                      if (split == tokens.length) {
                          break;  // Breaks the while-loop.
                      }
  
                      // Finally, add the split...
                      addSplit(split);
                      continue;
                  }
  
                  // === ELSE ===
                  // Search for the first non space/tab/placeholder/punctuation token backwards.
                  var minSplit = Math.max(split - (wrapLimit - (wrapLimit >> 2)), lastSplit - 1);
                  while (split > minSplit && tokens[split] < PLACEHOLDER_START) {
                      split--;
                  }
                  if (isCode) {
                      while (split > minSplit && tokens[split] < PLACEHOLDER_START) {
                          split--;
                      }
                      while (split > minSplit && tokens[split] == PUNCTUATION) {
                          split--;
                      }
                  } else {
                      while (split > minSplit && tokens[split] < SPACE) {
                          split--;
                      }
                  }
                  // If we found one, then add the split.
                  if (split > minSplit) {
                      addSplit(++split);
                      continue;
                  }
  
                  // === ELSE ===
                  split = lastSplit + wrapLimit;
                  // The split is inside of a CHAR or CHAR_EXT token and no space
                  // around -> force a split.
                  if (tokens[split] == CHAR_EXT)
                      split--;
                  addSplit(split - indent);
              }
              return splits;
          };
  
          /**
           * Given a string, returns an array of the display characters, including tabs and spaces.
           * @param {String} str The string to check
           * @param {Number} offset The value to start at
           *
           **/
          this.$getDisplayTokens = function (str, offset) {
              var arr = [];
              var tabSize;
              offset = offset || 0;
  
              for (var i = 0; i < str.length; i++) {
                  var c = str.charCodeAt(i);
                  // Tab
                  if (c == 9) {
                      tabSize = this.getScreenTabSize(arr.length + offset);
                      arr.push(TAB);
                      for (var n = 1; n < tabSize; n++) {
                          arr.push(TAB_SPACE);
                      }
                  }
                  // Space
                  else if (c == 32) {
                      arr.push(SPACE);
                  } else if ((c > 39 && c < 48) || (c > 57 && c < 64)) {
                      arr.push(PUNCTUATION);
                  }
                  // full width characters
                  else if (c >= 0x1100 && isFullWidth(c)) {
                      arr.push(CHAR, CHAR_EXT);
                  } else {
                      arr.push(CHAR);
                  }
              }
              return arr;
          };
  
          /**
           * Calculates the width of the string `str` on the screen while assuming that the string starts at the first column on the screen.
           * @param {String} str The string to calculate the screen width of
           * @param {Number} maxScreenColumn
           * @param {Number} screenColumn
           * @returns {[Number]} Returns an `int[]` array with two elements:<br/>
           * The first position indicates the number of columns for `str` on screen.<br/>
           * The second value contains the position of the document column that this function read until.
           *
           **/
          this.$getStringScreenWidth = function (str, maxScreenColumn, screenColumn) {
              if (maxScreenColumn == 0)
                  return [0, 0];
              if (maxScreenColumn == null)
                  maxScreenColumn = Infinity;
              screenColumn = screenColumn || 0;
  
              var c, column;
              for (column = 0; column < str.length; column++) {
                  c = str.charCodeAt(column);
                  // tab
                  if (c == 9) {
                      screenColumn += this.getScreenTabSize(screenColumn);
                  }
                  // full width characters
                  else if (c >= 0x1100 && isFullWidth(c)) {
                      screenColumn += 2;
                  } else {
                      screenColumn += 1;
                  }
                  if (screenColumn > maxScreenColumn) {
                      break;
                  }
              }
  
              return [screenColumn, column];
          };
  
          this.lineWidgets = null;
          /**
           * Returns number of screenrows in a wrapped line.
           * @param {Number} row The row number to check
           *
           * @returns {Number}
           **/
          this.getRowLength = function (row) {
              if (this.lineWidgets)
                  var h = this.lineWidgets[row] && this.lineWidgets[row].rowCount || 0;
              else
                  h = 0
              if (!this.$useWrapMode || !this.$wrapData[row]) {
                  return 1 + h;
              } else {
                  return this.$wrapData[row].length + 1 + h;
              }
          };
          this.getRowLineCount = function (row) {
              if (!this.$useWrapMode || !this.$wrapData[row]) {
                  return 1;
              } else {
                  return this.$wrapData[row].length + 1;
              }
          };
  
          this.getRowWrapIndent = function (screenRow) {
              if (this.$useWrapMode) {
                  var pos = this.screenToDocumentPosition(screenRow, Number.MAX_VALUE);
                  var splits = this.$wrapData[pos.row];
                  return splits.length && splits[0] < pos.column ? splits.indent : 0;
              } else {
                  return 0;
              }
          }
  
          /**
           * Returns the position (on screen) for the last character in the provided screen row.
           * @param {Number} screenRow The screen row to check
           * @returns {Number}
           *
           * @related EditSession.documentToScreenColumn
           **/
          this.getScreenLastRowColumn = function (screenRow) {
              var pos = this.screenToDocumentPosition(screenRow, Number.MAX_VALUE);
              return this.documentToScreenColumn(pos.row, pos.column);
          };
  
          /**
           * For the given document row and column, this returns the column position of the last screen row.
           * @param {Number} docRow
           *
           * @param {Number} docColumn
           **/
          this.getDocumentLastRowColumn = function (docRow, docColumn) {
              var screenRow = this.documentToScreenRow(docRow, docColumn);
              return this.getScreenLastRowColumn(screenRow);
          };
  
          /**
           * For the given document row and column, this returns the document position of the last row.
           * @param {Number} docRow
           * @param {Number} docColumn
           *
           **/
          this.getDocumentLastRowColumnPosition = function (docRow, docColumn) {
              var screenRow = this.documentToScreenRow(docRow, docColumn);
              return this.screenToDocumentPosition(screenRow, Number.MAX_VALUE / 10);
          };
  
          /**
           * For the given row, this returns the split data.
           * @returns {String}
           **/
          this.getRowSplitData = function (row) {
              if (!this.$useWrapMode) {
                  return undefined;
              } else {
                  return this.$wrapData[row];
              }
          };
  
          /**
           * The distance to the next tab stop at the specified screen column.
           * @param {Number} screenColumn The screen column to check
           *
           * @returns {Number}
           **/
          this.getScreenTabSize = function (screenColumn) {
              return this.$tabSize - screenColumn % this.$tabSize;
          };
  
  
          this.screenToDocumentRow = function (screenRow, screenColumn) {
              return this.screenToDocumentPosition(screenRow, screenColumn).row;
          };
  
  
          this.screenToDocumentColumn = function (screenRow, screenColumn) {
              return this.screenToDocumentPosition(screenRow, screenColumn).column;
          };
  
          /**
           * Converts characters coordinates on the screen to characters coordinates within the document. [This takes into account code folding, word wrap, tab size, and any other visual modifications.]{: #conversionConsiderations}
           * @param {Number} screenRow The screen row to check
           * @param {Number} screenColumn The screen column to check
           * @returns {Object} The object returned has two properties: `row` and `column`.
           *
           * @related EditSession.documentToScreenPosition
           **/
          this.screenToDocumentPosition = function (screenRow, screenColumn) {
              if (screenRow < 0)
                  return {row: 0, column: 0};
  
              var line;
              var docRow = 0;
              var docColumn = 0;
              var column;
              var row = 0;
              var rowLength = 0;
  
              var rowCache = this.$screenRowCache;
              var i = this.$getRowCacheIndex(rowCache, screenRow);
              var l = rowCache.length;
              if (l && i >= 0) {
                  var row = rowCache[i];
                  var docRow = this.$docRowCache[i];
                  var doCache = screenRow > rowCache[l - 1];
              } else {
                  var doCache = !l;
              }
  
              var maxRow = this.getLength() - 1;
              var foldLine = this.getNextFoldLine(docRow);
              var foldStart = foldLine ? foldLine.start.row : Infinity;
  
              while (row <= screenRow) {
                  rowLength = this.getRowLength(docRow);
                  if (row + rowLength > screenRow || docRow >= maxRow) {
                      break;
                  } else {
                      row += rowLength;
                      docRow++;
                      if (docRow > foldStart) {
                          docRow = foldLine.end.row + 1;
                          foldLine = this.getNextFoldLine(docRow, foldLine);
                          foldStart = foldLine ? foldLine.start.row : Infinity;
                      }
                  }
  
                  if (doCache) {
                      this.$docRowCache.push(docRow);
                      this.$screenRowCache.push(row);
                  }
              }
  
              if (foldLine && foldLine.start.row <= docRow) {
                  line = this.getFoldDisplayLine(foldLine);
                  docRow = foldLine.start.row;
              } else if (row + rowLength <= screenRow || docRow > maxRow) {
                  // clip at the end of the document
                  return {
                      row: maxRow,
                      column: this.getLine(maxRow).length
                  };
              } else {
                  line = this.getLine(docRow);
                  foldLine = null;
              }
              var wrapIndent = 0;
              if (this.$useWrapMode) {
                  var splits = this.$wrapData[docRow];
                  if (splits) {
                      var splitIndex = Math.floor(screenRow - row);
                      column = splits[splitIndex];
                      if (splitIndex > 0 && splits.length) {
                          wrapIndent = splits.indent;
                          docColumn = splits[splitIndex - 1] || splits[splits.length - 1];
                          line = line.substring(docColumn);
                      }
                  }
              }
  
              docColumn += this.$getStringScreenWidth(line, screenColumn - wrapIndent)[1];
  
              // We remove one character at the end so that the docColumn
              // position returned is not associated to the next row on the screen.
              if (this.$useWrapMode && docColumn >= column)
                  docColumn = column - 1;
  
              if (foldLine)
                  return foldLine.idxToPosition(docColumn);
  
              return {row: docRow, column: docColumn};
          };
  
          /**
           * Converts document coordinates to screen coordinates. {:conversionConsiderations}
           * @param {Number} docRow The document row to check
           * @param {Number} docColumn The document column to check
           * @returns {Object} The object returned by this method has two properties: `row` and `column`.
           *
           * @related EditSession.screenToDocumentPosition
           **/
          this.documentToScreenPosition = function (docRow, docColumn) {
              // Normalize the passed in arguments.
              if (typeof docColumn === "undefined")
                  var pos = this.$clipPositionToDocument(docRow.row, docRow.column);
              else
                  pos = this.$clipPositionToDocument(docRow, docColumn);
  
              docRow = pos.row;
              docColumn = pos.column;
  
              var screenRow = 0;
              var foldStartRow = null;
              var fold = null;
  
              // Clamp the docRow position in case it's inside of a folded block.
              fold = this.getFoldAt(docRow, docColumn, 1);
              if (fold) {
                  docRow = fold.start.row;
                  docColumn = fold.start.column;
              }
  
              var rowEnd, row = 0;
  
  
              var rowCache = this.$docRowCache;
              var i = this.$getRowCacheIndex(rowCache, docRow);
              var l = rowCache.length;
              if (l && i >= 0) {
                  var row = rowCache[i];
                  var screenRow = this.$screenRowCache[i];
                  var doCache = docRow > rowCache[l - 1];
              } else {
                  var doCache = !l;
              }
  
              var foldLine = this.getNextFoldLine(row);
              var foldStart = foldLine ? foldLine.start.row : Infinity;
  
              while (row < docRow) {
                  if (row >= foldStart) {
                      rowEnd = foldLine.end.row + 1;
                      if (rowEnd > docRow)
                          break;
                      foldLine = this.getNextFoldLine(rowEnd, foldLine);
                      foldStart = foldLine ? foldLine.start.row : Infinity;
                  }
                  else {
                      rowEnd = row + 1;
                  }
  
                  screenRow += this.getRowLength(row);
                  row = rowEnd;
  
                  if (doCache) {
                      this.$docRowCache.push(row);
                      this.$screenRowCache.push(screenRow);
                  }
              }
  
              // Calculate the text line that is displayed in docRow on the screen.
              var textLine = "";
              // Check if the final row we want to reach is inside of a fold.
              if (foldLine && row >= foldStart) {
                  textLine = this.getFoldDisplayLine(foldLine, docRow, docColumn);
                  foldStartRow = foldLine.start.row;
              } else {
                  textLine = this.getLine(docRow).substring(0, docColumn);
                  foldStartRow = docRow;
              }
              var wrapIndent = 0;
              // Clamp textLine if in wrapMode.
              if (this.$useWrapMode) {
                  var wrapRow = this.$wrapData[foldStartRow];
                  if (wrapRow) {
                      var screenRowOffset = 0;
                      while (textLine.length >= wrapRow[screenRowOffset]) {
                          screenRow++;
                          screenRowOffset++;
                      }
                      textLine = textLine.substring(
                          wrapRow[screenRowOffset - 1] || 0, textLine.length
                      );
                      wrapIndent = screenRowOffset > 0 ? wrapRow.indent : 0;
                  }
              }
  
              return {
                  row: screenRow,
                  column: wrapIndent + this.$getStringScreenWidth(textLine)[0]
              };
          };
  
          /**
           * For the given document row and column, returns the screen column.
           * @param {Number} row
           * @param {Number} docColumn
           * @returns {Number}
           *
           **/
          this.documentToScreenColumn = function (row, docColumn) {
              return this.documentToScreenPosition(row, docColumn).column;
          };
  
          /**
           * For the given document row and column, returns the screen row.
           * @param {Number} docRow
           * @param {Number} docColumn
           *
           **/
          this.documentToScreenRow = function (docRow, docColumn) {
              return this.documentToScreenPosition(docRow, docColumn).row;
          };
  
          /**
           * Returns the length of the screen.
           * @returns {Number}
           **/
          this.getScreenLength = function () {
              var screenRows = 0;
              var fold = null;
              if (!this.$useWrapMode) {
                  screenRows = this.getLength();
  
                  // Remove the folded lines again.
                  var foldData = this.$foldData;
                  for (var i = 0; i < foldData.length; i++) {
                      fold = foldData[i];
                      screenRows -= fold.end.row - fold.start.row;
                  }
              } else {
                  var lastRow = this.$wrapData.length;
                  var row = 0, i = 0;
                  var fold = this.$foldData[i++];
                  var foldStart = fold ? fold.start.row : Infinity;
  
                  while (row < lastRow) {
                      var splits = this.$wrapData[row];
                      screenRows += splits ? splits.length + 1 : 1;
                      row++;
                      if (row > foldStart) {
                          row = fold.end.row + 1;
                          fold = this.$foldData[i++];
                          foldStart = fold ? fold.start.row : Infinity;
                      }
                  }
              }
  
              // todo
              if (this.lineWidgets)
                  screenRows += this.$getWidgetScreenLength();
  
              return screenRows;
          };
  
          /**
           * @private
           *
           */
          this.$setFontMetrics = function (fm) {
              if (!this.$enableVarChar) return;
              this.$getStringScreenWidth = function (str, maxScreenColumn, screenColumn) {
                  if (maxScreenColumn === 0)
                      return [0, 0];
                  if (!maxScreenColumn)
                      maxScreenColumn = Infinity;
                  screenColumn = screenColumn || 0;
  
                  var c, column;
                  for (column = 0; column < str.length; column++) {
                      c = str.charAt(column);
                      // tab
                      if (c === "\t") {
                          screenColumn += this.getScreenTabSize(screenColumn);
                      } else {
                          screenColumn += fm.getCharacterWidth(c);
                      }
                      if (screenColumn > maxScreenColumn) {
                          break;
                      }
                  }
  
                  return [screenColumn, column];
              };
          };
  
          this.destroy = function () {
              if (this.bgTokenizer) {
                  this.bgTokenizer.setDocument(null);
                  this.bgTokenizer = null;
              }
              this.$stopWorker();
          };
  
          // For every keystroke this gets called once per char in the whole doc!!
          // Wouldn't hurt to make it a bit faster for c >= 0x1100
          function isFullWidth(c) {
              if (c < 0x1100)
                  return false;
              return c >= 0x1100 && c <= 0x115F ||
                  c >= 0x11A3 && c <= 0x11A7 ||
                  c >= 0x11FA && c <= 0x11FF ||
                  c >= 0x2329 && c <= 0x232A ||
                  c >= 0x2E80 && c <= 0x2E99 ||
                  c >= 0x2E9B && c <= 0x2EF3 ||
                  c >= 0x2F00 && c <= 0x2FD5 ||
                  c >= 0x2FF0 && c <= 0x2FFB ||
                  c >= 0x3000 && c <= 0x303E ||
                  c >= 0x3041 && c <= 0x3096 ||
                  c >= 0x3099 && c <= 0x30FF ||
                  c >= 0x3105 && c <= 0x312D ||
                  c >= 0x3131 && c <= 0x318E ||
                  c >= 0x3190 && c <= 0x31BA ||
                  c >= 0x31C0 && c <= 0x31E3 ||
                  c >= 0x31F0 && c <= 0x321E ||
                  c >= 0x3220 && c <= 0x3247 ||
                  c >= 0x3250 && c <= 0x32FE ||
                  c >= 0x3300 && c <= 0x4DBF ||
                  c >= 0x4E00 && c <= 0xA48C ||
                  c >= 0xA490 && c <= 0xA4C6 ||
                  c >= 0xA960 && c <= 0xA97C ||
                  c >= 0xAC00 && c <= 0xD7A3 ||
                  c >= 0xD7B0 && c <= 0xD7C6 ||
                  c >= 0xD7CB && c <= 0xD7FB ||
                  c >= 0xF900 && c <= 0xFAFF ||
                  c >= 0xFE10 && c <= 0xFE19 ||
                  c >= 0xFE30 && c <= 0xFE52 ||
                  c >= 0xFE54 && c <= 0xFE66 ||
                  c >= 0xFE68 && c <= 0xFE6B ||
                  c >= 0xFF01 && c <= 0xFF60 ||
                  c >= 0xFFE0 && c <= 0xFFE6;
          }
  
      }).call(EditSession.prototype);
  
      require("./edit_session/folding").Folding.call(EditSession.prototype);
      require("./edit_session/bracket_match").BracketMatch.call(EditSession.prototype);
  
  
      config.defineOptions(EditSession.prototype, "session", {
          wrap: {
              set: function (value) {
                  if (!value || value == "off")
                      value = false;
                  else if (value == "free")
                      value = true;
                  else if (value == "printMargin")
                      value = -1;
                  else if (typeof value == "string")
                      value = parseInt(value, 10) || false;
  
                  if (this.$wrap == value)
                      return;
                  this.$wrap = value;
                  if (!value) {
                      this.setUseWrapMode(false);
                  } else {
                      var col = typeof value == "number" ? value : null;
                      this.setWrapLimitRange(col, col);
                      this.setUseWrapMode(true);
                  }
              },
              get: function () {
                  if (this.getUseWrapMode()) {
                      if (this.$wrap == -1)
                          return "printMargin";
                      if (!this.getWrapLimitRange().min)
                          return "free";
                      return this.$wrap;
                  }
                  return "off";
              },
              handlesSet: true
          },
          wrapMethod: {
              // code|text|auto
              set: function (val) {
                  val = val == "auto"
                      ? this.$mode.type != "text"
                      : val != "text";
                  if (val != this.$wrapAsCode) {
                      this.$wrapAsCode = val;
                      if (this.$useWrapMode) {
                          this.$modified = true;
                          this.$resetRowCache(0);
                          this.$updateWrapData(0, this.getLength() - 1);
                      }
                  }
              },
              initialValue: "auto"
          },
          indentedSoftWrap: {initialValue: true},
          firstLineNumber: {
              set: function () {
                  this._signal("changeBreakpoint");
              },
              initialValue: 1
          },
          useWorker: {
              set: function (useWorker) {
                  this.$useWorker = useWorker;
  
                  this.$stopWorker();
                  if (useWorker)
                      this.$startWorker();
              },
              initialValue: true
          },
          useSoftTabs: {initialValue: true},
          tabSize: {
              set: function (tabSize) {
                  if (isNaN(tabSize) || this.$tabSize === tabSize) return;
  
                  this.$modified = true;
                  this.$rowLengthCache = [];
                  this.$tabSize = tabSize;
                  this._signal("changeTabSize");
              },
              initialValue: 4,
              handlesSet: true
          },
          overwrite: {
              set: function (val) {
                  this._signal("changeOverwrite");
              },
              initialValue: false
          },
          newLineMode: {
              set: function (val) {
                  this.doc.setNewLineMode(val)
              },
              get: function () {
                  return this.doc.getNewLineMode()
              },
              handlesSet: true
          },
          mode: {
              set: function (val) {
                  this.setMode(val)
              },
              get: function () {
                  return this.$modeId
              }
          }
      });
  
      exports.EditSession = EditSession;
  });
  