From f4eb8ee43524168eb0028399596899488172aa27 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Thu, 5 Nov 2015 20:17:13 +0000
Subject: [PATCH 01/10] Initial commit

---
 README.md                          |   90 +
 example/build/index.d.ts           |    0
 example/build/index.js             |   20 +
 example/build/index.js.map         |    1 +
 example/bundle.js                  | 3853 +++++++++++++
 example/ext/codemirror.css         |  320 +
 example/ext/codemirror.js          | 8645 ++++++++++++++++++++++++++++
 example/ext/jquery-2.1.4.min.js    |    4 +
 example/ext/pythonmode.js          |  359 ++
 example/index.css                  |   10 +
 example/index.html                 |   14 +
 example/src/index.ts               |   29 +
 example/tsconfig.json              |   15 +
 package.json                       |   64 +
 scripts/copycss.js                 |    3 +
 scripts/travis_after_success.sh    |   17 +
 scripts/travis_install.sh          |   19 +
 scripts/travis_script.sh           |   12 +
 src/codemirror-ipython.js          |   38 +
 src/index.ts                       |  296 +
 src/settings.ts                    |   48 +
 src/tsconfig.json                  |   16 +
 typings/codemirror/codemirror.d.ts |  919 +++
 typings/es6-promise.d.ts           |   71 +
 typings/expect.js/expect.js.d.ts   |  227 +
 typings/mocha/mocha.d.ts           |  220 +
 26 files changed, 15310 insertions(+)
 create mode 100644 README.md
 create mode 100644 example/build/index.d.ts
 create mode 100644 example/build/index.js
 create mode 100644 example/build/index.js.map
 create mode 100644 example/bundle.js
 create mode 100644 example/ext/codemirror.css
 create mode 100644 example/ext/codemirror.js
 create mode 100644 example/ext/jquery-2.1.4.min.js
 create mode 100644 example/ext/pythonmode.js
 create mode 100644 example/index.css
 create mode 100644 example/index.html
 create mode 100644 example/src/index.ts
 create mode 100644 example/tsconfig.json
 create mode 100644 package.json
 create mode 100644 scripts/copycss.js
 create mode 100644 scripts/travis_after_success.sh
 create mode 100644 scripts/travis_install.sh
 create mode 100644 scripts/travis_script.sh
 create mode 100644 src/codemirror-ipython.js
 create mode 100644 src/index.ts
 create mode 100644 src/settings.ts
 create mode 100644 src/tsconfig.json
 create mode 100644 typings/codemirror/codemirror.d.ts
 create mode 100644 typings/es6-promise.d.ts
 create mode 100644 typings/expect.js/expect.js.d.ts
 create mode 100644 typings/mocha/mocha.d.ts

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c66a2ed
--- /dev/null
+++ b/README.md
@@ -0,0 +1,90 @@
+Jupyter JS Editor
+=================
+
+Code/text editor for Jupyter.
+
+[API Docs](http://jupyter.github.io/jupyter-js-editor/)
+
+
+Package Install
+---------------
+
+**Prerequisites**
+- [node](http://nodejs.org/)
+
+```bash
+npm install --save jupyter-js-editor
+```
+
+
+Source Build
+------------
+
+**Prerequisites**
+- [git](http://git-scm.com/)
+- [node 0.12+](http://nodejs.org/)
+
+```bash
+git clone https://github.com/jupyter/jupyter-js-editor.git
+cd jupyter-js-editor
+npm install
+npm run build
+```
+
+**Rebuild**
+```bash
+npm run clean
+npm run build
+```
+
+
+Run Tests
+---------
+
+Follow the source build instructions first.
+
+```bash
+npm test
+```
+
+
+Build Docs
+----------
+
+Follow the source build instructions first.
+
+```bash
+npm run docs
+```
+
+Navigate to `docs/index.html`.
+
+
+Supported Runtimes
+------------------
+
+The runtime versions which are currently *known to work* are listed below.
+Earlier versions may also work, but come with no guarantees.
+
+- Node 0.12.7+
+- IE 11+
+- Firefox 32+
+- Chrome 38+
+
+
+Bundle for the Browser
+----------------------
+
+Follow the package install instructions first.
+
+```bash
+npm install --save-dev browserify
+browserify myapp.js -o mybundle.js
+```
+
+
+Usage Examples
+--------------
+
+**Note:** This module is fully compatible with Node/Babel/ES6/ES5. Simply
+omit the type declarations when using a language other than TypeScript.
diff --git a/example/build/index.d.ts b/example/build/index.d.ts
new file mode 100644
index 0000000..e69de29
diff --git a/example/build/index.js b/example/build/index.js
new file mode 100644
index 0000000..1e29c94
--- /dev/null
+++ b/example/build/index.js
@@ -0,0 +1,20 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use-strict';
+var phosphor_widget_1 = require('phosphor-widget');
+var index_1 = require('../../lib/index');
+function main() {
+    var model = new index_1.EditorModel();
+    var viewmodel = new index_1.EditorViewModel(model);
+    var view = new index_1.EditorWidget(viewmodel);
+    phosphor_widget_1.Widget.attach(view, document.getElementById('main'));
+    view.update();
+    window.onresize = function () { return view.update(); };
+}
+window.onload = main;
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/example/build/index.js.map b/example/build/index.js.map
new file mode 100644
index 0000000..af5a633
--- /dev/null
+++ b/example/build/index.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":["main"],"mappings":"AAAA;;;;;;+EAM+E;AAC/E,YAAY,CAAC;AAEb,gCAEO,iBAAiB,CAAC,CAAA;AAEzB,sBAEO,iBAAiB,CAAC,CAAA;AAEzB;IACEA,IAAIA,KAAKA,GAAGA,IAAIA,mBAAWA,EAAEA,CAACA;IAC9BA,IAAIA,SAASA,GAAGA,IAAIA,uBAAeA,CAACA,KAAKA,CAACA,CAACA;IAC3CA,IAAIA,IAAIA,GAAGA,IAAIA,oBAAYA,CAACA,SAASA,CAACA,CAACA;IAEvCA,wBAAMA,CAACA,MAAMA,CAACA,IAAIA,EAAEA,QAAQA,CAACA,cAAcA,CAACA,MAAMA,CAACA,CAACA,CAACA;IACrDA,IAAIA,CAACA,MAAMA,EAAEA,CAACA;IAEdA,MAAMA,CAACA,QAAQA,GAAGA,cAAMA,OAAAA,IAAIA,CAACA,MAAMA,EAAEA,EAAbA,CAAaA,CAACA;AACxCA,CAACA;AAED,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC"}
\ No newline at end of file
diff --git a/example/bundle.js b/example/bundle.js
new file mode 100644
index 0000000..d2573f0
--- /dev/null
+++ b/example/bundle.js
@@ -0,0 +1,3853 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use-strict';
+var phosphor_widget_1 = require('phosphor-widget');
+var index_1 = require('../../lib/index');
+function main() {
+    var model = new index_1.EditorModel();
+    var viewmodel = new index_1.EditorViewModel(model);
+    var view = new index_1.EditorWidget(viewmodel);
+    phosphor_widget_1.Widget.attach(view, document.getElementById('main'));
+    view.update();
+    window.onresize = function () { return view.update(); };
+}
+window.onload = main;
+
+},{"../../lib/index":2,"phosphor-widget":8}],2:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var phosphor_signaling_1 = require('phosphor-signaling');
+var phosphor_widget_1 = require('phosphor-widget');
+/**
+ * An implementation of IEditorModel.
+ */
+var EditorModel = (function () {
+    function EditorModel() {
+        this._lineNumbers = true;
+        this._tabSize = 2;
+    }
+    EditorModel.prototype.save = function (data) {
+        console.log('MODEL SAVE');
+    };
+    EditorModel.prototype.rename = function (name) {
+        console.log("MODEL RENAME");
+    };
+    return EditorModel;
+})();
+exports.EditorModel = EditorModel;
+var EditorViewModel = (function () {
+    /**
+     * Construct an editor view model.
+     */
+    function EditorViewModel(model) {
+        this.showLineNumbers = true;
+        this.readOnly = true;
+        this.tabSize = 2; // TODO
+        this._mode = '';
+        this._disposed = false;
+        this._view = null;
+        this._buffer = '';
+        /**
+         * The delay in milliseconds between view buffer-fetches.
+         */
+        this._bufferDelay = 1000;
+        /**
+         * The id returned by setTimeout.
+         */
+        this._bufferTimeoutId = 0;
+        this._model = model;
+    }
+    /**
+     * Set the view object for this view model.
+     */
+    EditorViewModel.prototype.setView = function (view) {
+        this._view = view;
+        EditorWidget
+            .getContentsChanged(this._view)
+            .connect(this._startBufferTimer, this);
+    };
+    /**
+     * Save the current buffer in the existing file.
+     */
+    EditorViewModel.prototype.save = function () {
+        this._updateBuffer();
+        this._model.save(this._buffer);
+    };
+    /**
+     * Rename the current file.
+     */
+    EditorViewModel.prototype.rename = function (name) {
+        this._model.rename(name);
+    };
+    /**
+     * The mode of the current editor.
+     */
+    EditorViewModel.prototype.mode = function () {
+        return this._mode;
+    };
+    /**
+     * Dispose of this object.
+     */
+    EditorViewModel.prototype.dispose = function () {
+        this._disposed = true;
+        phosphor_signaling_1.clearSignalData(this);
+        this._model = null;
+        this._view = null;
+    };
+    Object.defineProperty(EditorViewModel.prototype, "isDisposed", {
+        /**
+         * Get the disposed status of this object.
+         */
+        get: function () {
+            return this._disposed;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    EditorViewModel.prototype._updateBuffer = function () {
+        if (!this.isDisposed) {
+            var data = this._view.getContents();
+            this._buffer = data;
+        }
+    };
+    EditorViewModel.prototype._startBufferTimer = function () {
+        var _this = this;
+        clearTimeout(this._bufferTimeoutId);
+        //console.log("setting timeout...");
+        this._bufferTimeoutId = setTimeout(function () {
+            //console.log("TIMED OUT");
+            _this._updateBuffer();
+        }, this._bufferDelay);
+    };
+    return EditorViewModel;
+})();
+exports.EditorViewModel = EditorViewModel;
+/**
+ * A widget used for entering text/code.
+ *
+ * #### Notes
+ * This class happens to use Codemirror as the hosted widget for
+ * text entry, but Codemirror is entirely encapsulated
+ * within this class. As long as the IEditorWidget interface is
+ * adhered to, any other text editor widget can be easily
+ * swapped in.
+ */
+var EditorWidget = (function (_super) {
+    __extends(EditorWidget, _super);
+    /**
+     * Construct an EditorWidget.
+     */
+    function EditorWidget(vm) {
+        var _this = this;
+        _super.call(this);
+        this.addClass('EditorWidget');
+        var config = {
+            mode: vm.mode(),
+            lineNumbers: vm.showLineNumbers,
+            tabSize: vm.tabSize
+        };
+        this._editor = CodeMirror(this.node, config);
+        this._editor.on("change", function () {
+            EditorWidget.getContentsChanged(_this).emit(true);
+        });
+        this._viewmodel = vm;
+        this._viewmodel.setView(this);
+    }
+    /**
+     * A delegate for [[contentsChangedSignal]].
+     */
+    EditorWidget.getContentsChanged = function (item) {
+        return EditorWidget.contentsChangedSignal.bind(item);
+    };
+    /**
+     * Get the contents of the current view as a string.
+     */
+    EditorWidget.prototype.getContents = function () {
+        var doc = this._editor.getDoc();
+        return doc.getValue();
+    };
+    Object.defineProperty(EditorWidget.prototype, "fontSize", {
+        /**
+         * Set the font size in the editor.
+         */
+        set: function (size) {
+            (this._editor.getWrapperElement()).style["font-size"] = size;
+            this._editor.refresh();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    EditorWidget.prototype.onAfterAttach = function (msg) {
+        this._editor.refresh();
+    };
+    EditorWidget.prototype.onResize = function (msg) {
+        if (msg.width < 0 || msg.height < 0) {
+            this._editor.refresh();
+        }
+        else {
+            this._editor.setSize(msg.width, msg.height);
+        }
+    };
+    /**
+     * A signal which is emitted when the view contents change.
+     *
+     * #### Notes
+     * This is designed for the view-model. The data is *not* passed
+     * as the signal argument in order that the view-model can decide
+     * when to pull the potentially large data string from the view.
+     */
+    EditorWidget.contentsChangedSignal = new phosphor_signaling_1.Signal();
+    return EditorWidget;
+})(phosphor_widget_1.Widget);
+exports.EditorWidget = EditorWidget;
+
+},{"phosphor-signaling":6,"phosphor-widget":8}],3:[function(require,module,exports){
+'use strict';
+// For more information about browser field, check out the browser field at https://github.com/substack/browserify-handbook#browser-field.
+
+module.exports = {
+    // Create a <link> tag with optional data attributes
+    createLink: function(href, attributes) {
+        var head = document.head || document.getElementsByTagName('head')[0];
+        var link = document.createElement('link');
+
+        link.href = href;
+        link.rel = 'stylesheet';
+
+        for (var key in attributes) {
+            if ( ! attributes.hasOwnProperty(key)) {
+                continue;
+            }
+            var value = attributes[key];
+            link.setAttribute('data-' + key, value);
+        }
+
+        head.appendChild(link);
+    },
+    // Create a <style> tag with optional data attributes
+    createStyle: function(cssText, attributes) {
+        var head = document.head || document.getElementsByTagName('head')[0],
+            style = document.createElement('style');
+
+        style.type = 'text/css';
+
+        for (var key in attributes) {
+            if ( ! attributes.hasOwnProperty(key)) {
+                continue;
+            }
+            var value = attributes[key];
+            style.setAttribute('data-' + key, value);
+        }
+        
+        if (style.sheet) { // for jsdom and IE9+
+            style.innerHTML = cssText;
+            style.sheet.cssText = cssText;
+            head.appendChild(style);
+        } else if (style.styleSheet) { // for IE8 and below
+            head.appendChild(style);
+            style.styleSheet.cssText = cssText;
+        } else { // for Chrome, Firefox, and Safari
+            style.appendChild(document.createTextNode(cssText));
+            head.appendChild(style);
+        }
+    }
+};
+
+},{}],4:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+var phosphor_queue_1 = require('phosphor-queue');
+/**
+ * A mesage which can be sent or posted to a message handler.
+ *
+ * #### Notes
+ * This class may be subclassed to create complex message types.
+ *
+ * **See Also** [[postMessage]] and [[sendMessage]].
+ */
+var Message = (function () {
+    /**
+     * Construct a new message.
+     *
+     * @param type - The type of the message. Consumers of a message will
+     *   use this value to cast the message to the appropriately derived
+     *   message type.
+     */
+    function Message(type) {
+        this._type = type;
+    }
+    Object.defineProperty(Message.prototype, "type", {
+        /**
+         * Get the type of the message.
+         */
+        get: function () {
+            return this._type;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Message;
+})();
+exports.Message = Message;
+/**
+ * Send a message to the message handler to process immediately.
+ *
+ * @param handler - The handler which should process the message.
+ *
+ * @param msg - The message to send to the handler.
+ *
+ * #### Notes
+ * Unlike [[postMessage]], [[sendMessage]] delivers the message to
+ * the handler immediately. The handler will not have the opportunity
+ * to compress the message, however the message will still be sent
+ * through any installed message filters.
+ *
+ * **See Also** [[postMessage]].
+ */
+function sendMessage(handler, msg) {
+    getDispatcher(handler).sendMessage(handler, msg);
+}
+exports.sendMessage = sendMessage;
+/**
+ * Post a message to the message handler to process in the future.
+ *
+ * @param handler - The handler which should process the message.
+ *
+ * @param msg - The message to post to the handler.
+ *
+ * #### Notes
+ * Unlike [[sendMessage]], [[postMessage]] will schedule the deliver of
+ * the message for the next cycle of the event loop. The handler will
+ * have the opportunity to compress the message in order to optimize
+ * its handling of similar messages. The message will be sent through
+ * any installed message filters before being delivered to the handler.
+ *
+ * **See Also** [[sendMessage]].
+ */
+function postMessage(handler, msg) {
+    getDispatcher(handler).postMessage(handler, msg);
+}
+exports.postMessage = postMessage;
+/**
+ * Test whether a message handler has posted messages pending delivery.
+ *
+ * @param handler - The message handler of interest.
+ *
+ * @returns `true` if the handler has pending posted messages, `false`
+ *   otherwise.
+ *
+ * **See Also** [[sendPendingMessage]].
+ */
+function hasPendingMessages(handler) {
+    return getDispatcher(handler).hasPendingMessages();
+}
+exports.hasPendingMessages = hasPendingMessages;
+/**
+ * Send the first pending posted message to the message handler.
+ *
+ * @param handler - The message handler of interest.
+ *
+ * #### Notes
+ * If the handler has no pending messages, this is a no-op.
+ *
+ * **See Also** [[hasPendingMessages]].
+ */
+function sendPendingMessage(handler) {
+    getDispatcher(handler).sendPendingMessage(handler);
+}
+exports.sendPendingMessage = sendPendingMessage;
+/**
+ * Install a message filter for a message handler.
+ *
+ * A message filter is invoked before the message handler processes a
+ * message. If the filter returns `true` from its [[filterMessage]] method,
+ * no other filters will be invoked, and the message will not be delivered.
+ *
+ * The most recently installed message filter is executed first.
+ *
+ * @param handler - The handler whose messages should be filtered.
+ *
+ * @param filter - The filter to install for the handler.
+ *
+ * #### Notes
+ * It is possible to install the same filter multiple times. If the
+ * filter should be unique, call [[removeMessageFilter]] first.
+ *
+ * **See Also** [[removeMessageFilter]].
+ */
+function installMessageFilter(handler, filter) {
+    getDispatcher(handler).installMessageFilter(filter);
+}
+exports.installMessageFilter = installMessageFilter;
+/**
+ * Remove a previously installed message filter for a message handler.
+ *
+ * @param handler - The handler for which the filter is installed.
+ *
+ * @param filter - The filter to remove.
+ *
+ * #### Notes
+ * This will remove **all** occurrences of the filter. If the filter is
+ * not installed, this is a no-op.
+ *
+ * It is safe to call this function while the filter is executing.
+ *
+ * **See Also** [[installMessageFilter]].
+ */
+function removeMessageFilter(handler, filter) {
+    getDispatcher(handler).removeMessageFilter(filter);
+}
+exports.removeMessageFilter = removeMessageFilter;
+/**
+ * Clear all message data associated with the message handler.
+ *
+ * @param handler - The message handler for which to clear the data.
+ *
+ * #### Notes
+ * This will remove all pending messages and filters for the handler.
+ */
+function clearMessageData(handler) {
+    var dispatcher = dispatcherMap.get(handler);
+    if (dispatcher)
+        dispatcher.clear();
+    dispatchQueue.removeAll(handler);
+}
+exports.clearMessageData = clearMessageData;
+/**
+ * The internal mapping of message handler to message dispatcher
+ */
+var dispatcherMap = new WeakMap();
+/**
+ * The internal queue of pending message handlers.
+ */
+var dispatchQueue = new phosphor_queue_1.Queue();
+/**
+ * The internal animation frame id for the message loop wake up call.
+ */
+var frameId = void 0;
+/**
+ * A local reference to an event loop hook.
+ */
+var raf;
+if (typeof requestAnimationFrame === 'function') {
+    raf = requestAnimationFrame;
+}
+else {
+    raf = setImmediate;
+}
+/**
+ * Get or create the message dispatcher for a message handler.
+ */
+function getDispatcher(handler) {
+    var dispatcher = dispatcherMap.get(handler);
+    if (dispatcher)
+        return dispatcher;
+    dispatcher = new MessageDispatcher();
+    dispatcherMap.set(handler, dispatcher);
+    return dispatcher;
+}
+/**
+ * Wake up the message loop to process any pending dispatchers.
+ *
+ * This is a no-op if a wake up is not needed or is already pending.
+ */
+function wakeUpMessageLoop() {
+    if (frameId === void 0 && !dispatchQueue.empty) {
+        frameId = raf(runMessageLoop);
+    }
+}
+/**
+ * Run an iteration of the message loop.
+ *
+ * This will process all pending dispatchers in the queue. Dispatchers
+ * which are added to the queue while the message loop is running will
+ * be processed on the next message loop cycle.
+ */
+function runMessageLoop() {
+    // Clear the frame id so the next wake up call can be scheduled.
+    frameId = void 0;
+    // If the queue is empty, there is nothing else to do.
+    if (dispatchQueue.empty) {
+        return;
+    }
+    // Add a null sentinel value to the end of the queue. The queue
+    // will only be processed up to the first null value. This means
+    // that messages posted during this cycle will execute on the next
+    // cycle of the loop. If the last value in the array is null, it
+    // means that an exception was thrown by a message handler and the
+    // loop had to be restarted.
+    if (dispatchQueue.back !== null) {
+        dispatchQueue.push(null);
+    }
+    // The message dispatch loop. If the dispatcher is the null sentinel,
+    // the processing of the current block of messages is complete and
+    // another loop is scheduled. Otherwise, the pending message is
+    // dispatched to the message handler.
+    while (!dispatchQueue.empty) {
+        var handler = dispatchQueue.pop();
+        if (handler === null) {
+            wakeUpMessageLoop();
+            return;
+        }
+        dispatchMessage(dispatcherMap.get(handler), handler);
+    }
+}
+/**
+ * Safely process the pending handler message.
+ *
+ * If the message handler throws an exception, the message loop will
+ * be restarted and the exception will be rethrown.
+ */
+function dispatchMessage(dispatcher, handler) {
+    try {
+        dispatcher.sendPendingMessage(handler);
+    }
+    catch (ex) {
+        wakeUpMessageLoop();
+        throw ex;
+    }
+}
+/**
+ * An internal class which manages message dispatching for a handler.
+ */
+var MessageDispatcher = (function () {
+    function MessageDispatcher() {
+        this._filters = null;
+        this._messages = null;
+    }
+    /**
+     * Send a message to the handler immediately.
+     *
+     * The message will first be sent through installed filters.
+     */
+    MessageDispatcher.prototype.sendMessage = function (handler, msg) {
+        if (!this._filterMessage(handler, msg)) {
+            handler.processMessage(msg);
+        }
+    };
+    /**
+     * Post a message for delivery in the future.
+     *
+     * The message will first be compressed if possible.
+     */
+    MessageDispatcher.prototype.postMessage = function (handler, msg) {
+        if (!this._compressMessage(handler, msg)) {
+            this._enqueueMessage(handler, msg);
+        }
+    };
+    /**
+     * Test whether the dispatcher has messages pending delivery.
+     */
+    MessageDispatcher.prototype.hasPendingMessages = function () {
+        return !!(this._messages && !this._messages.empty);
+    };
+    /**
+     * Send the first pending message to the message handler.
+     */
+    MessageDispatcher.prototype.sendPendingMessage = function (handler) {
+        if (this._messages && !this._messages.empty) {
+            this.sendMessage(handler, this._messages.pop());
+        }
+    };
+    /**
+     * Install a message filter for the dispatcher.
+     */
+    MessageDispatcher.prototype.installMessageFilter = function (filter) {
+        this._filters = { next: this._filters, filter: filter };
+    };
+    /**
+     * Remove all occurrences of a message filter from the dispatcher.
+     */
+    MessageDispatcher.prototype.removeMessageFilter = function (filter) {
+        var link = this._filters;
+        var prev = null;
+        while (link !== null) {
+            if (link.filter === filter) {
+                link.filter = null;
+            }
+            else if (prev === null) {
+                this._filters = link;
+                prev = link;
+            }
+            else {
+                prev.next = link;
+                prev = link;
+            }
+            link = link.next;
+        }
+        if (!prev) {
+            this._filters = null;
+        }
+        else {
+            prev.next = null;
+        }
+    };
+    /**
+     * Clear all messages and filters from the dispatcher.
+     */
+    MessageDispatcher.prototype.clear = function () {
+        if (this._messages) {
+            this._messages.clear();
+        }
+        for (var link = this._filters; link !== null; link = link.next) {
+            link.filter = null;
+        }
+        this._filters = null;
+    };
+    /**
+     * Run the installed message filters for the handler.
+     *
+     * Returns `true` if the message was filtered, `false` otherwise.
+     */
+    MessageDispatcher.prototype._filterMessage = function (handler, msg) {
+        for (var link = this._filters; link !== null; link = link.next) {
+            if (link.filter && link.filter.filterMessage(handler, msg)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * Compress the mssage for the given handler.
+     *
+     * Returns `true` if the message was compressed, `false` otherwise.
+     */
+    MessageDispatcher.prototype._compressMessage = function (handler, msg) {
+        if (!handler.compressMessage) {
+            return false;
+        }
+        if (!this._messages || this._messages.empty) {
+            return false;
+        }
+        return handler.compressMessage(msg, this._messages);
+    };
+    /**
+     * Enqueue the message for future delivery to the handler.
+     */
+    MessageDispatcher.prototype._enqueueMessage = function (handler, msg) {
+        (this._messages || (this._messages = new phosphor_queue_1.Queue())).push(msg);
+        dispatchQueue.push(handler);
+        wakeUpMessageLoop();
+    };
+    return MessageDispatcher;
+})();
+
+},{"phosphor-queue":5}],5:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+/**
+ * A generic FIFO queue data structure.
+ *
+ * #### Notes
+ * This queue is implemented internally using a singly linked list and
+ * can grow to arbitrary size.
+ *
+ * #### Example
+ * ```typescript
+ * var q = new Queue<number>([0, 1, 2]);
+ * q.size;      // 3
+ * q.empty;     // false
+ * q.pop();     // 0
+ * q.pop();     // 1
+ * q.push(42);  // undefined
+ * q.size;      // 2
+ * q.pop();     // 2
+ * q.pop();     // 42
+ * q.pop();     // undefined
+ * q.size;      // 0
+ * q.empty;     // true
+ * ```
+ */
+var Queue = (function () {
+    /**
+     * Construct a new queue.
+     *
+     * @param items - The initial items for the queue.
+     */
+    function Queue(items) {
+        var _this = this;
+        this._size = 0;
+        this._front = null;
+        this._back = null;
+        if (items)
+            items.forEach(function (item) { return _this.push(item); });
+    }
+    Object.defineProperty(Queue.prototype, "size", {
+        /**
+         * Get the number of elements in the queue.
+         *
+         * #### Notes
+         * This has `O(1)` complexity.
+         */
+        get: function () {
+            return this._size;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Queue.prototype, "empty", {
+        /**
+         * Test whether the queue is empty.
+         *
+         * #### Notes
+         * This has `O(1)` complexity.
+         */
+        get: function () {
+            return this._size === 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Queue.prototype, "front", {
+        /**
+         * Get the value at the front of the queue.
+         *
+         * #### Notes
+         * This has `O(1)` complexity.
+         *
+         * If the queue is empty, this value will be `undefined`.
+         */
+        get: function () {
+            return this._front !== null ? this._front.value : void 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Queue.prototype, "back", {
+        /**
+         * Get the value at the back of the queue.
+         *
+         * #### Notes
+         * This has `O(1)` complexity.
+         *
+         * If the queue is empty, this value will be `undefined`.
+         */
+        get: function () {
+            return this._back !== null ? this._back.value : void 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Push a value onto the back of the queue.
+     *
+     * @param value - The value to add to the queue.
+     *
+     * #### Notes
+     * This has `O(1)` complexity.
+     */
+    Queue.prototype.push = function (value) {
+        var link = { next: null, value: value };
+        if (this._back === null) {
+            this._front = link;
+            this._back = link;
+        }
+        else {
+            this._back.next = link;
+            this._back = link;
+        }
+        this._size++;
+    };
+    /**
+     * Pop and return the value at the front of the queue.
+     *
+     * @returns The value at the front of the queue.
+     *
+     * #### Notes
+     * This has `O(1)` complexity.
+     *
+     * If the queue is empty, the return value will be `undefined`.
+     */
+    Queue.prototype.pop = function () {
+        var link = this._front;
+        if (link === null) {
+            return void 0;
+        }
+        if (link.next === null) {
+            this._front = null;
+            this._back = null;
+        }
+        else {
+            this._front = link.next;
+        }
+        this._size--;
+        return link.value;
+    };
+    /**
+     * Remove the first occurrence of a value from the queue.
+     *
+     * @param value - The value to remove from the queue.
+     *
+     * @returns `true` on success, `false` otherwise.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     */
+    Queue.prototype.remove = function (value) {
+        var link = this._front;
+        var prev = null;
+        while (link !== null) {
+            if (link.value === value) {
+                if (prev === null) {
+                    this._front = link.next;
+                }
+                else {
+                    prev.next = link.next;
+                }
+                if (link.next === null) {
+                    this._back = prev;
+                }
+                this._size--;
+                return true;
+            }
+            prev = link;
+            link = link.next;
+        }
+        return false;
+    };
+    /**
+     * Remove all occurrences of a value from the queue.
+     *
+     * @param value - The value to remove from the queue.
+     *
+     * @returns The number of occurrences removed.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     */
+    Queue.prototype.removeAll = function (value) {
+        var count = 0;
+        var link = this._front;
+        var prev = null;
+        while (link !== null) {
+            if (link.value === value) {
+                count++;
+                this._size--;
+            }
+            else if (prev === null) {
+                this._front = link;
+                prev = link;
+            }
+            else {
+                prev.next = link;
+                prev = link;
+            }
+            link = link.next;
+        }
+        if (!prev) {
+            this._front = null;
+            this._back = null;
+        }
+        else {
+            prev.next = null;
+            this._back = prev;
+        }
+        return count;
+    };
+    /**
+     * Remove all values from the queue.
+     *
+     * #### Notes
+     * This has `O(1)` complexity.
+     */
+    Queue.prototype.clear = function () {
+        this._size = 0;
+        this._front = null;
+        this._back = null;
+    };
+    /**
+     * Create an array from the values in the queue.
+     *
+     * @returns An array of all values in the queue.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     */
+    Queue.prototype.toArray = function () {
+        var result = new Array(this._size);
+        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
+            result[i] = link.value;
+        }
+        return result;
+    };
+    /**
+     * Test whether any value in the queue passes a predicate function.
+     *
+     * @param pred - The predicate to apply to the values.
+     *
+     * @returns `true` if any value in the queue passes the predicate,
+     *   or `false` otherwise.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     *
+     * It is **not** safe for the predicate to modify the queue while
+     * iterating.
+     */
+    Queue.prototype.some = function (pred) {
+        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
+            if (pred(link.value, i))
+                return true;
+        }
+        return false;
+    };
+    /**
+     * Test whether all values in the queue pass a predicate function.
+     *
+     * @param pred - The predicate to apply to the values.
+     *
+     * @returns `true` if all values in the queue pass the predicate,
+     *   or `false` otherwise.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     *
+     * It is **not** safe for the predicate to modify the queue while
+     * iterating.
+     */
+    Queue.prototype.every = function (pred) {
+        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
+            if (!pred(link.value, i))
+                return false;
+        }
+        return true;
+    };
+    /**
+     * Create an array of the values which pass a predicate function.
+     *
+     * @param pred - The predicate to apply to the values.
+     *
+     * @returns The array of values which pass the predicate.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     *
+     * It is **not** safe for the predicate to modify the queue while
+     * iterating.
+     */
+    Queue.prototype.filter = function (pred) {
+        var result = [];
+        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
+            if (pred(link.value, i))
+                result.push(link.value);
+        }
+        return result;
+    };
+    /**
+     * Create an array of mapped values for the values in the queue.
+     *
+     * @param callback - The map function to apply to the values.
+     *
+     * @returns The array of values returned by the map function.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     *
+     * It is **not** safe for the callback to modify the queue while
+     * iterating.
+     */
+    Queue.prototype.map = function (callback) {
+        var result = new Array(this._size);
+        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
+            result[i] = callback(link.value, i);
+        }
+        return result;
+    };
+    /**
+     * Execute a callback for each value in the queue.
+     *
+     * @param callback - The function to apply to the values.
+     *
+     * @returns The first value returned by the callback which is not
+     *   `undefined`.
+     *
+     * #### Notes
+     * This has `O(N)` complexity.
+     *
+     * Iteration will terminate immediately if the callback returns any
+     * value other than `undefined`.
+     *
+     * It is **not** safe for the callback to modify the queue while
+     * iterating.
+     */
+    Queue.prototype.forEach = function (callback) {
+        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
+            var result = callback(link.value, i);
+            if (result !== void 0)
+                return result;
+        }
+        return void 0;
+    };
+    return Queue;
+})();
+exports.Queue = Queue;
+
+},{}],6:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+/**
+ * An object used for type-safe inter-object communication.
+ *
+ * Signals provide a type-safe implementation of the publish-subscribe
+ * pattern. An object (publisher) declares which signals it will emit,
+ * and consumers connect callbacks (subscribers) to those signals. The
+ * subscribers are invoked whenever the publisher emits the signal.
+ *
+ * A `Signal` object must be bound to a sender in order to be useful.
+ * A common pattern is to declare a `Signal` object as a static class
+ * member, along with a convenience getter which binds the signal to
+ * the `this` instance on-demand.
+ *
+ * #### Example
+ * ```typescript
+ * import { ISignal, Signal } from 'phosphor-signaling';
+ *
+ * class MyClass {
+ *
+ *   static valueChangedSignal = new Signal<MyClass, number>();
+ *
+ *   constructor(name: string) {
+ *     this._name = name;
+ *   }
+ *
+ *   get valueChanged(): ISignal<MyClass, number> {
+ *     return MyClass.valueChangedSignal.bind(this);
+ *   }
+ *
+ *   get name(): string {
+ *     return this._name;
+ *   }
+ *
+ *   get value(): number {
+ *     return this._value;
+ *   }
+ *
+ *   set value(value: number) {
+ *     if (value !== this._value) {
+ *       this._value = value;
+ *       this.valueChanged.emit(value);
+ *     }
+ *   }
+ *
+ *   private _name: string;
+ *   private _value = 0;
+ * }
+ *
+ * function logger(sender: MyClass, value: number): void {
+ *   console.log(sender.name, value);
+ * }
+ *
+ * var m1 = new MyClass('foo');
+ * var m2 = new MyClass('bar');
+ *
+ * m1.valueChanged.connect(logger);
+ * m2.valueChanged.connect(logger);
+ *
+ * m1.value = 42;  // logs: foo 42
+ * m2.value = 17;  // logs: bar 17
+ * ```
+ */
+var Signal = (function () {
+    function Signal() {
+    }
+    /**
+     * Bind the signal to a specific sender.
+     *
+     * @param sender - The sender object to bind to the signal.
+     *
+     * @returns The bound signal object which can be used for connecting,
+     *   disconnecting, and emitting the signal.
+     */
+    Signal.prototype.bind = function (sender) {
+        return new BoundSignal(this, sender);
+    };
+    return Signal;
+})();
+exports.Signal = Signal;
+/**
+ * Remove all connections where the given object is the sender.
+ *
+ * @param sender - The sender object of interest.
+ *
+ * #### Example
+ * ```typescript
+ * disconnectSender(someObject);
+ * ```
+ */
+function disconnectSender(sender) {
+    var list = senderMap.get(sender);
+    if (!list) {
+        return;
+    }
+    var conn = list.first;
+    while (conn !== null) {
+        removeFromSendersList(conn);
+        conn.callback = null;
+        conn.thisArg = null;
+        conn = conn.nextReceiver;
+    }
+    senderMap.delete(sender);
+}
+exports.disconnectSender = disconnectSender;
+/**
+ * Remove all connections where the given object is the receiver.
+ *
+ * @param receiver - The receiver object of interest.
+ *
+ * #### Notes
+ * If a `thisArg` is provided when connecting a signal, that object
+ * is considered the receiver. Otherwise, the `callback` is used as
+ * the receiver.
+ *
+ * #### Example
+ * ```typescript
+ * // disconnect a regular object receiver
+ * disconnectReceiver(myObject);
+ *
+ * // disconnect a plain callback receiver
+ * disconnectReceiver(myCallback);
+ * ```
+ */
+function disconnectReceiver(receiver) {
+    var conn = receiverMap.get(receiver);
+    if (!conn) {
+        return;
+    }
+    while (conn !== null) {
+        var next = conn.nextSender;
+        conn.callback = null;
+        conn.thisArg = null;
+        conn.prevSender = null;
+        conn.nextSender = null;
+        conn = next;
+    }
+    receiverMap.delete(receiver);
+}
+exports.disconnectReceiver = disconnectReceiver;
+/**
+ * Clear all signal data associated with the given object.
+ *
+ * @param obj - The object for which the signal data should be cleared.
+ *
+ * #### Notes
+ * This removes all signal connections where the object is used as
+ * either the sender or the receiver.
+ *
+ * #### Example
+ * ```typescript
+ * clearSignalData(someObject);
+ * ```
+ */
+function clearSignalData(obj) {
+    disconnectSender(obj);
+    disconnectReceiver(obj);
+}
+exports.clearSignalData = clearSignalData;
+/**
+ * A concrete implementation of ISignal.
+ */
+var BoundSignal = (function () {
+    /**
+     * Construct a new bound signal.
+     */
+    function BoundSignal(signal, sender) {
+        this._signal = signal;
+        this._sender = sender;
+    }
+    /**
+     * Connect a callback to the signal.
+     */
+    BoundSignal.prototype.connect = function (callback, thisArg) {
+        return connect(this._sender, this._signal, callback, thisArg);
+    };
+    /**
+     * Disconnect a callback from the signal.
+     */
+    BoundSignal.prototype.disconnect = function (callback, thisArg) {
+        return disconnect(this._sender, this._signal, callback, thisArg);
+    };
+    /**
+     * Emit the signal and invoke the connected callbacks.
+     */
+    BoundSignal.prototype.emit = function (args) {
+        emit(this._sender, this._signal, args);
+    };
+    return BoundSignal;
+})();
+/**
+ * A struct which holds connection data.
+ */
+var Connection = (function () {
+    function Connection() {
+        /**
+         * The signal for the connection.
+         */
+        this.signal = null;
+        /**
+         * The callback connected to the signal.
+         */
+        this.callback = null;
+        /**
+         * The `this` context for the callback.
+         */
+        this.thisArg = null;
+        /**
+         * The next connection in the singly linked receivers list.
+         */
+        this.nextReceiver = null;
+        /**
+         * The next connection in the doubly linked senders list.
+         */
+        this.nextSender = null;
+        /**
+         * The previous connection in the doubly linked senders list.
+         */
+        this.prevSender = null;
+    }
+    return Connection;
+})();
+/**
+ * The list of receiver connections for a specific sender.
+ */
+var ConnectionList = (function () {
+    function ConnectionList() {
+        /**
+         * The ref count for the list.
+         */
+        this.refs = 0;
+        /**
+         * The first connection in the list.
+         */
+        this.first = null;
+        /**
+         * The last connection in the list.
+         */
+        this.last = null;
+    }
+    return ConnectionList;
+})();
+/**
+ * A mapping of sender object to its receiver connection list.
+ */
+var senderMap = new WeakMap();
+/**
+ * A mapping of receiver object to its sender connection list.
+ */
+var receiverMap = new WeakMap();
+/**
+ * Create a connection between a sender, signal, and callback.
+ */
+function connect(sender, signal, callback, thisArg) {
+    // Coerce a `null` thisArg to `undefined`.
+    thisArg = thisArg || void 0;
+    // Search for an equivalent connection and bail if one exists.
+    var list = senderMap.get(sender);
+    if (list && findConnection(list, signal, callback, thisArg)) {
+        return false;
+    }
+    // Create a new connection.
+    var conn = new Connection();
+    conn.signal = signal;
+    conn.callback = callback;
+    conn.thisArg = thisArg;
+    // Add the connection to the receivers list.
+    if (!list) {
+        list = new ConnectionList();
+        list.first = conn;
+        list.last = conn;
+        senderMap.set(sender, list);
+    }
+    else if (list.last === null) {
+        list.first = conn;
+        list.last = conn;
+    }
+    else {
+        list.last.nextReceiver = conn;
+        list.last = conn;
+    }
+    // Add the connection to the senders list.
+    var receiver = thisArg || callback;
+    var head = receiverMap.get(receiver);
+    if (head) {
+        head.prevSender = conn;
+        conn.nextSender = head;
+    }
+    receiverMap.set(receiver, conn);
+    return true;
+}
+/**
+ * Break the connection between a sender, signal, and callback.
+ */
+function disconnect(sender, signal, callback, thisArg) {
+    // Coerce a `null` thisArg to `undefined`.
+    thisArg = thisArg || void 0;
+    // Search for an equivalent connection and bail if none exists.
+    var list = senderMap.get(sender);
+    if (!list) {
+        return false;
+    }
+    var conn = findConnection(list, signal, callback, thisArg);
+    if (!conn) {
+        return false;
+    }
+    // Remove the connection from the senders list. It will be removed
+    // from the receivers list the next time the signal is emitted.
+    removeFromSendersList(conn);
+    // Clear the connection data so it becomes a dead connection.
+    conn.callback = null;
+    conn.thisArg = null;
+    return true;
+}
+/**
+ * Emit a signal and invoke the connected callbacks.
+ */
+function emit(sender, signal, args) {
+    var list = senderMap.get(sender);
+    if (!list) {
+        return;
+    }
+    list.refs++;
+    try {
+        var dirty = invokeList(list, sender, signal, args);
+    }
+    finally {
+        list.refs--;
+    }
+    if (dirty && list.refs === 0) {
+        cleanList(list);
+    }
+}
+/**
+ * Find a matching connection in the given connection list.
+ *
+ * Returns `null` if no matching connection is found.
+ */
+function findConnection(list, signal, callback, thisArg) {
+    var conn = list.first;
+    while (conn !== null) {
+        if (conn.signal === signal &&
+            conn.callback === callback &&
+            conn.thisArg === thisArg) {
+            return conn;
+        }
+        conn = conn.nextReceiver;
+    }
+    return null;
+}
+/**
+ * Invoke the callbacks for the matching signals in the list.
+ *
+ * Connections added during dispatch will not be invoked. This returns
+ * `true` if there are dead connections in the list, `false` otherwise.
+ */
+function invokeList(list, sender, signal, args) {
+    var dirty = false;
+    var last = list.last;
+    var conn = list.first;
+    while (conn !== null) {
+        if (!conn.callback) {
+            dirty = true;
+        }
+        else if (conn.signal === signal) {
+            conn.callback.call(conn.thisArg, sender, args);
+        }
+        if (conn === last) {
+            break;
+        }
+        conn = conn.nextReceiver;
+    }
+    return dirty;
+}
+/**
+ * Remove the dead connections from the given connection list.
+ */
+function cleanList(list) {
+    var prev;
+    var conn = list.first;
+    while (conn !== null) {
+        var next = conn.nextReceiver;
+        if (!conn.callback) {
+            conn.nextReceiver = null;
+        }
+        else if (!prev) {
+            list.first = conn;
+            prev = conn;
+        }
+        else {
+            prev.nextReceiver = conn;
+            prev = conn;
+        }
+        conn = next;
+    }
+    if (!prev) {
+        list.first = null;
+        list.last = null;
+    }
+    else {
+        prev.nextReceiver = null;
+        list.last = prev;
+    }
+}
+/**
+ * Remove a connection from the doubly linked list of senders.
+ */
+function removeFromSendersList(conn) {
+    var receiver = conn.thisArg || conn.callback;
+    var prev = conn.prevSender;
+    var next = conn.nextSender;
+    if (prev === null && next === null) {
+        receiverMap.delete(receiver);
+    }
+    else if (prev === null) {
+        receiverMap.set(receiver, next);
+        next.prevSender = null;
+    }
+    else if (next === null) {
+        prev.nextSender = null;
+    }
+    else {
+        prev.nextSender = next;
+        next.prevSender = prev;
+    }
+    conn.prevSender = null;
+    conn.nextSender = null;
+}
+
+},{}],7:[function(require,module,exports){
+var css = "/*-----------------------------------------------------------------------------\r\n| Copyright (c) 2014-2015, PhosphorJS Contributors\r\n|\r\n| Distributed under the terms of the BSD 3-Clause License.\r\n|\r\n| The full license is in the file LICENSE, distributed with this software.\r\n|----------------------------------------------------------------------------*/\n.p-Widget {\n  box-sizing: border-box;\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n  overflow: hidden;\n  cursor: default;\n}\n.p-Widget.p-mod-hidden {\n  display: none;\n}\n"; (require("browserify-css").createStyle(css, { "href": "node_modules/phosphor-widget/lib/index.css"})); module.exports = css;
+},{"browserify-css":3}],8:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+__export(require('./title'));
+__export(require('./widget'));
+require('./index.css');
+
+},{"./index.css":7,"./title":9,"./widget":10}],9:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+var phosphor_properties_1 = require('phosphor-properties');
+/**
+ * An object which holds data related to a widget title.
+ */
+var Title = (function () {
+    function Title() {
+    }
+    Object.defineProperty(Title.prototype, "text", {
+        /**
+         * Get the text for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[textProperty]].
+         */
+        get: function () {
+            return Title.textProperty.get(this);
+        },
+        /**
+         * Set the text for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[textProperty]].
+         */
+        set: function (value) {
+            Title.textProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Title.prototype, "icon", {
+        /**
+         * Get the icon class for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[iconProperty]].
+         */
+        get: function () {
+            return Title.iconProperty.get(this);
+        },
+        /**
+         * Set the icon class for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[iconProperty]].
+         */
+        set: function (value) {
+            Title.iconProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Title.prototype, "editable", {
+        /**
+         * Get the editable state for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[editableProperty]].
+         */
+        get: function () {
+            return Title.editableProperty.get(this);
+        },
+        /**
+         * Set the editable state for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[editableProperty]].
+         */
+        set: function (value) {
+            Title.editableProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Title.prototype, "editHandler", {
+        /**
+         * Get the edit handler for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[editHandlerProperty]].
+         */
+        get: function () {
+            return Title.editHandlerProperty.get(this);
+        },
+        /**
+         * Set the edit handler for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[editHandlerProperty]].
+         */
+        set: function (value) {
+            Title.editHandlerProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Title.prototype, "closable", {
+        /**
+         * Get the closable state for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[closableProperty]].
+         */
+        get: function () {
+            return Title.closableProperty.get(this);
+        },
+        /**
+         * Set the closable state for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[closableProperty]].
+         */
+        set: function (value) {
+            Title.closableProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Title.prototype, "className", {
+        /**
+         * Get the extra class name for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[classNameProperty]].
+         */
+        get: function () {
+            return Title.classNameProperty.get(this);
+        },
+        /**
+         * Set the extra class name for the title.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[classNameProperty]].
+         */
+        set: function (value) {
+            Title.classNameProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * The property descriptor for the title text.
+     *
+     * This will be used as the display text in title contexts.
+     *
+     * The default value is an empty string.
+     *
+     * **See also:** [[text]]
+     */
+    Title.textProperty = new phosphor_properties_1.Property({
+        value: '',
+    });
+    /**
+     * The property descriptor for the title icon class.
+     *
+     * This will be added to the class name of the title icon node.
+     *
+     * Multiple class names can be separated with whitespace.
+     *
+     * The default value is an empty string.
+     *
+     * **See also:** [[icon]]
+     */
+    Title.iconProperty = new phosphor_properties_1.Property({
+        value: '',
+    });
+    /**
+     * The property descriptor for the title editable state.
+     *
+     * This controls whether the title is editable by the user.
+     *
+     * The default value is `false`.
+     *
+     * **See also:** [[editable]]
+     */
+    Title.editableProperty = new phosphor_properties_1.Property({
+        value: false,
+    });
+    /**
+     * The property descriptor for the title edit handler.
+     *
+     * If the title is user editable, this handler will be invoked when
+     * the text is edited by the user. The handler should update its own
+     * internal state and then update the title text as appropriate. If
+     * this is not provided, the title text will be updated directly.
+     *
+     * The default value is `null`.
+     *
+     * **See also:** [[editHandler]]
+     */
+    Title.editHandlerProperty = new phosphor_properties_1.Property({
+        value: null,
+    });
+    /**
+     * The property descriptor for the title closable state.
+     *
+     * This controls whether the title area shows a close icon.
+     *
+     * The default value is `false`.
+     *
+     * **See also:** [[closable]]
+     */
+    Title.closableProperty = new phosphor_properties_1.Property({
+        value: false,
+    });
+    /**
+     * The property descriptor for the title extra class name.
+     *
+     * This will be added to the class name of the title area node.
+     *
+     * Multiple class names can be separated with whitespace.
+     *
+     * The default value is an empty string.
+     *
+     * **See also:** [[className]]
+     */
+    Title.classNameProperty = new phosphor_properties_1.Property({
+        value: '',
+    });
+    return Title;
+})();
+exports.Title = Title;
+
+},{"phosphor-properties":13}],10:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var arrays = require('phosphor-arrays');
+var phosphor_messaging_1 = require('phosphor-messaging');
+var phosphor_nodewrapper_1 = require('phosphor-nodewrapper');
+var phosphor_properties_1 = require('phosphor-properties');
+var phosphor_signaling_1 = require('phosphor-signaling');
+var title_1 = require('./title');
+/**
+ * The class name added to Widget instances.
+ */
+var WIDGET_CLASS = 'p-Widget';
+/**
+ * The class name added to hidden widgets.
+ */
+var HIDDEN_CLASS = 'p-mod-hidden';
+/**
+ * The base class of the Phosphor widget hierarchy.
+ *
+ * #### Notes
+ * This class will typically be subclassed in order to create a useful
+ * widget. However, it can be used by itself to host foreign content
+ * such as a React or Bootstrap component. Simply instantiate an empty
+ * widget and add the content directly to its `.node`. The widget and
+ * its content can then be embedded within a Phosphor widget hierarchy.
+ */
+var Widget = (function (_super) {
+    __extends(Widget, _super);
+    /**
+     * Construct a new widget.
+     */
+    function Widget() {
+        _super.call(this);
+        this._flags = 0;
+        this._parent = null;
+        this._children = [];
+        this.addClass(WIDGET_CLASS);
+    }
+    /**
+     * Attach a widget to a host DOM node.
+     *
+     * @param widget - The widget to attach to the DOM.
+     *
+     * @param host - The node to use as the widget's host.
+     *
+     * @throws Will throw an error if the widget is not a root widget,
+     *   if the widget is already attached to the DOM, or if the host
+     *   is not attached to the DOM.
+     *
+     * #### Notes
+     * The function should be used in lieu of manual DOM attachment. It
+     * ensures that an `'after-attach'` message is properly dispatched
+     * to the widget hierarchy.
+     */
+    Widget.attach = function (widget, host) {
+        if (widget.parent) {
+            throw new Error('only a root widget can be attached to the DOM');
+        }
+        if (widget.isAttached || document.body.contains(widget.node)) {
+            throw new Error('widget is already attached to the DOM');
+        }
+        if (!document.body.contains(host)) {
+            throw new Error('host is not attached to the DOM');
+        }
+        host.appendChild(widget.node);
+        phosphor_messaging_1.sendMessage(widget, Widget.MsgAfterAttach);
+    };
+    /**
+     * Detach a widget from its host DOM node.
+     *
+     * @param widget - The widget to detach from the DOM.
+     *
+     * @throws Will throw an error if the widget is not a root widget,
+     *   or if the widget is not attached to the DOM.
+     *
+     * #### Notes
+     * The function should be used in lieu of manual DOM detachment. It
+     * ensures that a `'before-detach'` message is properly dispatched
+     * to the widget hierarchy.
+     */
+    Widget.detach = function (widget) {
+        if (widget.parent) {
+            throw new Error('only a root widget can be detached from the DOM');
+        }
+        if (!widget.isAttached || !document.body.contains(widget.node)) {
+            throw new Error('widget is not attached to the DOM');
+        }
+        phosphor_messaging_1.sendMessage(widget, Widget.MsgBeforeDetach);
+        widget.node.parentNode.removeChild(widget.node);
+    };
+    /**
+     * Dispose of the widget and its descendant widgets.
+     *
+     * #### Notes
+     * It is generally unsafe to use the widget after it has been
+     * disposed.
+     *
+     * If this method is called more than once, all calls made after
+     * the first will be a no-op.
+     */
+    Widget.prototype.dispose = function () {
+        if (this.isDisposed) {
+            return;
+        }
+        this._flags |= WidgetFlag.IsDisposed;
+        this.disposed.emit(void 0);
+        if (this._parent) {
+            this._parent.removeChild(this);
+        }
+        else if (this.isAttached) {
+            Widget.detach(this);
+        }
+        while (this._children.length > 0) {
+            var child = this._children.pop();
+            child._parent = null;
+            child.dispose();
+        }
+        phosphor_signaling_1.clearSignalData(this);
+        phosphor_messaging_1.clearMessageData(this);
+        phosphor_properties_1.clearPropertyData(this);
+    };
+    Object.defineProperty(Widget.prototype, "disposed", {
+        /**
+         * A signal emitted when the widget is disposed.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[disposedSignal]].
+         */
+        get: function () {
+            return Widget.disposedSignal.bind(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "isAttached", {
+        /**
+         * Test whether the widget's node is attached to the DOM.
+         *
+         * #### Notes
+         * This is a read-only property which is always safe to access.
+         *
+         * **See also:** [[attach]], [[detach]]
+         */
+        get: function () {
+            return (this._flags & WidgetFlag.IsAttached) !== 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "isDisposed", {
+        /**
+         * Test whether the widget has been disposed.
+         *
+         * #### Notes
+         * This is a read-only property which is always safe to access.
+         *
+         * **See also:** [[disposed]]
+         */
+        get: function () {
+            return (this._flags & WidgetFlag.IsDisposed) !== 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "isVisible", {
+        /**
+         * Test whether the widget is visible.
+         *
+         * #### Notes
+         * A widget is visible when it is attached to the DOM, is not
+         * explicitly hidden, and has no explicitly hidden ancestors.
+         *
+         * This is a read-only property which is always safe to access.
+         *
+         * **See also:** [[hidden]]
+         */
+        get: function () {
+            return (this._flags & WidgetFlag.IsVisible) !== 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "hidden", {
+        /**
+         * Get whether the widget is explicitly hidden.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[hiddenProperty]].
+         *
+         * **See also:** [[isVisible]]
+         */
+        get: function () {
+            return Widget.hiddenProperty.get(this);
+        },
+        /**
+         * Set whether the widget is explicitly hidden.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[hiddenProperty]].
+         *
+         * **See also:** [[isVisible]]
+         */
+        set: function (value) {
+            Widget.hiddenProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "title", {
+        /**
+         * Get the title data object for the widget.
+         *
+         * #### Notes
+         * The title data is used by some container widgets when displaying
+         * the widget along with a title, such as a tab panel or dock panel.
+         *
+         * Not all widgets will make use of the title data, so it is created
+         * on-demand the first time it is accessed.
+         */
+        get: function () {
+            return getTitle(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "parent", {
+        /**
+         * Get the parent of the widget.
+         *
+         * #### Notes
+         * This will be `null` if the widget does not have a parent.
+         */
+        get: function () {
+            return this._parent;
+        },
+        /**
+         * Set the parent of the widget.
+         *
+         * @throws Will throw an error if the widget is the parent.
+         *
+         * #### Notes
+         * If the specified parent is the current parent, this is a no-op.
+         *
+         * If the specified parent is `null`, this is equivalent to the
+         * expression `widget.parent.removeChild(widget)`, otherwise it
+         * is equivalent to the expression `parent.addChild(widget)`.
+         *
+         * **See also:** [[addChild]], [[insertChild]], [[removeChild]]
+         */
+        set: function (parent) {
+            if (parent && parent !== this._parent) {
+                parent.addChild(this);
+            }
+            else if (!parent && this._parent) {
+                this._parent.removeChild(this);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "children", {
+        /**
+         * Get a shallow copy of the array of child widgets.
+         *
+         * #### Notes
+         * When only iterating over the children, it can be faster to use
+         * the child query methods, which do not perform a copy.
+         *
+         * **See also:** [[childCount]], [[childAt]]
+         */
+        get: function () {
+            return this._children.slice();
+        },
+        /**
+         * Set the children of the widget.
+         *
+         * #### Notes
+         * This will clear the current child widgets and add the specified
+         * child widgets. Depending on the desired outcome, it can be more
+         * efficient to use one of the child manipulation methods.
+         *
+         * **See also:** [[addChild]], [[insertChild]], [[removeChild]]
+         */
+        set: function (children) {
+            var _this = this;
+            this.clearChildren();
+            children.forEach(function (child) { _this.addChild(child); });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Widget.prototype, "childCount", {
+        /**
+         * Get the number of children of the widget.
+         *
+         * #### Notes
+         * This is a read-only property.
+         *
+         * **See also:** [[children]], [[childAt]]
+         */
+        get: function () {
+            return this._children.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Get the child widget at a specific index.
+     *
+     * @param index - The index of the child of interest.
+     *
+     * @returns The child widget at the specified index, or `undefined`
+     *  if the index is out of range.
+     *
+     * **See also:** [[childCount]], [[childIndex]]
+     */
+    Widget.prototype.childAt = function (index) {
+        return this._children[index | 0];
+    };
+    /**
+     * Get the index of a specific child widget.
+     *
+     * @param child - The child widget of interest.
+     *
+     * @returns The index of the specified child widget, or `-1` if
+     *   the widget is not a child of this widget.
+     *
+     * **See also:** [[childCount]], [[childAt]]
+     */
+    Widget.prototype.childIndex = function (child) {
+        return this._children.indexOf(child);
+    };
+    /**
+     * Add a child widget to the end of the widget's children.
+     *
+     * @param child - The child widget to add to this widget.
+     *
+     * @returns The new index of the child.
+     *
+     * @throws Will throw an error if a widget is added to itself.
+     *
+     * #### Notes
+     * The child will be automatically removed from its current parent
+     * before being added to this widget.
+     *
+     * **See also:** [[insertChild]], [[moveChild]]
+     */
+    Widget.prototype.addChild = function (child) {
+        return this.insertChild(this._children.length, child);
+    };
+    /**
+     * Insert a child widget at a specific index.
+     *
+     * @param index - The target index for the widget. This will be
+     *   clamped to the bounds of the children.
+     *
+     * @param child - The child widget to insert into the widget.
+     *
+     * @returns The new index of the child.
+     *
+     * @throws Will throw an error if a widget is inserted into itself.
+     *
+     * #### Notes
+     * The child will be automatically removed from its current parent
+     * before being added to this widget.
+     *
+     * **See also:** [[addChild]], [[moveChild]]
+     */
+    Widget.prototype.insertChild = function (index, child) {
+        if (child === this) {
+            throw new Error('invalid child widget');
+        }
+        if (child._parent) {
+            child._parent.removeChild(child);
+        }
+        else if (child.isAttached) {
+            Widget.detach(child);
+        }
+        child._parent = this;
+        var i = arrays.insert(this._children, index, child);
+        phosphor_messaging_1.sendMessage(this, new ChildMessage('child-added', child, -1, i));
+        return i;
+    };
+    /**
+     * Move a child widget from one index to another.
+     *
+     * @param fromIndex - The index of the child of interest.
+     *
+     * @param toIndex - The target index for the child.
+     *
+     * @returns 'true' if the child was moved, or `false` if either
+     *   of the given indices are out of range.
+     *
+     * #### Notes
+     * This method can be more efficient than re-inserting an existing
+     * child, as some widgets may be able to optimize child moves and
+     * avoid making unnecessary changes to the DOM.
+     *
+     * **See also:** [[addChild]], [[insertChild]]
+     */
+    Widget.prototype.moveChild = function (fromIndex, toIndex) {
+        var i = fromIndex | 0;
+        var j = toIndex | 0;
+        if (!arrays.move(this._children, i, j)) {
+            return false;
+        }
+        if (i !== j) {
+            var child = this._children[j];
+            phosphor_messaging_1.sendMessage(this, new ChildMessage('child-moved', child, i, j));
+        }
+        return true;
+    };
+    /**
+     * Remove the child widget at a specific index.
+     *
+     * @param index - The index of the child of interest.
+     *
+     * @returns The removed child widget, or `undefined` if the index
+     *   is out of range.
+     *
+     * **See also:** [[removeChild]], [[clearChildren]]
+     */
+    Widget.prototype.removeChildAt = function (index) {
+        var i = index | 0;
+        var child = arrays.removeAt(this._children, i);
+        if (child) {
+            child._parent = null;
+            phosphor_messaging_1.sendMessage(this, new ChildMessage('child-removed', child, i, -1));
+        }
+        return child;
+    };
+    /**
+     * Remove a specific child widget from this widget.
+     *
+     * @param child - The child widget of interest.
+     *
+     * @returns The index which the child occupied, or `-1` if the
+     *   child is not a child of this widget.
+     *
+     * **See also:** [[removeChildAt]], [[clearChildren]]
+     */
+    Widget.prototype.removeChild = function (child) {
+        var i = this.childIndex(child);
+        if (i !== -1)
+            this.removeChildAt(i);
+        return i;
+    };
+    /**
+     * Remove all child widgets from the widget.
+     *
+     * #### Notes
+     * This will continue to remove children until the `childCount`
+     * reaches zero. It is therefore possible to enter an infinite
+     * loop if a message handler causes a child widget to be added
+     * in response to one being removed.
+     *
+     * **See also:** [[removeChild]], [[removeChildAt]]
+     */
+    Widget.prototype.clearChildren = function () {
+        while (this.childCount > 0) {
+            this.removeChildAt(this.childCount - 1);
+        }
+    };
+    /**
+     * Dispatch an `'update-request'` message to the widget.
+     *
+     * @param immediate - Whether to dispatch the message immediately
+     *   (`true`) or in the future (`false`). The default is `false`.
+     *
+     * **See also:** [[MsgUpdateRequest]], [[onUpdateRequest]]
+     */
+    Widget.prototype.update = function (immediate) {
+        if (immediate === void 0) { immediate = false; }
+        if (immediate) {
+            phosphor_messaging_1.sendMessage(this, Widget.MsgUpdateRequest);
+        }
+        else {
+            phosphor_messaging_1.postMessage(this, Widget.MsgUpdateRequest);
+        }
+    };
+    /**
+     * Dispatch a `'close-request'` message to the widget.
+     *
+     * @param immediate - Whether to dispatch the message immediately
+     *   (`true`) or in the future (`false`). The default is `false`.
+     *
+     * **See also:** [[MsgCloseRequest]], [[onCloseRequest]]
+     */
+    Widget.prototype.close = function (immediate) {
+        if (immediate === void 0) { immediate = false; }
+        if (immediate) {
+            phosphor_messaging_1.sendMessage(this, Widget.MsgCloseRequest);
+        }
+        else {
+            phosphor_messaging_1.postMessage(this, Widget.MsgCloseRequest);
+        }
+    };
+    /**
+     * Process a message sent to the widget.
+     *
+     * @param msg - The message sent to the widget.
+     *
+     * #### Notes
+     * Subclasses may reimplement this method as needed.
+     */
+    Widget.prototype.processMessage = function (msg) {
+        switch (msg.type) {
+            case 'resize':
+                this.onResize(msg);
+                break;
+            case 'update-request':
+                this.onUpdateRequest(msg);
+                break;
+            case 'layout-request':
+                this.onLayoutRequest(msg);
+                break;
+            case 'child-added':
+                this.onChildAdded(msg);
+                break;
+            case 'child-removed':
+                this.onChildRemoved(msg);
+                break;
+            case 'child-moved':
+                this.onChildMoved(msg);
+                break;
+            case 'after-show':
+                this._flags |= WidgetFlag.IsVisible;
+                this.onAfterShow(msg);
+                sendToShown(this._children, msg);
+                break;
+            case 'before-hide':
+                this.onBeforeHide(msg);
+                sendToShown(this._children, msg);
+                this._flags &= ~WidgetFlag.IsVisible;
+                break;
+            case 'after-attach':
+                var visible = !this.hidden && (!this._parent || this._parent.isVisible);
+                if (visible)
+                    this._flags |= WidgetFlag.IsVisible;
+                this._flags |= WidgetFlag.IsAttached;
+                this.onAfterAttach(msg);
+                sendToAll(this._children, msg);
+                break;
+            case 'before-detach':
+                this.onBeforeDetach(msg);
+                sendToAll(this._children, msg);
+                this._flags &= ~WidgetFlag.IsVisible;
+                this._flags &= ~WidgetFlag.IsAttached;
+                break;
+            case 'child-shown':
+                this.onChildShown(msg);
+                break;
+            case 'child-hidden':
+                this.onChildHidden(msg);
+                break;
+            case 'close-request':
+                this.onCloseRequest(msg);
+                break;
+        }
+    };
+    /**
+     * Compress a message posted to the widget.
+     *
+     * @param msg - The message posted to the widget.
+     *
+     * @param pending - The queue of pending messages for the widget.
+     *
+     * @returns `true` if the message was compressed and should be
+     *   dropped, or `false` if the message should be enqueued for
+     *   delivery as normal.
+     *
+     * #### Notes
+     * The default implementation compresses the following messages:
+     * `'update-request'`, `'layout-request'`, and `'close-request'`.
+     *
+     * Subclasses may reimplement this method as needed.
+     */
+    Widget.prototype.compressMessage = function (msg, pending) {
+        switch (msg.type) {
+            case 'update-request':
+            case 'layout-request':
+            case 'close-request':
+                return pending.some(function (other) { return other.type === msg.type; });
+        }
+        return false;
+    };
+    /**
+     * A message handler invoked on a `'child-added'` message.
+     *
+     * #### Notes
+     * The default implementation adds the child node to the widget
+     * node at the proper location and dispatches an `'after-attach'`
+     * message if appropriate.
+     *
+     * Subclasses may reimplement this method to control how the child
+     * node is added, but they must dispatch an `'after-attach'` message
+     * if appropriate.
+     */
+    Widget.prototype.onChildAdded = function (msg) {
+        var next = this.childAt(msg.currentIndex + 1);
+        this.node.insertBefore(msg.child.node, next && next.node);
+        if (this.isAttached)
+            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgAfterAttach);
+    };
+    /**
+     * A message handler invoked on a `'child-removed'` message.
+     *
+     * #### Notes
+     * The default implementation removes the child node from the widget
+     * node and dispatches a `'before-detach'` message if appropriate.
+     *
+     * Subclasses may reimplement this method to control how the child
+     * node is removed, but they must  dispatch a `'before-detach'`
+     * message if appropriate.
+     */
+    Widget.prototype.onChildRemoved = function (msg) {
+        if (this.isAttached)
+            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgBeforeDetach);
+        this.node.removeChild(msg.child.node);
+    };
+    /**
+     * A message handler invoked on a `'child-moved'` message.
+     *
+     * #### Notes
+     * The default implementation moves the child node to the proper
+     * location in the widget node and dispatches a `'before-detach'`
+     * and `'after-attach'` message if appropriate.
+     *
+     * Subclasses may reimplement this method to control how the child
+     * node is moved, but they must dispatch a `'before-detach'` and
+     * `'after-attach'` message if appropriate.
+     */
+    Widget.prototype.onChildMoved = function (msg) {
+        if (this.isAttached)
+            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgBeforeDetach);
+        var next = this.childAt(msg.currentIndex + 1);
+        this.node.insertBefore(msg.child.node, next && next.node);
+        if (this.isAttached)
+            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgAfterAttach);
+    };
+    /**
+     * A message handler invoked on a `'resize'` message.
+     *
+     * #### Notes
+     * The default implementation of this handler sends an [[UnknownSize]]
+     * resize message to each child. This ensures that the resize messages
+     * propagate through all widgets in the hierarchy.
+     *
+     * Subclasses may reimplement this method as needed, but they must
+     * dispatch `'resize'` messages to their children as appropriate.
+     */
+    Widget.prototype.onResize = function (msg) {
+        sendToAll(this._children, ResizeMessage.UnknownSize);
+    };
+    /**
+     * A message handler invoked on an `'update-request'` message.
+     *
+     * #### Notes
+     * The default implementation of this handler sends an [[UnknownSize]]
+     * resize message to each child. This ensures that the resize messages
+     * propagate through all widgets in the hierarchy.
+     *
+     * Subclass may reimplement this method as needed, but they should
+     * dispatch `'resize'` messages to their children as appropriate.
+     *
+     * **See also:** [[update]], [[MsgUpdateRequest]]
+     */
+    Widget.prototype.onUpdateRequest = function (msg) {
+        sendToAll(this._children, ResizeMessage.UnknownSize);
+    };
+    /**
+     * A message handler invoked on a `'close-request'` message.
+     *
+     * #### Notes
+     * The default implementation of this handler will unparent or detach
+     * the widget as appropriate. Subclasses may reimplement this handler
+     * for custom close behavior.
+     *
+     * **See also:** [[close]], [[MsgCloseRequest]]
+     */
+    Widget.prototype.onCloseRequest = function (msg) {
+        if (this._parent) {
+            this._parent.removeChild(this);
+        }
+        else if (this.isAttached) {
+            Widget.detach(this);
+        }
+    };
+    /**
+     * A message handler invoked on a `'layout-request'` message.
+     *
+     * The default implementation of this handler is a no-op.
+     *
+     * **See also:** [[MsgLayoutRequest]]
+     */
+    Widget.prototype.onLayoutRequest = function (msg) { };
+    /**
+     * A message handler invoked on an `'after-show'` message.
+     *
+     * The default implementation of this handler is a no-op.
+     *
+     * **See also:** [[MsgAfterShow]]
+     */
+    Widget.prototype.onAfterShow = function (msg) { };
+    /**
+     * A message handler invoked on a `'before-hide'` message.
+     *
+     * The default implementation of this handler is a no-op.
+     *
+     * **See also:** [[MsgBeforeHide]]
+     */
+    Widget.prototype.onBeforeHide = function (msg) { };
+    /**
+     * A message handler invoked on an `'after-attach'` message.
+     *
+     * The default implementation of this handler is a no-op.
+     *
+     * **See also:** [[MsgAfterAttach]]
+     */
+    Widget.prototype.onAfterAttach = function (msg) { };
+    /**
+     * A message handler invoked on a `'before-detach'` message.
+     *
+     * The default implementation of this handler is a no-op.
+     *
+     * **See also:** [[MsgBeforeDetach]]
+     */
+    Widget.prototype.onBeforeDetach = function (msg) { };
+    /**
+     * A message handler invoked on a `'child-shown'` message.
+     *
+     * The default implementation of this handler is a no-op.
+     */
+    Widget.prototype.onChildShown = function (msg) { };
+    /**
+     * A message handler invoked on a `'child-hidden'` message.
+     *
+     * The default implementation of this handler is a no-op.
+     */
+    Widget.prototype.onChildHidden = function (msg) { };
+    /**
+     * A singleton `'update-request'` message.
+     *
+     * #### Notes
+     * This message can be dispatched to supporting widgets in order to
+     * update their content. Not all widgets will respond to messages of
+     * this type.
+     *
+     * This message is typically used to update the position and size of
+     * a widget's children, or to update a widget's content to reflect the
+     * current state of the widget.
+     *
+     * Messages of this type are compressed by default.
+     *
+     * **See also:** [[update]], [[onUpdateRequest]]
+     */
+    Widget.MsgUpdateRequest = new phosphor_messaging_1.Message('update-request');
+    /**
+     * A singleton `'layout-request'` message.
+     *
+     * #### Notes
+     * This message can be dispatched to supporting widgets in order to
+     * update their layout. Not all widgets will respond to messages of
+     * this type.
+     *
+     * This message is typically used to update the size contraints of
+     * a widget and to update the position and size of its children.
+     *
+     * Messages of this type are compressed by default.
+     *
+     * **See also:** [[onLayoutRequest]]
+     */
+    Widget.MsgLayoutRequest = new phosphor_messaging_1.Message('layout-request');
+    /**
+     * A singleton `'close-request'` message.
+     *
+     * #### Notes
+     * This message should be dispatched to a widget when it should close
+     * and remove itself from the widget hierarchy.
+     *
+     * Messages of this type are compressed by default.
+     *
+     * **See also:** [[close]], [[onCloseRequest]]
+     */
+    Widget.MsgCloseRequest = new phosphor_messaging_1.Message('close-request');
+    /**
+     * A singleton `'after-show'` message.
+     *
+     * #### Notes
+     * This message is sent to a widget when it becomes visible.
+     *
+     * This message is **not** sent when the widget is attached.
+     *
+     * **See also:** [[isVisible]], [[onAfterShow]]
+     */
+    Widget.MsgAfterShow = new phosphor_messaging_1.Message('after-show');
+    /**
+     * A singleton `'before-hide'` message.
+     *
+     * #### Notes
+     * This message is sent to a widget when it becomes not-visible.
+     *
+     * This message is **not** sent when the widget is detached.
+     *
+     * **See also:** [[isVisible]], [[onBeforeHide]]
+     */
+    Widget.MsgBeforeHide = new phosphor_messaging_1.Message('before-hide');
+    /**
+     * A singleton `'after-attach'` message.
+     *
+     * #### Notes
+     * This message is sent to a widget after it is attached to the DOM.
+     *
+     * **See also:** [[isAttached]], [[onAfterAttach]]
+     */
+    Widget.MsgAfterAttach = new phosphor_messaging_1.Message('after-attach');
+    /**
+     * A singleton `'before-detach'` message.
+     *
+     * #### Notes
+     * This message is sent to a widget before it is detached from the DOM.
+     *
+     * **See also:** [[isAttached]], [[onBeforeDetach]]
+     */
+    Widget.MsgBeforeDetach = new phosphor_messaging_1.Message('before-detach');
+    /**
+     * A signal emitted when the widget is disposed.
+     *
+     * **See also:** [[disposed]], [[isDisposed]]
+     */
+    Widget.disposedSignal = new phosphor_signaling_1.Signal();
+    /**
+     * A property descriptor which controls the hidden state of a widget.
+     *
+     * #### Notes
+     * This property controls whether a widget is explicitly hidden.
+     *
+     * Hiding a widget will cause the widget and all of its descendants
+     * to become not-visible.
+     *
+     * This property will toggle the presence of `'p-mod-hidden'` on a
+     * widget. It will also dispatch `'after-show'` and `'before-hide'`
+     * messages as appropriate.
+     *
+     * The default property value is `false`.
+     *
+     * **See also:** [[hidden]], [[isVisible]]
+     */
+    Widget.hiddenProperty = new phosphor_properties_1.Property({
+        value: false,
+        changed: onHiddenChanged,
+    });
+    return Widget;
+})(phosphor_nodewrapper_1.NodeWrapper);
+exports.Widget = Widget;
+/**
+ * A message class for child-related messages.
+ */
+var ChildMessage = (function (_super) {
+    __extends(ChildMessage, _super);
+    /**
+     * Construct a new child message.
+     *
+     * @param type - The message type.
+     *
+     * @param child - The child widget for the message.
+     *
+     * @param previousIndex - The previous index of the child, if known.
+     *   The default index is `-1` and indicates an unknown index.
+     *
+     * @param currentIndex - The current index of the child, if known.
+     *   The default index is `-1` and indicates an unknown index.
+     */
+    function ChildMessage(type, child, previousIndex, currentIndex) {
+        if (previousIndex === void 0) { previousIndex = -1; }
+        if (currentIndex === void 0) { currentIndex = -1; }
+        _super.call(this, type);
+        this._child = child;
+        this._currentIndex = currentIndex;
+        this._previousIndex = previousIndex;
+    }
+    Object.defineProperty(ChildMessage.prototype, "child", {
+        /**
+         * The child widget for the message.
+         *
+         * #### Notes
+         * This is a read-only property.
+         */
+        get: function () {
+            return this._child;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ChildMessage.prototype, "currentIndex", {
+        /**
+         * The current index of the child.
+         *
+         * #### Notes
+         * This will be `-1` if the current index is unknown.
+         *
+         * This is a read-only property.
+         */
+        get: function () {
+            return this._currentIndex;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ChildMessage.prototype, "previousIndex", {
+        /**
+         * The previous index of the child.
+         *
+         * #### Notes
+         * This will be `-1` if the previous index is unknown.
+         *
+         * This is a read-only property.
+         */
+        get: function () {
+            return this._previousIndex;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ChildMessage;
+})(phosphor_messaging_1.Message);
+exports.ChildMessage = ChildMessage;
+/**
+ * A message class for `'resize'` messages.
+ */
+var ResizeMessage = (function (_super) {
+    __extends(ResizeMessage, _super);
+    /**
+     * Construct a new resize message.
+     *
+     * @param width - The **offset width** of the widget, or `-1` if
+     *   the width is not known.
+     *
+     * @param height - The **offset height** of the widget, or `-1` if
+     *   the height is not known.
+     */
+    function ResizeMessage(width, height) {
+        _super.call(this, 'resize');
+        this._width = width;
+        this._height = height;
+    }
+    Object.defineProperty(ResizeMessage.prototype, "width", {
+        /**
+         * The offset width of the widget.
+         *
+         * #### Notes
+         * This will be `-1` if the width is unknown.
+         *
+         * This is a read-only property.
+         */
+        get: function () {
+            return this._width;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ResizeMessage.prototype, "height", {
+        /**
+         * The offset height of the widget.
+         *
+         * #### Notes
+         * This will be `-1` if the height is unknown.
+         *
+         * This is a read-only property.
+         */
+        get: function () {
+            return this._height;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * A singleton `'resize'` message with an unknown size.
+     */
+    ResizeMessage.UnknownSize = new ResizeMessage(-1, -1);
+    return ResizeMessage;
+})(phosphor_messaging_1.Message);
+exports.ResizeMessage = ResizeMessage;
+/**
+ * An enum of widget bit flags.
+ */
+var WidgetFlag;
+(function (WidgetFlag) {
+    /**
+     * The widget is attached to the DOM.
+     */
+    WidgetFlag[WidgetFlag["IsAttached"] = 1] = "IsAttached";
+    /**
+     * The widget is visible.
+     */
+    WidgetFlag[WidgetFlag["IsVisible"] = 2] = "IsVisible";
+    /**
+     * The widget has been disposed.
+     */
+    WidgetFlag[WidgetFlag["IsDisposed"] = 4] = "IsDisposed";
+})(WidgetFlag || (WidgetFlag = {}));
+/**
+ * A private attached property for the title data for a widget.
+ */
+var titleProperty = new phosphor_properties_1.Property({
+    create: function () { return new title_1.Title(); },
+});
+/**
+ * Lookup the title data for the given widget.
+ */
+function getTitle(widget) {
+    return titleProperty.get(widget);
+}
+/**
+ * The change handler for the [[hiddenProperty]].
+ */
+function onHiddenChanged(owner, old, hidden) {
+    if (hidden) {
+        if (owner.isAttached && (!owner.parent || owner.parent.isVisible)) {
+            phosphor_messaging_1.sendMessage(owner, Widget.MsgBeforeHide);
+        }
+        owner.addClass(HIDDEN_CLASS);
+        if (owner.parent) {
+            phosphor_messaging_1.sendMessage(owner.parent, new ChildMessage('child-hidden', owner));
+        }
+    }
+    else {
+        owner.removeClass(HIDDEN_CLASS);
+        if (owner.isAttached && (!owner.parent || owner.parent.isVisible)) {
+            phosphor_messaging_1.sendMessage(owner, Widget.MsgAfterShow);
+        }
+        if (owner.parent) {
+            phosphor_messaging_1.sendMessage(owner.parent, new ChildMessage('child-shown', owner));
+        }
+    }
+}
+/**
+ * Send a message to all widgets in an array.
+ */
+function sendToAll(widgets, msg) {
+    widgets.forEach(function (w) { phosphor_messaging_1.sendMessage(w, msg); });
+}
+/**
+ * Send a message to all non-hidden widgets in an array.
+ */
+function sendToShown(widgets, msg) {
+    widgets.forEach(function (w) { if (!w.hidden)
+        phosphor_messaging_1.sendMessage(w, msg); });
+}
+
+},{"./title":9,"phosphor-arrays":11,"phosphor-messaging":4,"phosphor-nodewrapper":12,"phosphor-properties":13,"phosphor-signaling":6}],11:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+/**
+ * Execute a callback for each element in an array.
+ *
+ * @param array - The array of values to iterate.
+ *
+ * @param callback - The callback to invoke for the array elements.
+ *
+ * @param fromIndex - The starting index for iteration.
+ *
+ * @param wrap - Whether iteration wraps around at the end of the array.
+ *
+ * @returns The first value returned by `callback` which is not
+ *   equal to `undefined`, or `undefined` if the callback does
+ *   not return a value or if the start index is out of range.
+ *
+ * #### Notes
+ * It is not safe to modify the size of the array while iterating.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function logger(value: number): void {
+ *   console.log(value);
+ * }
+ *
+ * var data = [1, 2, 3, 4];
+ * arrays.forEach(data, logger);           // logs 1, 2, 3, 4
+ * arrays.forEach(data, logger, 2);        // logs 3, 4
+ * arrays.forEach(data, logger, 2, true);  // logs 3, 4, 1, 2
+ * arrays.forEach(data, (v, i) => {        // 2
+ *   if (v === 3) return i;
+ * });
+ * ```
+ *
+ * **See also** [[rforEach]]
+ */
+function forEach(array, callback, fromIndex, wrap) {
+    if (fromIndex === void 0) { fromIndex = 0; }
+    if (wrap === void 0) { wrap = false; }
+    var start = fromIndex | 0;
+    if (start < 0 || start >= array.length) {
+        return void 0;
+    }
+    if (wrap) {
+        for (var i = 0, n = array.length; i < n; ++i) {
+            var j = (start + i) % n;
+            var result = callback(array[j], j);
+            if (result !== void 0)
+                return result;
+        }
+    }
+    else {
+        for (var i = start, n = array.length; i < n; ++i) {
+            var result = callback(array[i], i);
+            if (result !== void 0)
+                return result;
+        }
+    }
+    return void 0;
+}
+exports.forEach = forEach;
+/**
+ * Execute a callback for each element in an array, in reverse.
+ *
+ * @param array - The array of values to iterate.
+ *
+ * @param callback - The callback to invoke for the array elements.
+ *
+ * @param fromIndex - The starting index for iteration.
+ *
+ * @param wrap - Whether iteration wraps around at the end of the array.
+ *
+ * @returns The first value returned by `callback` which is not
+ *   equal to `undefined`, or `undefined` if the callback does
+ *   not return a value or if the start index is out of range.
+ *
+ * #### Notes
+ * It is not safe to modify the size of the array while iterating.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function logger(value: number): void {
+ *   console.log(value);
+ * }
+ *
+ * var data = [1, 2, 3, 4];
+ * arrays.rforEach(data, logger);           // logs 4, 3, 2, 1
+ * arrays.rforEach(data, logger, 2);        // logs 3, 2, 1
+ * arrays.rforEach(data, logger, 2, true);  // logs 3, 2, 1, 4
+ * arrays.rforEach(data, (v, i) => {        // 2
+ *   if (v === 3) return i;
+ * });
+ * ```
+ * **See also** [[forEach]]
+ */
+function rforEach(array, callback, fromIndex, wrap) {
+    if (fromIndex === void 0) { fromIndex = array.length - 1; }
+    if (wrap === void 0) { wrap = false; }
+    var start = fromIndex | 0;
+    if (start < 0 || start >= array.length) {
+        return void 0;
+    }
+    if (wrap) {
+        for (var i = 0, n = array.length; i < n; ++i) {
+            var j = (start - i + n) % n;
+            var result = callback(array[j], j);
+            if (result !== void 0)
+                return result;
+        }
+    }
+    else {
+        for (var i = start; i >= 0; --i) {
+            var result = callback(array[i], i);
+            if (result !== void 0)
+                return result;
+        }
+    }
+    return void 0;
+}
+exports.rforEach = rforEach;
+/**
+ * Find the index of the first value which matches a predicate.
+ *
+ * @param array - The array of values to be searched.
+ *
+ * @param pred - The predicate function to apply to the values.
+ *
+ * @param fromIndex - The starting index of the search.
+ *
+ * @param wrap - Whether the search wraps around at the end of the array.
+ *
+ * @returns The index of the first matching value, or `-1` if no value
+ *   matches the predicate or if the start index is out of range.
+ *
+ * #### Notes
+ * It is not safe to modify the size of the array while iterating.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * var data = [1, 2, 3, 4, 3, 2, 1];
+ * arrays.findIndex(data, isEven);           // 1
+ * arrays.findIndex(data, isEven, 4);        // 5
+ * arrays.findIndex(data, isEven, 6);        // -1
+ * arrays.findIndex(data, isEven, 6, true);  // 1
+ * ```
+ *
+ * **See also** [[rfindIndex]].
+ */
+function findIndex(array, pred, fromIndex, wrap) {
+    if (fromIndex === void 0) { fromIndex = 0; }
+    if (wrap === void 0) { wrap = false; }
+    var start = fromIndex | 0;
+    if (start < 0 || start >= array.length) {
+        return -1;
+    }
+    if (wrap) {
+        for (var i = 0, n = array.length; i < n; ++i) {
+            var j = (start + i) % n;
+            if (pred(array[j], j))
+                return j;
+        }
+    }
+    else {
+        for (var i = start, n = array.length; i < n; ++i) {
+            if (pred(array[i], i))
+                return i;
+        }
+    }
+    return -1;
+}
+exports.findIndex = findIndex;
+/**
+ * Find the index of the last value which matches a predicate.
+ *
+ * @param array - The array of values to be searched.
+ *
+ * @param pred - The predicate function to apply to the values.
+ *
+ * @param fromIndex - The starting index of the search.
+ *
+ * @param wrap - Whether the search wraps around at the front of the array.
+ *
+ * @returns The index of the last matching value, or `-1` if no value
+ *   matches the predicate or if the start index is out of range.
+ *
+ * #### Notes
+ * It is not safe to modify the size of the array while iterating.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * var data = [1, 2, 3, 4, 3, 2, 1];
+ * arrays.rfindIndex(data, isEven);           // 5
+ * arrays.rfindIndex(data, isEven, 4);        // 3
+ * arrays.rfindIndex(data, isEven, 0);        // -1
+ * arrays.rfindIndex(data, isEven, 0, true);  // 5
+ * ```
+ *
+ * **See also** [[findIndex]].
+ */
+function rfindIndex(array, pred, fromIndex, wrap) {
+    if (fromIndex === void 0) { fromIndex = array.length - 1; }
+    if (wrap === void 0) { wrap = false; }
+    var start = fromIndex | 0;
+    if (start < 0 || start >= array.length) {
+        return -1;
+    }
+    if (wrap) {
+        for (var i = 0, n = array.length; i < n; ++i) {
+            var j = (start - i + n) % n;
+            if (pred(array[j], j))
+                return j;
+        }
+    }
+    else {
+        for (var i = start; i >= 0; --i) {
+            if (pred(array[i], i))
+                return i;
+        }
+    }
+    return -1;
+}
+exports.rfindIndex = rfindIndex;
+/**
+ * Find the first value which matches a predicate.
+ *
+ * @param array - The array of values to be searched.
+ *
+ * @param pred - The predicate function to apply to the values.
+ *
+ * @param fromIndex - The starting index of the search.
+ *
+ * @param wrap - Whether the search wraps around at the end of the array.
+ *
+ * @returns The first matching value, or `undefined` if no value matches
+ *   the predicate or if the start index is out of range.
+ *
+ * #### Notes
+ * It is not safe to modify the size of the array while iterating.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * var data = [1, 2, 3, 4, 3, 2, 1];
+ * arrays.find(data, isEven);           // 2
+ * arrays.find(data, isEven, 4);        // 2
+ * arrays.find(data, isEven, 6);        // undefined
+ * arrays.find(data, isEven, 6, true);  // 2
+ * ```
+ *
+ * **See also** [[rfind]].
+ */
+function find(array, pred, fromIndex, wrap) {
+    var i = findIndex(array, pred, fromIndex, wrap);
+    return i !== -1 ? array[i] : void 0;
+}
+exports.find = find;
+/**
+ * Find the last value which matches a predicate.
+ *
+ * @param array - The array of values to be searched.
+ *
+ * @param pred - The predicate function to apply to the values.
+ *
+ * @param fromIndex - The starting index of the search.
+ *
+ * @param wrap - Whether the search wraps around at the front of the array.
+ *
+ * @returns The last matching value, or `undefined` if no value matches
+ *   the predicate or if the start index is out of range.
+ *
+ * #### Notes
+ * The range of visited indices is set before the first invocation of
+ * `pred`. It is not safe for `pred` to change the length of `array`.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * var data = [1, 2, 3, 4, 3, 2, 1];
+ * arrays.rfind(data, isEven);           // 2
+ * arrays.rfind(data, isEven, 4);        // 4
+ * arrays.rfind(data, isEven, 0);        // undefined
+ * arrays.rfind(data, isEven, 0, true);  // 2
+ * ```
+ *
+ * **See also** [[find]].
+ */
+function rfind(array, pred, fromIndex, wrap) {
+    var i = rfindIndex(array, pred, fromIndex, wrap);
+    return i !== -1 ? array[i] : void 0;
+}
+exports.rfind = rfind;
+/**
+ * Insert an element into an array at a specified index.
+ *
+ * @param array - The array of values to modify.
+ *
+ * @param index - The index at which to insert the value. This value
+ *   is clamped to the bounds of the array.
+ *
+ * @param value - The value to insert into the array.
+ *
+ * @returns The index at which the value was inserted.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * var data = [0, 1, 2, 3, 4];
+ * arrays.insert(data, 0, 12);  // 0
+ * arrays.insert(data, 3, 42);  // 3
+ * arrays.insert(data, -9, 9);  // 0
+ * arrays.insert(data, 12, 8);  // 8
+ * console.log(data);           // [9, 12, 0, 1, 42, 2, 3, 4, 8]
+ * ```
+ *
+ * **See also** [[removeAt]] and [[remove]]
+ */
+function insert(array, index, value) {
+    var j = Math.max(0, Math.min(index | 0, array.length));
+    for (var i = array.length; i > j; --i) {
+        array[i] = array[i - 1];
+    }
+    array[j] = value;
+    return j;
+}
+exports.insert = insert;
+/**
+ * Move an element in an array from one index to another.
+ *
+ * @param array - The array of values to modify.
+ *
+ * @param fromIndex - The index of the element to move.
+ *
+ * @param toIndex - The target index of the element.
+ *
+ * @returns `true` if the element was moved, or `false` if either
+ *   index is out of range.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * var data = [0, 1, 2, 3, 4];
+ * arrays.move(data, 1, 2);   // true
+ * arrays.move(data, -1, 0);  // false
+ * arrays.move(data, 4, 2);   // true
+ * arrays.move(data, 10, 0);  // false
+ * console.log(data);         // [0, 2, 4, 1, 3]
+ * ```
+ */
+function move(array, fromIndex, toIndex) {
+    var j = fromIndex | 0;
+    if (j < 0 || j >= array.length) {
+        return false;
+    }
+    var k = toIndex | 0;
+    if (k < 0 || k >= array.length) {
+        return false;
+    }
+    var value = array[j];
+    if (j > k) {
+        for (var i = j; i > k; --i) {
+            array[i] = array[i - 1];
+        }
+    }
+    else if (j < k) {
+        for (var i = j; i < k; ++i) {
+            array[i] = array[i + 1];
+        }
+    }
+    array[k] = value;
+    return true;
+}
+exports.move = move;
+/**
+ * Remove an element from an array at a specified index.
+ *
+ * @param array - The array of values to modify.
+ *
+ * @param index - The index of the element to remove.
+ *
+ * @returns The removed value, or `undefined` if the index is out
+ *   of range.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * var data = [0, 1, 2, 3, 4];
+ * arrays.removeAt(data, 1);   // 1
+ * arrays.removeAt(data, 3);   // 4
+ * arrays.removeAt(data, 10);  // undefined
+ * console.log(data);          // [0, 2, 3]
+ * ```
+ *
+ * **See also** [[remove]] and [[insert]]
+ */
+function removeAt(array, index) {
+    var j = index | 0;
+    if (j < 0 || j >= array.length) {
+        return void 0;
+    }
+    var value = array[j];
+    for (var i = j + 1, n = array.length; i < n; ++i) {
+        array[i - 1] = array[i];
+    }
+    array.length -= 1;
+    return value;
+}
+exports.removeAt = removeAt;
+/**
+ * Remove the first occurrence of a value from an array.
+ *
+ * @param array - The array of values to modify.
+ *
+ * @param value - The value to remove from the array.
+ *
+ * @returns The index where the value was located, or `-1` if the
+ *   value is not the array.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * var data = [0, 1, 2, 3, 4];
+ * arrays.remove(data, 1);  // 1
+ * arrays.remove(data, 3);  // 2
+ * arrays.remove(data, 7);  // -1
+ * console.log(data);       // [0, 2, 4]
+ * ```
+ *
+ * **See also** [[removeAt]] and [[insert]]
+ */
+function remove(array, value) {
+    var j = -1;
+    for (var i = 0, n = array.length; i < n; ++i) {
+        if (array[i] === value) {
+            j = i;
+            break;
+        }
+    }
+    if (j === -1) {
+        return -1;
+    }
+    for (var i = j + 1, n = array.length; i < n; ++i) {
+        array[i - 1] = array[i];
+    }
+    array.length -= 1;
+    return j;
+}
+exports.remove = remove;
+/**
+ * Reverse an array in-place subject to an optional range.
+ *
+ * @param array - The array to reverse.
+ *
+ * @param fromIndex - The index of the first element of the range.
+ *   This value will be clamped to the array bounds.
+ *
+ * @param toIndex - The index of the last element of the range.
+ *   This value will be clamped to the array bounds.
+ *
+ * @returns A reference to the original array.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * var data = [0, 1, 2, 3, 4];
+ * arrays.reverse(data, 1, 3);    // [0, 3, 2, 1, 4]
+ * arrays.reverse(data, 3);       // [0, 3, 2, 4, 1]
+ * arrays.reverse(data);          // [1, 4, 2, 3, 0]
+ * ```
+ *
+ * **See also** [[rotate]]
+ */
+function reverse(array, fromIndex, toIndex) {
+    if (fromIndex === void 0) { fromIndex = 0; }
+    if (toIndex === void 0) { toIndex = array.length; }
+    var i = Math.max(0, Math.min(fromIndex | 0, array.length - 1));
+    var j = Math.max(0, Math.min(toIndex | 0, array.length - 1));
+    if (j < i)
+        i = j + (j = i, 0);
+    while (i < j) {
+        var tmpval = array[i];
+        array[i++] = array[j];
+        array[j--] = tmpval;
+    }
+    return array;
+}
+exports.reverse = reverse;
+/**
+ * Rotate the elements of an array by a positive or negative delta.
+ *
+ * @param array - The array to rotate.
+ *
+ * @param delta - The amount of rotation to apply to the elements. A
+ *   positive delta will shift the elements to the left. A negative
+ *   delta will shift the elements to the right.
+ *
+ * @returns A reference to the original array.
+ *
+ * #### Notes
+ * This executes in `O(n)` time and `O(1)` space.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * var data = [0, 1, 2, 3, 4];
+ * arrays.rotate(data, 2);    // [2, 3, 4, 0, 1]
+ * arrays.rotate(data, -2);   // [0, 1, 2, 3, 4]
+ * arrays.rotate(data, 10);   // [0, 1, 2, 3, 4]
+ * arrays.rotate(data, 9);    // [4, 0, 1, 2, 3]
+ * ```
+ *
+ * **See also** [[reverse]]
+ */
+function rotate(array, delta) {
+    var n = array.length;
+    if (n <= 1) {
+        return array;
+    }
+    var d = delta | 0;
+    if (d > 0) {
+        d = d % n;
+    }
+    else if (d < 0) {
+        d = ((d % n) + n) % n;
+    }
+    if (d === 0) {
+        return array;
+    }
+    reverse(array, 0, d - 1);
+    reverse(array, d, n - 1);
+    reverse(array, 0, n - 1);
+    return array;
+}
+exports.rotate = rotate;
+/**
+ * Using a binary search, find the index of the first element in an
+ * array which compares `>=` to a value.
+ *
+ * @param array - The array of values to be searched. It must be sorted
+ *   in ascending order.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param cmp - The comparison function which returns `true` if an
+ *   array element is less than the given value.
+ *
+ * @returns The index of the first element in `array` which compares
+ *   `>=` to `value`, or `array.length` if there is no such element.
+ *
+ * #### Notes
+ * It is not safe for the comparison function to modify the array.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function numberCmp(a: number, b: number): boolean {
+ *   return a < b;
+ * }
+ *
+ * var data = [0, 3, 4, 7, 7, 9];
+ * arrays.lowerBound(data, 0, numberCmp);   // 0
+ * arrays.lowerBound(data, 6, numberCmp);   // 3
+ * arrays.lowerBound(data, 7, numberCmp);   // 3
+ * arrays.lowerBound(data, -1, numberCmp);  // 0
+ * arrays.lowerBound(data, 10, numberCmp);  // 6
+ * ```
+ *
+ * **See also** [[upperBound]]
+ */
+function lowerBound(array, value, cmp) {
+    var begin = 0;
+    var half;
+    var middle;
+    var n = array.length;
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (cmp(array[middle], value)) {
+            begin = middle + 1;
+            n -= half + 1;
+        }
+        else {
+            n = half;
+        }
+    }
+    return begin;
+}
+exports.lowerBound = lowerBound;
+/**
+ * Using a binary search, find the index of the first element in an
+ * array which compares `>` than a value.
+ *
+ * @param array - The array of values to be searched. It must be sorted
+ *   in ascending order.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param cmp - The comparison function which returns `true` if the
+ *   the given value is less than an array element.
+ *
+ * @returns The index of the first element in `array` which compares
+ *   `>` than `value`, or `array.length` if there is no such element.
+ *
+ * #### Notes
+ * It is not safe for the comparison function to modify the array.
+ *
+ * #### Example
+ * ```typescript
+ * import * as arrays from 'phosphor-arrays';
+ *
+ * function numberCmp(a: number, b: number): number {
+ *   return a < b;
+ * }
+ *
+ * var data = [0, 3, 4, 7, 7, 9];
+ * arrays.upperBound(data, 0, numberCmp);   // 1
+ * arrays.upperBound(data, 6, numberCmp);   // 3
+ * arrays.upperBound(data, 7, numberCmp);   // 5
+ * arrays.upperBound(data, -1, numberCmp);  // 0
+ * arrays.upperBound(data, 10, numberCmp);  // 6
+ * ```
+ *
+ * **See also** [[lowerBound]]
+ */
+function upperBound(array, value, cmp) {
+    var begin = 0;
+    var half;
+    var middle;
+    var n = array.length;
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (cmp(value, array[middle])) {
+            n = half;
+        }
+        else {
+            begin = middle + 1;
+            n -= half + 1;
+        }
+    }
+    return begin;
+}
+exports.upperBound = upperBound;
+
+},{}],12:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+/**
+ * A base class for creating objects which wrap a DOM node.
+ */
+var NodeWrapper = (function () {
+    function NodeWrapper() {
+        this._node = this.constructor.createNode();
+    }
+    /**
+     * Create the DOM node for a new node wrapper instance.
+     *
+     * @returns The DOM node to use with the node wrapper instance.
+     *
+     * #### Notes
+     * The default implementation creates an empty `<div>`.
+     *
+     * This may be reimplemented by a subclass to create a custom node.
+     */
+    NodeWrapper.createNode = function () {
+        return document.createElement('div');
+    };
+    Object.defineProperty(NodeWrapper.prototype, "node", {
+        /**
+         * Get the DOM node managed by the wrapper.
+         *
+         * #### Notes
+         * This property is read-only.
+         */
+        get: function () {
+            return this._node;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeWrapper.prototype, "id", {
+        /**
+         * Get the id of the wrapper's DOM node.
+         */
+        get: function () {
+            return this._node.id;
+        },
+        /**
+         * Set the id of the wrapper's DOM node.
+         */
+        set: function (value) {
+            this._node.id = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Test whether the wrapper's DOM node has the given class name.
+     *
+     * @param name - The class name of interest.
+     *
+     * @returns `true` if the node has the class, `false` otherwise.
+     */
+    NodeWrapper.prototype.hasClass = function (name) {
+        return this._node.classList.contains(name);
+    };
+    /**
+     * Add a class name to the wrapper's DOM node.
+     *
+     * @param name - The class name to add to the node.
+     *
+     * #### Notes
+     * If the class name is already added to the node, this is a no-op.
+     */
+    NodeWrapper.prototype.addClass = function (name) {
+        this._node.classList.add(name);
+    };
+    /**
+     * Remove a class name from the wrapper's DOM node.
+     *
+     * @param name - The class name to remove from the node.
+     *
+     * #### Notes
+     * If the class name is not yet added to the node, this is a no-op.
+     */
+    NodeWrapper.prototype.removeClass = function (name) {
+        this._node.classList.remove(name);
+    };
+    /**
+     * Toggle a class name on the wrapper's DOM node.
+     *
+     * @param name - The class name to toggle on the node.
+     *
+     * @param force - Whether to force add the class (`true`) or force
+     *   remove the class (`false`). If not provided, the presence of
+     *   the class will be toggled from its current state.
+     *
+     * @returns `true` if the class is now present, `false` otherwise.
+     */
+    NodeWrapper.prototype.toggleClass = function (name, force) {
+        var present;
+        if (force === true) {
+            this.addClass(name);
+            present = true;
+        }
+        else if (force === false) {
+            this.removeClass(name);
+            present = false;
+        }
+        else if (this.hasClass(name)) {
+            this.removeClass(name);
+            present = false;
+        }
+        else {
+            this.addClass(name);
+            present = true;
+        }
+        return present;
+    };
+    return NodeWrapper;
+})();
+exports.NodeWrapper = NodeWrapper;
+
+},{}],13:[function(require,module,exports){
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+var phosphor_signaling_1 = require('phosphor-signaling');
+/**
+ * A property descriptor for a property on an object.
+ *
+ * Properties descriptors can be used to expose a rich interface for an
+ * object which encapsulates value creation, coercion, and notification.
+ * They can also be used to extend the state of an object with semantic
+ * data from another class.
+ *
+ * #### Example
+ * ```typescript
+ * import { Property } from 'phosphor-properties';
+ *
+ * class MyClass {
+ *
+ *   static myValueProperty = new Property<MyClass, number>({
+ *      value: 0,
+ *      coerce: (owner, value) => Math.max(0, value),
+ *      changed: (owner, oldValue, newValue) => { console.log(newValue); },
+ *   });
+ *
+ *   get myValue(): number {
+ *     return MyClass.myValueProperty.get(this);
+ *   }
+ *
+ *   set myValue(value: number) {
+ *     MyClass.myValueProperty.set(this, value);
+ *   }
+ * }
+ * ```
+ */
+var Property = (function () {
+    /**
+     * Construct a new property descriptor.
+     *
+     * @param options - The options for initializing the property.
+     */
+    function Property(options) {
+        if (options === void 0) { options = {}; }
+        this._pid = nextPID();
+        this._changedSignal = new phosphor_signaling_1.Signal();
+        this._value = options.value;
+        this._create = options.create;
+        this._coerce = options.coerce;
+        this._compare = options.compare;
+        this._changed = options.changed;
+        this._silent = !!options.silent;
+        this._metadata = options.metadata || {};
+    }
+    /**
+     * Get the bound changed signal for a given property owner.
+     *
+     * @param owner - The object to bind to the changed signal.
+     *
+     * @returns The bound changed signal for the owner.
+     *
+     * #### Notes
+     * This signal will be emitted whenever **any** property value for
+     * the specified owner is changed.
+     *
+     * This signal is emitted **after** the instance changed signal.
+     *
+     * This signal will not be emmited for properties marked as silent.
+     */
+    Property.getChanged = function (owner) {
+        return Property.changedSignal.bind(owner);
+    };
+    Object.defineProperty(Property.prototype, "metadata", {
+        /**
+         * Get the metadata for the property.
+         *
+         * #### Notes
+         * This is a read-only property.
+         */
+        get: function () {
+            return this._metadata;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Property.prototype, "changedSignal", {
+        /**
+         * A signal emitted when the property value changes.
+         *
+         * #### Notes
+         * This is an attached signal which will be emitted using the owner
+         * of the property value as the sender.
+         *
+         * **See Also:** [[getChanged]]
+         */
+        get: function () {
+            return this._changedSignal;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Get the bound changed signal for a given property owner.
+     *
+     * @param owner - The object to bind to the changed signal.
+     *
+     * @returns The bound changed signal for the owner.
+     *
+     * #### Notes
+     * This signal will be emitted whenever **this** property value
+     * for the specified owner is changed.
+     *
+     * This signal is emitted **before** the static changed signal.
+     *
+     * This signal will not be emmited for properties marked as silent.
+     */
+    Property.prototype.getChanged = function (owner) {
+        return this._changedSignal.bind(owner);
+    };
+    /**
+     * Get the current value of the property for a given owner.
+     *
+     * @param owner - The property owner of interest.
+     *
+     * @returns The current value of the property.
+     *
+     * #### Notes
+     * If the value has not yet been set, the default value will be
+     * computed and assigned as the current value of the property.
+     */
+    Property.prototype.get = function (owner) {
+        var value;
+        var hash = lookupHash(owner);
+        if (this._pid in hash) {
+            value = hash[this._pid];
+        }
+        else {
+            value = hash[this._pid] = this._createValue(owner);
+        }
+        return value;
+    };
+    /**
+     * Set the current value of the property for a given owner.
+     *
+     * @param owner - The property owner of interest.
+     *
+     * @param value - The value for the property.
+     *
+     * #### Notes
+     * If this operation causes the property value to change, the
+     * changed signals will be emitted with the owner as sender.
+     *
+     * If the value has not yet been set, the default value will be
+     * computed and used as the previous value for the comparison.
+     */
+    Property.prototype.set = function (owner, value) {
+        var oldValue;
+        var hash = lookupHash(owner);
+        if (this._pid in hash) {
+            oldValue = hash[this._pid];
+        }
+        else {
+            oldValue = hash[this._pid] = this._createValue(owner);
+        }
+        var newValue = this._coerceValue(owner, value);
+        this._maybeNotify(owner, oldValue, hash[this._pid] = newValue);
+    };
+    /**
+     * Explicitly coerce the current property value for a given owner.
+     *
+     * @param owner - The property owner of interest.
+     *
+     * #### Notes
+     * If this operation causes the property value to change, the
+     * changed signals will be emitted with the owner as sender.
+     *
+     * If the value has not yet been set, the default value will be
+     * computed and used as the previous value for the comparison.
+     */
+    Property.prototype.coerce = function (owner) {
+        var oldValue;
+        var hash = lookupHash(owner);
+        if (this._pid in hash) {
+            oldValue = hash[this._pid];
+        }
+        else {
+            oldValue = hash[this._pid] = this._createValue(owner);
+        }
+        var newValue = this._coerceValue(owner, oldValue);
+        this._maybeNotify(owner, oldValue, hash[this._pid] = newValue);
+    };
+    /**
+     * Get or create the default value for the given owner.
+     */
+    Property.prototype._createValue = function (owner) {
+        var create = this._create;
+        return create ? create(owner) : this._value;
+    };
+    /**
+     * Coerce the value for the given owner.
+     */
+    Property.prototype._coerceValue = function (owner, value) {
+        var coerce = this._coerce;
+        return coerce ? coerce(owner, value) : value;
+    };
+    /**
+     * Compare the old value and new value for equality.
+     */
+    Property.prototype._compareValue = function (oldValue, newValue) {
+        var compare = this._compare;
+        return compare ? compare(oldValue, newValue) : oldValue === newValue;
+    };
+    /**
+     * Run the change notification if the given values are different.
+     */
+    Property.prototype._maybeNotify = function (owner, oldValue, newValue) {
+        if (this._compareValue(oldValue, newValue)) {
+            return;
+        }
+        var changed = this._changed;
+        if (changed) {
+            changed(owner, oldValue, newValue);
+        }
+        if (this._silent) {
+            return;
+        }
+        var args = { property: this, oldValue: oldValue, newValue: newValue };
+        this.getChanged(owner).emit(args);
+        Property.getChanged(owner).emit(args);
+    };
+    /**
+     * A signal emitted when a property value changes.
+     *
+     * #### Notes
+     * This is an attached signal which will be emitted using the owner
+     * of the property value as the sender.
+     *
+     * **See Also:** [[getChanged]]
+     */
+    Property.changedSignal = new phosphor_signaling_1.Signal();
+    return Property;
+})();
+exports.Property = Property;
+/**
+ * Clear the stored property data for the given property owner.
+ *
+ * @param owner - The property owner of interest.
+ *
+ * #### Notes
+ * This will clear all property values for the owner, but it will
+ * **not** emit any change notifications.
+ */
+function clearPropertyData(owner) {
+    ownerData.delete(owner);
+}
+exports.clearPropertyData = clearPropertyData;
+/**
+ * A weak mapping of property owner to property hash.
+ */
+var ownerData = new WeakMap();
+/**
+ * A function which computes successive unique property ids.
+ */
+var nextPID = (function () { var id = 0; return function () { return 'pid-' + id++; }; })();
+/**
+ * Lookup the data hash for the property owner.
+ *
+ * This will create the hash if one does not already exist.
+ */
+function lookupHash(owner) {
+    var hash = ownerData.get(owner);
+    if (hash !== void 0)
+        return hash;
+    hash = Object.create(null);
+    ownerData.set(owner, hash);
+    return hash;
+}
+
+},{"phosphor-signaling":6}]},{},[1]);
diff --git a/example/ext/codemirror.css b/example/ext/codemirror.css
new file mode 100644
index 0000000..1902ba4
--- /dev/null
+++ b/example/ext/codemirror.css
@@ -0,0 +1,320 @@
+/* BASICS */
+
+.CodeMirror {
+  /* Set height, width, borders, and global font properties here */
+  font-family: monospace;
+  height: 300px;
+  color: black;
+}
+
+/* PADDING */
+
+.CodeMirror-lines {
+  padding: 4px 0; /* Vertical padding around content */
+}
+.CodeMirror pre {
+  padding: 0 4px; /* Horizontal padding of content */
+}
+
+.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  background-color: white; /* The little square between H and V scrollbars */
+}
+
+/* GUTTER */
+
+.CodeMirror-gutters {
+  border-right: 1px solid #ddd;
+  background-color: #f7f7f7;
+  white-space: nowrap;
+}
+.CodeMirror-linenumbers {}
+.CodeMirror-linenumber {
+  padding: 0 3px 0 5px;
+  min-width: 20px;
+  text-align: right;
+  color: #999;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+
+.CodeMirror-guttermarker { color: black; }
+.CodeMirror-guttermarker-subtle { color: #999; }
+
+/* CURSOR */
+
+.CodeMirror div.CodeMirror-cursor {
+  border-left: 1px solid black;
+}
+/* Shown when moving in bi-directional text */
+.CodeMirror div.CodeMirror-secondarycursor {
+  border-left: 1px solid silver;
+}
+.CodeMirror.cm-fat-cursor div.CodeMirror-cursor {
+  width: auto;
+  border: 0;
+  background: #7e7;
+}
+.CodeMirror.cm-fat-cursor div.CodeMirror-cursors {
+  z-index: 1;
+}
+
+.cm-animate-fat-cursor {
+  width: auto;
+  border: 0;
+  -webkit-animation: blink 1.06s steps(1) infinite;
+  -moz-animation: blink 1.06s steps(1) infinite;
+  animation: blink 1.06s steps(1) infinite;
+}
+@-moz-keyframes blink {
+  0% { background: #7e7; }
+  50% { background: none; }
+  100% { background: #7e7; }
+}
+@-webkit-keyframes blink {
+  0% { background: #7e7; }
+  50% { background: none; }
+  100% { background: #7e7; }
+}
+@keyframes blink {
+  0% { background: #7e7; }
+  50% { background: none; }
+  100% { background: #7e7; }
+}
+
+/* Can style cursor different in overwrite (non-insert) mode */
+div.CodeMirror-overwrite div.CodeMirror-cursor {}
+
+.cm-tab { display: inline-block; text-decoration: inherit; }
+
+.CodeMirror-ruler {
+  border-left: 1px solid #ccc;
+  position: absolute;
+}
+
+/* DEFAULT THEME */
+
+.cm-s-default .cm-keyword {color: #708;}
+.cm-s-default .cm-atom {color: #219;}
+.cm-s-default .cm-number {color: #164;}
+.cm-s-default .cm-def {color: #00f;}
+.cm-s-default .cm-variable,
+.cm-s-default .cm-punctuation,
+.cm-s-default .cm-property,
+.cm-s-default .cm-operator {}
+.cm-s-default .cm-variable-2 {color: #05a;}
+.cm-s-default .cm-variable-3 {color: #085;}
+.cm-s-default .cm-comment {color: #a50;}
+.cm-s-default .cm-string {color: #a11;}
+.cm-s-default .cm-string-2 {color: #f50;}
+.cm-s-default .cm-meta {color: #555;}
+.cm-s-default .cm-qualifier {color: #555;}
+.cm-s-default .cm-builtin {color: #30a;}
+.cm-s-default .cm-bracket {color: #997;}
+.cm-s-default .cm-tag {color: #170;}
+.cm-s-default .cm-attribute {color: #00c;}
+.cm-s-default .cm-header {color: blue;}
+.cm-s-default .cm-quote {color: #090;}
+.cm-s-default .cm-hr {color: #999;}
+.cm-s-default .cm-link {color: #00c;}
+
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-header, .cm-strong {font-weight: bold;}
+.cm-em {font-style: italic;}
+.cm-link {text-decoration: underline;}
+.cm-strikethrough {text-decoration: line-through;}
+
+.cm-s-default .cm-error {color: #f00;}
+.cm-invalidchar {color: #f00;}
+
+/* Default styles for common addons */
+
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
+.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
+.CodeMirror-activeline-background {background: #e8f2ff;}
+
+/* STOP */
+
+/* The rest of this file contains styles related to the mechanics of
+   the editor. You probably shouldn't touch them. */
+
+.CodeMirror {
+  position: relative;
+  overflow: hidden;
+  background: white;
+}
+
+.CodeMirror-scroll {
+  overflow: scroll !important; /* Things will break if this is overridden */
+  /* 30px is the magic margin used to hide the element's real scrollbars */
+  /* See overflow: hidden in .CodeMirror */
+  margin-bottom: -30px; margin-right: -30px;
+  padding-bottom: 30px;
+  height: 100%;
+  outline: none; /* Prevent dragging from highlighting the element */
+  position: relative;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+.CodeMirror-sizer {
+  position: relative;
+  border-right: 30px solid transparent;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+
+/* The fake, visible scrollbars. Used to force redraw during scrolling
+   before actuall scrolling happens, thus preventing shaking and
+   flickering artifacts. */
+.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  position: absolute;
+  z-index: 6;
+  display: none;
+}
+.CodeMirror-vscrollbar {
+  right: 0; top: 0;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+.CodeMirror-hscrollbar {
+  bottom: 0; left: 0;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}
+.CodeMirror-scrollbar-filler {
+  right: 0; bottom: 0;
+}
+.CodeMirror-gutter-filler {
+  left: 0; bottom: 0;
+}
+
+.CodeMirror-gutters {
+  position: absolute; left: 0; top: 0;
+  z-index: 3;
+}
+.CodeMirror-gutter {
+  white-space: normal;
+  height: 100%;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+  display: inline-block;
+  margin-bottom: -30px;
+  /* Hack to make IE7 behave */
+  *zoom:1;
+  *display:inline;
+}
+.CodeMirror-gutter-wrapper {
+  position: absolute;
+  z-index: 4;
+  height: 100%;
+}
+.CodeMirror-gutter-elt {
+  position: absolute;
+  cursor: default;
+  z-index: 4;
+}
+.CodeMirror-gutter-wrapper {
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+}
+
+.CodeMirror-lines {
+  cursor: text;
+  min-height: 1px; /* prevents collapsing before first draw */
+}
+.CodeMirror pre {
+  /* Reset some styles that the rest of the page might have set */
+  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
+  border-width: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  margin: 0;
+  white-space: pre;
+  word-wrap: normal;
+  line-height: inherit;
+  color: inherit;
+  z-index: 2;
+  position: relative;
+  overflow: visible;
+  -webkit-tap-highlight-color: transparent;
+}
+.CodeMirror-wrap pre {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  word-break: normal;
+}
+
+.CodeMirror-linebackground {
+  position: absolute;
+  left: 0; right: 0; top: 0; bottom: 0;
+  z-index: 0;
+}
+
+.CodeMirror-linewidget {
+  position: relative;
+  z-index: 2;
+  overflow: auto;
+}
+
+.CodeMirror-widget {}
+
+.CodeMirror-code {
+  outline: none;
+}
+
+.CodeMirror-measure {
+  position: absolute;
+  width: 100%;
+  height: 0;
+  overflow: hidden;
+  visibility: hidden;
+}
+.CodeMirror-measure pre { position: static; }
+
+.CodeMirror div.CodeMirror-cursor {
+  position: absolute;
+  border-right: none;
+  width: 0;
+}
+
+div.CodeMirror-cursors {
+  visibility: hidden;
+  position: relative;
+  z-index: 3;
+}
+.CodeMirror-focused div.CodeMirror-cursors {
+  visibility: visible;
+}
+
+.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
+.CodeMirror-crosshair { cursor: crosshair; }
+.CodeMirror ::selection { background: #d7d4f0; }
+.CodeMirror ::-moz-selection { background: #d7d4f0; }
+
+.cm-searching {
+  background: #ffa;
+  background: rgba(255, 255, 0, .4);
+}
+
+/* IE7 hack to prevent it from returning funny offsetTops on the spans */
+.CodeMirror span { *vertical-align: text-bottom; }
+
+/* Used to force a border model for a node */
+.cm-force-border { padding-right: .1px; }
+
+@media print {
+  /* Hide the cursor when printing */
+  .CodeMirror div.CodeMirror-cursors {
+    visibility: hidden;
+  }
+}
+
+/* See issue #2901 */
+.cm-tab-wrap-hack:after { content: ''; }
+
+/* Help users use markselection to safely style text background */
+span.CodeMirror-selectedtext { background: none; }
diff --git a/example/ext/codemirror.js b/example/ext/codemirror.js
new file mode 100644
index 0000000..53b3532
--- /dev/null
+++ b/example/ext/codemirror.js
@@ -0,0 +1,8645 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// This is CodeMirror (http://codemirror.net), a code editor
+// implemented in JavaScript on top of the browser's DOM.
+//
+// You can find some technical background for some of the code below
+// at http://marijnhaverbeke.nl/blog/#cm-internals .
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    module.exports = mod();
+  else if (typeof define == "function" && define.amd) // AMD
+    return define([], mod);
+  else // Plain browser env
+    this.CodeMirror = mod();
+})(function() {
+  "use strict";
+
+  // BROWSER SNIFFING
+
+  // Kludges for bugs and behavior differences that can't be feature
+  // detected are enabled based on userAgent etc sniffing.
+
+  var gecko = /gecko\/\d/i.test(navigator.userAgent);
+  var ie_upto10 = /MSIE \d/.test(navigator.userAgent);
+  var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);
+  var ie = ie_upto10 || ie_11up;
+  var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1]);
+  var webkit = /WebKit\//.test(navigator.userAgent);
+  var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(navigator.userAgent);
+  var chrome = /Chrome\//.test(navigator.userAgent);
+  var presto = /Opera\//.test(navigator.userAgent);
+  var safari = /Apple Computer/.test(navigator.vendor);
+  var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(navigator.userAgent);
+  var phantom = /PhantomJS/.test(navigator.userAgent);
+
+  var ios = /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent);
+  // This is woefully incomplete. Suggestions for alternative methods welcome.
+  var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(navigator.userAgent);
+  var mac = ios || /Mac/.test(navigator.platform);
+  var windows = /win/i.test(navigator.platform);
+
+  var presto_version = presto && navigator.userAgent.match(/Version\/(\d*\.\d*)/);
+  if (presto_version) presto_version = Number(presto_version[1]);
+  if (presto_version && presto_version >= 15) { presto = false; webkit = true; }
+  // Some browsers use the wrong event properties to signal cmd/ctrl on OS X
+  var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));
+  var captureRightClick = gecko || (ie && ie_version >= 9);
+
+  // Optimize some code when these features are not used.
+  var sawReadOnlySpans = false, sawCollapsedSpans = false;
+
+  // EDITOR CONSTRUCTOR
+
+  // A CodeMirror instance represents an editor. This is the object
+  // that user code is usually dealing with.
+
+  function CodeMirror(place, options) {
+    if (!(this instanceof CodeMirror)) return new CodeMirror(place, options);
+
+    this.options = options = options ? copyObj(options) : {};
+    // Determine effective options based on given values and defaults.
+    copyObj(defaults, options, false);
+    setGuttersForLineNumbers(options);
+
+    var doc = options.value;
+    if (typeof doc == "string") doc = new Doc(doc, options.mode);
+    this.doc = doc;
+
+    var input = new CodeMirror.inputStyles[options.inputStyle](this);
+    var display = this.display = new Display(place, doc, input);
+    display.wrapper.CodeMirror = this;
+    updateGutters(this);
+    themeChanged(this);
+    if (options.lineWrapping)
+      this.display.wrapper.className += " CodeMirror-wrap";
+    if (options.autofocus && !mobile) display.input.focus();
+    initScrollbars(this);
+
+    this.state = {
+      keyMaps: [],  // stores maps added by addKeyMap
+      overlays: [], // highlighting overlays, as added by addOverlay
+      modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
+      overwrite: false, focused: false,
+      suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
+      pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll
+      draggingText: false,
+      highlight: new Delayed(), // stores highlight worker timeout
+      keySeq: null  // Unfinished key sequence
+    };
+
+    var cm = this;
+
+    // Override magic textarea content restore that IE sometimes does
+    // on our hidden textarea on reload
+    if (ie && ie_version < 11) setTimeout(function() { cm.display.input.reset(true); }, 20);
+
+    registerEventHandlers(this);
+    ensureGlobalHandlers();
+
+    startOperation(this);
+    this.curOp.forceUpdate = true;
+    attachDoc(this, doc);
+
+    if ((options.autofocus && !mobile) || cm.hasFocus())
+      setTimeout(bind(onFocus, this), 20);
+    else
+      onBlur(this);
+
+    for (var opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))
+      optionHandlers[opt](this, options[opt], Init);
+    maybeUpdateLineNumberWidth(this);
+    if (options.finishInit) options.finishInit(this);
+    for (var i = 0; i < initHooks.length; ++i) initHooks[i](this);
+    endOperation(this);
+    // Suppress optimizelegibility in Webkit, since it breaks text
+    // measuring on line wrapping boundaries.
+    if (webkit && options.lineWrapping &&
+        getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
+      display.lineDiv.style.textRendering = "auto";
+  }
+
+  // DISPLAY CONSTRUCTOR
+
+  // The display handles the DOM integration, both for input reading
+  // and content drawing. It holds references to DOM nodes and
+  // display-related state.
+
+  function Display(place, doc, input) {
+    var d = this;
+    this.input = input;
+
+    // Covers bottom-right square when both scrollbars are present.
+    d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");
+    d.scrollbarFiller.setAttribute("cm-not-content", "true");
+    // Covers bottom of gutter when coverGutterNextToScrollbar is on
+    // and h scrollbar is present.
+    d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler");
+    d.gutterFiller.setAttribute("cm-not-content", "true");
+    // Will contain the actual code, positioned to cover the viewport.
+    d.lineDiv = elt("div", null, "CodeMirror-code");
+    // Elements are added to these to represent selection and cursors.
+    d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");
+    d.cursorDiv = elt("div", null, "CodeMirror-cursors");
+    // A visibility: hidden element used to find the size of things.
+    d.measure = elt("div", null, "CodeMirror-measure");
+    // When lines outside of the viewport are measured, they are drawn in this.
+    d.lineMeasure = elt("div", null, "CodeMirror-measure");
+    // Wraps everything that needs to exist inside the vertically-padded coordinate system
+    d.lineSpace = elt("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
+                      null, "position: relative; outline: none");
+    // Moved around its parent to cover visible view.
+    d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative");
+    // Set to the height of the document, allowing scrolling.
+    d.sizer = elt("div", [d.mover], "CodeMirror-sizer");
+    d.sizerWidth = null;
+    // Behavior of elts with overflow: auto and padding is
+    // inconsistent across browsers. This is used to ensure the
+    // scrollable area is big enough.
+    d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;");
+    // Will contain the gutters, if any.
+    d.gutters = elt("div", null, "CodeMirror-gutters");
+    d.lineGutter = null;
+    // Actual scrollable element.
+    d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll");
+    d.scroller.setAttribute("tabIndex", "-1");
+    // The element in which the editor lives.
+    d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror");
+
+    // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
+    if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }
+    if (!webkit && !(gecko && mobile)) d.scroller.draggable = true;
+
+    if (place) {
+      if (place.appendChild) place.appendChild(d.wrapper);
+      else place(d.wrapper);
+    }
+
+    // Current rendered range (may be bigger than the view window).
+    d.viewFrom = d.viewTo = doc.first;
+    d.reportedViewFrom = d.reportedViewTo = doc.first;
+    // Information about the rendered lines.
+    d.view = [];
+    d.renderedView = null;
+    // Holds info about a single rendered line when it was rendered
+    // for measurement, while not in view.
+    d.externalMeasured = null;
+    // Empty space (in pixels) above the view
+    d.viewOffset = 0;
+    d.lastWrapHeight = d.lastWrapWidth = 0;
+    d.updateLineNumbers = null;
+
+    d.nativeBarWidth = d.barHeight = d.barWidth = 0;
+    d.scrollbarsClipped = false;
+
+    // Used to only resize the line number gutter when necessary (when
+    // the amount of lines crosses a boundary that makes its width change)
+    d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;
+    // Set to true when a non-horizontal-scrolling line widget is
+    // added. As an optimization, line widget aligning is skipped when
+    // this is false.
+    d.alignWidgets = false;
+
+    d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
+
+    // Tracks the maximum line length so that the horizontal scrollbar
+    // can be kept static when scrolling.
+    d.maxLine = null;
+    d.maxLineLength = 0;
+    d.maxLineChanged = false;
+
+    // Used for measuring wheel scrolling granularity
+    d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;
+
+    // True when shift is held down.
+    d.shift = false;
+
+    // Used to track whether anything happened since the context menu
+    // was opened.
+    d.selForContextMenu = null;
+
+    d.activeTouch = null;
+
+    input.init(d);
+  }
+
+  // STATE UPDATES
+
+  // Used to get the editor into a consistent state again when options change.
+
+  function loadMode(cm) {
+    cm.doc.mode = CodeMirror.getMode(cm.options, cm.doc.modeOption);
+    resetModeState(cm);
+  }
+
+  function resetModeState(cm) {
+    cm.doc.iter(function(line) {
+      if (line.stateAfter) line.stateAfter = null;
+      if (line.styles) line.styles = null;
+    });
+    cm.doc.frontier = cm.doc.first;
+    startWorker(cm, 100);
+    cm.state.modeGen++;
+    if (cm.curOp) regChange(cm);
+  }
+
+  function wrappingChanged(cm) {
+    if (cm.options.lineWrapping) {
+      addClass(cm.display.wrapper, "CodeMirror-wrap");
+      cm.display.sizer.style.minWidth = "";
+      cm.display.sizerWidth = null;
+    } else {
+      rmClass(cm.display.wrapper, "CodeMirror-wrap");
+      findMaxLine(cm);
+    }
+    estimateLineHeights(cm);
+    regChange(cm);
+    clearCaches(cm);
+    setTimeout(function(){updateScrollbars(cm);}, 100);
+  }
+
+  // Returns a function that estimates the height of a line, to use as
+  // first approximation until the line becomes visible (and is thus
+  // properly measurable).
+  function estimateHeight(cm) {
+    var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;
+    var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);
+    return function(line) {
+      if (lineIsHidden(cm.doc, line)) return 0;
+
+      var widgetsHeight = 0;
+      if (line.widgets) for (var i = 0; i < line.widgets.length; i++) {
+        if (line.widgets[i].height) widgetsHeight += line.widgets[i].height;
+      }
+
+      if (wrapping)
+        return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th;
+      else
+        return widgetsHeight + th;
+    };
+  }
+
+  function estimateLineHeights(cm) {
+    var doc = cm.doc, est = estimateHeight(cm);
+    doc.iter(function(line) {
+      var estHeight = est(line);
+      if (estHeight != line.height) updateLineHeight(line, estHeight);
+    });
+  }
+
+  function themeChanged(cm) {
+    cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
+      cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");
+    clearCaches(cm);
+  }
+
+  function guttersChanged(cm) {
+    updateGutters(cm);
+    regChange(cm);
+    setTimeout(function(){alignHorizontally(cm);}, 20);
+  }
+
+  // Rebuild the gutter elements, ensure the margin to the left of the
+  // code matches their width.
+  function updateGutters(cm) {
+    var gutters = cm.display.gutters, specs = cm.options.gutters;
+    removeChildren(gutters);
+    for (var i = 0; i < specs.length; ++i) {
+      var gutterClass = specs[i];
+      var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass));
+      if (gutterClass == "CodeMirror-linenumbers") {
+        cm.display.lineGutter = gElt;
+        gElt.style.width = (cm.display.lineNumWidth || 1) + "px";
+      }
+    }
+    gutters.style.display = i ? "" : "none";
+    updateGutterSpace(cm);
+  }
+
+  function updateGutterSpace(cm) {
+    var width = cm.display.gutters.offsetWidth;
+    cm.display.sizer.style.marginLeft = width + "px";
+  }
+
+  // Compute the character length of a line, taking into account
+  // collapsed ranges (see markText) that might hide parts, and join
+  // other lines onto it.
+  function lineLength(line) {
+    if (line.height == 0) return 0;
+    var len = line.text.length, merged, cur = line;
+    while (merged = collapsedSpanAtStart(cur)) {
+      var found = merged.find(0, true);
+      cur = found.from.line;
+      len += found.from.ch - found.to.ch;
+    }
+    cur = line;
+    while (merged = collapsedSpanAtEnd(cur)) {
+      var found = merged.find(0, true);
+      len -= cur.text.length - found.from.ch;
+      cur = found.to.line;
+      len += cur.text.length - found.to.ch;
+    }
+    return len;
+  }
+
+  // Find the longest line in the document.
+  function findMaxLine(cm) {
+    var d = cm.display, doc = cm.doc;
+    d.maxLine = getLine(doc, doc.first);
+    d.maxLineLength = lineLength(d.maxLine);
+    d.maxLineChanged = true;
+    doc.iter(function(line) {
+      var len = lineLength(line);
+      if (len > d.maxLineLength) {
+        d.maxLineLength = len;
+        d.maxLine = line;
+      }
+    });
+  }
+
+  // Make sure the gutters options contains the element
+  // "CodeMirror-linenumbers" when the lineNumbers option is true.
+  function setGuttersForLineNumbers(options) {
+    var found = indexOf(options.gutters, "CodeMirror-linenumbers");
+    if (found == -1 && options.lineNumbers) {
+      options.gutters = options.gutters.concat(["CodeMirror-linenumbers"]);
+    } else if (found > -1 && !options.lineNumbers) {
+      options.gutters = options.gutters.slice(0);
+      options.gutters.splice(found, 1);
+    }
+  }
+
+  // SCROLLBARS
+
+  // Prepare DOM reads needed to update the scrollbars. Done in one
+  // shot to minimize update/measure roundtrips.
+  function measureForScrollbars(cm) {
+    var d = cm.display, gutterW = d.gutters.offsetWidth;
+    var docH = Math.round(cm.doc.height + paddingVert(cm.display));
+    return {
+      clientHeight: d.scroller.clientHeight,
+      viewHeight: d.wrapper.clientHeight,
+      scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
+      viewWidth: d.wrapper.clientWidth,
+      barLeft: cm.options.fixedGutter ? gutterW : 0,
+      docHeight: docH,
+      scrollHeight: docH + scrollGap(cm) + d.barHeight,
+      nativeBarWidth: d.nativeBarWidth,
+      gutterWidth: gutterW
+    };
+  }
+
+  function NativeScrollbars(place, scroll, cm) {
+    this.cm = cm;
+    var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar");
+    var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar");
+    place(vert); place(horiz);
+
+    on(vert, "scroll", function() {
+      if (vert.clientHeight) scroll(vert.scrollTop, "vertical");
+    });
+    on(horiz, "scroll", function() {
+      if (horiz.clientWidth) scroll(horiz.scrollLeft, "horizontal");
+    });
+
+    this.checkedOverlay = false;
+    // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
+    if (ie && ie_version < 8) this.horiz.style.minHeight = this.vert.style.minWidth = "18px";
+  }
+
+  NativeScrollbars.prototype = copyObj({
+    update: function(measure) {
+      var needsH = measure.scrollWidth > measure.clientWidth + 1;
+      var needsV = measure.scrollHeight > measure.clientHeight + 1;
+      var sWidth = measure.nativeBarWidth;
+
+      if (needsV) {
+        this.vert.style.display = "block";
+        this.vert.style.bottom = needsH ? sWidth + "px" : "0";
+        var totalHeight = measure.viewHeight - (needsH ? sWidth : 0);
+        // A bug in IE8 can cause this value to be negative, so guard it.
+        this.vert.firstChild.style.height =
+          Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px";
+      } else {
+        this.vert.style.display = "";
+        this.vert.firstChild.style.height = "0";
+      }
+
+      if (needsH) {
+        this.horiz.style.display = "block";
+        this.horiz.style.right = needsV ? sWidth + "px" : "0";
+        this.horiz.style.left = measure.barLeft + "px";
+        var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);
+        this.horiz.firstChild.style.width =
+          (measure.scrollWidth - measure.clientWidth + totalWidth) + "px";
+      } else {
+        this.horiz.style.display = "";
+        this.horiz.firstChild.style.width = "0";
+      }
+
+      if (!this.checkedOverlay && measure.clientHeight > 0) {
+        if (sWidth == 0) this.overlayHack();
+        this.checkedOverlay = true;
+      }
+
+      return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0};
+    },
+    setScrollLeft: function(pos) {
+      if (this.horiz.scrollLeft != pos) this.horiz.scrollLeft = pos;
+    },
+    setScrollTop: function(pos) {
+      if (this.vert.scrollTop != pos) this.vert.scrollTop = pos;
+    },
+    overlayHack: function() {
+      var w = mac && !mac_geMountainLion ? "12px" : "18px";
+      this.horiz.style.minHeight = this.vert.style.minWidth = w;
+      var self = this;
+      var barMouseDown = function(e) {
+        if (e_target(e) != self.vert && e_target(e) != self.horiz)
+          operation(self.cm, onMouseDown)(e);
+      };
+      on(this.vert, "mousedown", barMouseDown);
+      on(this.horiz, "mousedown", barMouseDown);
+    },
+    clear: function() {
+      var parent = this.horiz.parentNode;
+      parent.removeChild(this.horiz);
+      parent.removeChild(this.vert);
+    }
+  }, NativeScrollbars.prototype);
+
+  function NullScrollbars() {}
+
+  NullScrollbars.prototype = copyObj({
+    update: function() { return {bottom: 0, right: 0}; },
+    setScrollLeft: function() {},
+    setScrollTop: function() {},
+    clear: function() {}
+  }, NullScrollbars.prototype);
+
+  CodeMirror.scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars};
+
+  function initScrollbars(cm) {
+    if (cm.display.scrollbars) {
+      cm.display.scrollbars.clear();
+      if (cm.display.scrollbars.addClass)
+        rmClass(cm.display.wrapper, cm.display.scrollbars.addClass);
+    }
+
+    cm.display.scrollbars = new CodeMirror.scrollbarModel[cm.options.scrollbarStyle](function(node) {
+      cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller);
+      // Prevent clicks in the scrollbars from killing focus
+      on(node, "mousedown", function() {
+        if (cm.state.focused) setTimeout(function() { cm.display.input.focus(); }, 0);
+      });
+      node.setAttribute("cm-not-content", "true");
+    }, function(pos, axis) {
+      if (axis == "horizontal") setScrollLeft(cm, pos);
+      else setScrollTop(cm, pos);
+    }, cm);
+    if (cm.display.scrollbars.addClass)
+      addClass(cm.display.wrapper, cm.display.scrollbars.addClass);
+  }
+
+  function updateScrollbars(cm, measure) {
+    if (!measure) measure = measureForScrollbars(cm);
+    var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight;
+    updateScrollbarsInner(cm, measure);
+    for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {
+      if (startWidth != cm.display.barWidth && cm.options.lineWrapping)
+        updateHeightsInViewport(cm);
+      updateScrollbarsInner(cm, measureForScrollbars(cm));
+      startWidth = cm.display.barWidth; startHeight = cm.display.barHeight;
+    }
+  }
+
+  // Re-synchronize the fake scrollbars with the actual size of the
+  // content.
+  function updateScrollbarsInner(cm, measure) {
+    var d = cm.display;
+    var sizes = d.scrollbars.update(measure);
+
+    d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px";
+    d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px";
+
+    if (sizes.right && sizes.bottom) {
+      d.scrollbarFiller.style.display = "block";
+      d.scrollbarFiller.style.height = sizes.bottom + "px";
+      d.scrollbarFiller.style.width = sizes.right + "px";
+    } else d.scrollbarFiller.style.display = "";
+    if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
+      d.gutterFiller.style.display = "block";
+      d.gutterFiller.style.height = sizes.bottom + "px";
+      d.gutterFiller.style.width = measure.gutterWidth + "px";
+    } else d.gutterFiller.style.display = "";
+  }
+
+  // Compute the lines that are visible in a given viewport (defaults
+  // the the current scroll position). viewport may contain top,
+  // height, and ensure (see op.scrollToPos) properties.
+  function visibleLines(display, doc, viewport) {
+    var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop;
+    top = Math.floor(top - paddingTop(display));
+    var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight;
+
+    var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom);
+    // Ensure is a {from: {line, ch}, to: {line, ch}} object, and
+    // forces those lines into the viewport (if possible).
+    if (viewport && viewport.ensure) {
+      var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line;
+      if (ensureFrom < from) {
+        from = ensureFrom;
+        to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight);
+      } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
+        from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight);
+        to = ensureTo;
+      }
+    }
+    return {from: from, to: Math.max(to, from + 1)};
+  }
+
+  // LINE NUMBERS
+
+  // Re-align line numbers and gutter marks to compensate for
+  // horizontal scrolling.
+  function alignHorizontally(cm) {
+    var display = cm.display, view = display.view;
+    if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return;
+    var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;
+    var gutterW = display.gutters.offsetWidth, left = comp + "px";
+    for (var i = 0; i < view.length; i++) if (!view[i].hidden) {
+      if (cm.options.fixedGutter && view[i].gutter)
+        view[i].gutter.style.left = left;
+      var align = view[i].alignable;
+      if (align) for (var j = 0; j < align.length; j++)
+        align[j].style.left = left;
+    }
+    if (cm.options.fixedGutter)
+      display.gutters.style.left = (comp + gutterW) + "px";
+  }
+
+  // Used to ensure that the line number gutter is still the right
+  // size for the current document size. Returns true when an update
+  // is needed.
+  function maybeUpdateLineNumberWidth(cm) {
+    if (!cm.options.lineNumbers) return false;
+    var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display;
+    if (last.length != display.lineNumChars) {
+      var test = display.measure.appendChild(elt("div", [elt("div", last)],
+                                                 "CodeMirror-linenumber CodeMirror-gutter-elt"));
+      var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;
+      display.lineGutter.style.width = "";
+      display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding);
+      display.lineNumWidth = display.lineNumInnerWidth + padding;
+      display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;
+      display.lineGutter.style.width = display.lineNumWidth + "px";
+      updateGutterSpace(cm);
+      return true;
+    }
+    return false;
+  }
+
+  function lineNumberFor(options, i) {
+    return String(options.lineNumberFormatter(i + options.firstLineNumber));
+  }
+
+  // Computes display.scroller.scrollLeft + display.gutters.offsetWidth,
+  // but using getBoundingClientRect to get a sub-pixel-accurate
+  // result.
+  function compensateForHScroll(display) {
+    return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left;
+  }
+
+  // DISPLAY DRAWING
+
+  function DisplayUpdate(cm, viewport, force) {
+    var display = cm.display;
+
+    this.viewport = viewport;
+    // Store some values that we'll need later (but don't want to force a relayout for)
+    this.visible = visibleLines(display, cm.doc, viewport);
+    this.editorIsHidden = !display.wrapper.offsetWidth;
+    this.wrapperHeight = display.wrapper.clientHeight;
+    this.wrapperWidth = display.wrapper.clientWidth;
+    this.oldDisplayWidth = displayWidth(cm);
+    this.force = force;
+    this.dims = getDimensions(cm);
+    this.events = [];
+  }
+
+  DisplayUpdate.prototype.signal = function(emitter, type) {
+    if (hasHandler(emitter, type))
+      this.events.push(arguments);
+  };
+  DisplayUpdate.prototype.finish = function() {
+    for (var i = 0; i < this.events.length; i++)
+      signal.apply(null, this.events[i]);
+  };
+
+  function maybeClipScrollbars(cm) {
+    var display = cm.display;
+    if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
+      display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth;
+      display.heightForcer.style.height = scrollGap(cm) + "px";
+      display.sizer.style.marginBottom = -display.nativeBarWidth + "px";
+      display.sizer.style.borderRightWidth = scrollGap(cm) + "px";
+      display.scrollbarsClipped = true;
+    }
+  }
+
+  // Does the actual updating of the line display. Bails out
+  // (returning false) when there is nothing to be done and forced is
+  // false.
+  function updateDisplayIfNeeded(cm, update) {
+    var display = cm.display, doc = cm.doc;
+
+    if (update.editorIsHidden) {
+      resetView(cm);
+      return false;
+    }
+
+    // Bail out if the visible area is already rendered and nothing changed.
+    if (!update.force &&
+        update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
+        (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
+        display.renderedView == display.view && countDirtyView(cm) == 0)
+      return false;
+
+    if (maybeUpdateLineNumberWidth(cm)) {
+      resetView(cm);
+      update.dims = getDimensions(cm);
+    }
+
+    // Compute a suitable new viewport (from & to)
+    var end = doc.first + doc.size;
+    var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first);
+    var to = Math.min(end, update.visible.to + cm.options.viewportMargin);
+    if (display.viewFrom < from && from - display.viewFrom < 20) from = Math.max(doc.first, display.viewFrom);
+    if (display.viewTo > to && display.viewTo - to < 20) to = Math.min(end, display.viewTo);
+    if (sawCollapsedSpans) {
+      from = visualLineNo(cm.doc, from);
+      to = visualLineEndNo(cm.doc, to);
+    }
+
+    var different = from != display.viewFrom || to != display.viewTo ||
+      display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth;
+    adjustView(cm, from, to);
+
+    display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom));
+    // Position the mover div to align with the current scroll position
+    cm.display.mover.style.top = display.viewOffset + "px";
+
+    var toUpdate = countDirtyView(cm);
+    if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
+        (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
+      return false;
+
+    // For big changes, we hide the enclosing element during the
+    // update, since that speeds up the operations on most browsers.
+    var focused = activeElt();
+    if (toUpdate > 4) display.lineDiv.style.display = "none";
+    patchDisplay(cm, display.updateLineNumbers, update.dims);
+    if (toUpdate > 4) display.lineDiv.style.display = "";
+    display.renderedView = display.view;
+    // There might have been a widget with a focused element that got
+    // hidden or updated, if so re-focus it.
+    if (focused && activeElt() != focused && focused.offsetHeight) focused.focus();
+
+    // Prevent selection and cursors from interfering with the scroll
+    // width and height.
+    removeChildren(display.cursorDiv);
+    removeChildren(display.selectionDiv);
+    display.gutters.style.height = 0;
+
+    if (different) {
+      display.lastWrapHeight = update.wrapperHeight;
+      display.lastWrapWidth = update.wrapperWidth;
+      startWorker(cm, 400);
+    }
+
+    display.updateLineNumbers = null;
+
+    return true;
+  }
+
+  function postUpdateDisplay(cm, update) {
+    var force = update.force, viewport = update.viewport;
+    for (var first = true;; first = false) {
+      if (first && cm.options.lineWrapping && update.oldDisplayWidth != displayWidth(cm)) {
+        force = true;
+      } else {
+        force = false;
+        // Clip forced viewport to actual scrollable area.
+        if (viewport && viewport.top != null)
+          viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)};
+        // Updated line heights might result in the drawn area not
+        // actually covering the viewport. Keep looping until it does.
+        update.visible = visibleLines(cm.display, cm.doc, viewport);
+        if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
+          break;
+      }
+      if (!updateDisplayIfNeeded(cm, update)) break;
+      updateHeightsInViewport(cm);
+      var barMeasure = measureForScrollbars(cm);
+      updateSelection(cm);
+      setDocumentHeight(cm, barMeasure);
+      updateScrollbars(cm, barMeasure);
+    }
+
+    update.signal(cm, "update", cm);
+    if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
+      update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo);
+      cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo;
+    }
+  }
+
+  function updateDisplaySimple(cm, viewport) {
+    var update = new DisplayUpdate(cm, viewport);
+    if (updateDisplayIfNeeded(cm, update)) {
+      updateHeightsInViewport(cm);
+      postUpdateDisplay(cm, update);
+      var barMeasure = measureForScrollbars(cm);
+      updateSelection(cm);
+      setDocumentHeight(cm, barMeasure);
+      updateScrollbars(cm, barMeasure);
+      update.finish();
+    }
+  }
+
+  function setDocumentHeight(cm, measure) {
+    cm.display.sizer.style.minHeight = measure.docHeight + "px";
+    var total = measure.docHeight + cm.display.barHeight;
+    cm.display.heightForcer.style.top = total + "px";
+    cm.display.gutters.style.height = Math.max(total + scrollGap(cm), measure.clientHeight) + "px";
+  }
+
+  // Read the actual heights of the rendered lines, and update their
+  // stored heights to match.
+  function updateHeightsInViewport(cm) {
+    var display = cm.display;
+    var prevBottom = display.lineDiv.offsetTop;
+    for (var i = 0; i < display.view.length; i++) {
+      var cur = display.view[i], height;
+      if (cur.hidden) continue;
+      if (ie && ie_version < 8) {
+        var bot = cur.node.offsetTop + cur.node.offsetHeight;
+        height = bot - prevBottom;
+        prevBottom = bot;
+      } else {
+        var box = cur.node.getBoundingClientRect();
+        height = box.bottom - box.top;
+      }
+      var diff = cur.line.height - height;
+      if (height < 2) height = textHeight(display);
+      if (diff > .001 || diff < -.001) {
+        updateLineHeight(cur.line, height);
+        updateWidgetHeight(cur.line);
+        if (cur.rest) for (var j = 0; j < cur.rest.length; j++)
+          updateWidgetHeight(cur.rest[j]);
+      }
+    }
+  }
+
+  // Read and store the height of line widgets associated with the
+  // given line.
+  function updateWidgetHeight(line) {
+    if (line.widgets) for (var i = 0; i < line.widgets.length; ++i)
+      line.widgets[i].height = line.widgets[i].node.offsetHeight;
+  }
+
+  // Do a bulk-read of the DOM positions and sizes needed to draw the
+  // view, so that we don't interleave reading and writing to the DOM.
+  function getDimensions(cm) {
+    var d = cm.display, left = {}, width = {};
+    var gutterLeft = d.gutters.clientLeft;
+    for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
+      left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft;
+      width[cm.options.gutters[i]] = n.clientWidth;
+    }
+    return {fixedPos: compensateForHScroll(d),
+            gutterTotalWidth: d.gutters.offsetWidth,
+            gutterLeft: left,
+            gutterWidth: width,
+            wrapperWidth: d.wrapper.clientWidth};
+  }
+
+  // Sync the actual display DOM structure with display.view, removing
+  // nodes for lines that are no longer in view, and creating the ones
+  // that are not there yet, and updating the ones that are out of
+  // date.
+  function patchDisplay(cm, updateNumbersFrom, dims) {
+    var display = cm.display, lineNumbers = cm.options.lineNumbers;
+    var container = display.lineDiv, cur = container.firstChild;
+
+    function rm(node) {
+      var next = node.nextSibling;
+      // Works around a throw-scroll bug in OS X Webkit
+      if (webkit && mac && cm.display.currentWheelTarget == node)
+        node.style.display = "none";
+      else
+        node.parentNode.removeChild(node);
+      return next;
+    }
+
+    var view = display.view, lineN = display.viewFrom;
+    // Loop over the elements in the view, syncing cur (the DOM nodes
+    // in display.lineDiv) with the view as we go.
+    for (var i = 0; i < view.length; i++) {
+      var lineView = view[i];
+      if (lineView.hidden) {
+      } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet
+        var node = buildLineElement(cm, lineView, lineN, dims);
+        container.insertBefore(node, cur);
+      } else { // Already drawn
+        while (cur != lineView.node) cur = rm(cur);
+        var updateNumber = lineNumbers && updateNumbersFrom != null &&
+          updateNumbersFrom <= lineN && lineView.lineNumber;
+        if (lineView.changes) {
+          if (indexOf(lineView.changes, "gutter") > -1) updateNumber = false;
+          updateLineForChanges(cm, lineView, lineN, dims);
+        }
+        if (updateNumber) {
+          removeChildren(lineView.lineNumber);
+          lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)));
+        }
+        cur = lineView.node.nextSibling;
+      }
+      lineN += lineView.size;
+    }
+    while (cur) cur = rm(cur);
+  }
+
+  // When an aspect of a line changes, a string is added to
+  // lineView.changes. This updates the relevant part of the line's
+  // DOM structure.
+  function updateLineForChanges(cm, lineView, lineN, dims) {
+    for (var j = 0; j < lineView.changes.length; j++) {
+      var type = lineView.changes[j];
+      if (type == "text") updateLineText(cm, lineView);
+      else if (type == "gutter") updateLineGutter(cm, lineView, lineN, dims);
+      else if (type == "class") updateLineClasses(lineView);
+      else if (type == "widget") updateLineWidgets(cm, lineView, dims);
+    }
+    lineView.changes = null;
+  }
+
+  // Lines with gutter elements, widgets or a background class need to
+  // be wrapped, and have the extra elements added to the wrapper div
+  function ensureLineWrapped(lineView) {
+    if (lineView.node == lineView.text) {
+      lineView.node = elt("div", null, null, "position: relative");
+      if (lineView.text.parentNode)
+        lineView.text.parentNode.replaceChild(lineView.node, lineView.text);
+      lineView.node.appendChild(lineView.text);
+      if (ie && ie_version < 8) lineView.node.style.zIndex = 2;
+    }
+    return lineView.node;
+  }
+
+  function updateLineBackground(lineView) {
+    var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass;
+    if (cls) cls += " CodeMirror-linebackground";
+    if (lineView.background) {
+      if (cls) lineView.background.className = cls;
+      else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null; }
+    } else if (cls) {
+      var wrap = ensureLineWrapped(lineView);
+      lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild);
+    }
+  }
+
+  // Wrapper around buildLineContent which will reuse the structure
+  // in display.externalMeasured when possible.
+  function getLineContent(cm, lineView) {
+    var ext = cm.display.externalMeasured;
+    if (ext && ext.line == lineView.line) {
+      cm.display.externalMeasured = null;
+      lineView.measure = ext.measure;
+      return ext.built;
+    }
+    return buildLineContent(cm, lineView);
+  }
+
+  // Redraw the line's text. Interacts with the background and text
+  // classes because the mode may output tokens that influence these
+  // classes.
+  function updateLineText(cm, lineView) {
+    var cls = lineView.text.className;
+    var built = getLineContent(cm, lineView);
+    if (lineView.text == lineView.node) lineView.node = built.pre;
+    lineView.text.parentNode.replaceChild(built.pre, lineView.text);
+    lineView.text = built.pre;
+    if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
+      lineView.bgClass = built.bgClass;
+      lineView.textClass = built.textClass;
+      updateLineClasses(lineView);
+    } else if (cls) {
+      lineView.text.className = cls;
+    }
+  }
+
+  function updateLineClasses(lineView) {
+    updateLineBackground(lineView);
+    if (lineView.line.wrapClass)
+      ensureLineWrapped(lineView).className = lineView.line.wrapClass;
+    else if (lineView.node != lineView.text)
+      lineView.node.className = "";
+    var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass;
+    lineView.text.className = textClass || "";
+  }
+
+  function updateLineGutter(cm, lineView, lineN, dims) {
+    if (lineView.gutter) {
+      lineView.node.removeChild(lineView.gutter);
+      lineView.gutter = null;
+    }
+    var markers = lineView.line.gutterMarkers;
+    if (cm.options.lineNumbers || markers) {
+      var wrap = ensureLineWrapped(lineView);
+      var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", "left: " +
+                                             (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) +
+                                             "px; width: " + dims.gutterTotalWidth + "px");
+      cm.display.input.setUneditable(gutterWrap);
+      wrap.insertBefore(gutterWrap, lineView.text);
+      if (lineView.line.gutterClass)
+        gutterWrap.className += " " + lineView.line.gutterClass;
+      if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
+        lineView.lineNumber = gutterWrap.appendChild(
+          elt("div", lineNumberFor(cm.options, lineN),
+              "CodeMirror-linenumber CodeMirror-gutter-elt",
+              "left: " + dims.gutterLeft["CodeMirror-linenumbers"] + "px; width: "
+              + cm.display.lineNumInnerWidth + "px"));
+      if (markers) for (var k = 0; k < cm.options.gutters.length; ++k) {
+        var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id];
+        if (found)
+          gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", "left: " +
+                                     dims.gutterLeft[id] + "px; width: " + dims.gutterWidth[id] + "px"));
+      }
+    }
+  }
+
+  function updateLineWidgets(cm, lineView, dims) {
+    if (lineView.alignable) lineView.alignable = null;
+    for (var node = lineView.node.firstChild, next; node; node = next) {
+      var next = node.nextSibling;
+      if (node.className == "CodeMirror-linewidget")
+        lineView.node.removeChild(node);
+    }
+    insertLineWidgets(cm, lineView, dims);
+  }
+
+  // Build a line's DOM representation from scratch
+  function buildLineElement(cm, lineView, lineN, dims) {
+    var built = getLineContent(cm, lineView);
+    lineView.text = lineView.node = built.pre;
+    if (built.bgClass) lineView.bgClass = built.bgClass;
+    if (built.textClass) lineView.textClass = built.textClass;
+
+    updateLineClasses(lineView);
+    updateLineGutter(cm, lineView, lineN, dims);
+    insertLineWidgets(cm, lineView, dims);
+    return lineView.node;
+  }
+
+  // A lineView may contain multiple logical lines (when merged by
+  // collapsed spans). The widgets for all of them need to be drawn.
+  function insertLineWidgets(cm, lineView, dims) {
+    insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);
+    if (lineView.rest) for (var i = 0; i < lineView.rest.length; i++)
+      insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false);
+  }
+
+  function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
+    if (!line.widgets) return;
+    var wrap = ensureLineWrapped(lineView);
+    for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
+      var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget");
+      if (!widget.handleMouseEvents) node.setAttribute("cm-ignore-events", "true");
+      positionLineWidget(widget, node, lineView, dims);
+      cm.display.input.setUneditable(node);
+      if (allowAbove && widget.above)
+        wrap.insertBefore(node, lineView.gutter || lineView.text);
+      else
+        wrap.appendChild(node);
+      signalLater(widget, "redraw");
+    }
+  }
+
+  function positionLineWidget(widget, node, lineView, dims) {
+    if (widget.noHScroll) {
+      (lineView.alignable || (lineView.alignable = [])).push(node);
+      var width = dims.wrapperWidth;
+      node.style.left = dims.fixedPos + "px";
+      if (!widget.coverGutter) {
+        width -= dims.gutterTotalWidth;
+        node.style.paddingLeft = dims.gutterTotalWidth + "px";
+      }
+      node.style.width = width + "px";
+    }
+    if (widget.coverGutter) {
+      node.style.zIndex = 5;
+      node.style.position = "relative";
+      if (!widget.noHScroll) node.style.marginLeft = -dims.gutterTotalWidth + "px";
+    }
+  }
+
+  // POSITION OBJECT
+
+  // A Pos instance represents a position within the text.
+  var Pos = CodeMirror.Pos = function(line, ch) {
+    if (!(this instanceof Pos)) return new Pos(line, ch);
+    this.line = line; this.ch = ch;
+  };
+
+  // Compare two positions, return 0 if they are the same, a negative
+  // number when a is less, and a positive number otherwise.
+  var cmp = CodeMirror.cmpPos = function(a, b) { return a.line - b.line || a.ch - b.ch; };
+
+  function copyPos(x) {return Pos(x.line, x.ch);}
+  function maxPos(a, b) { return cmp(a, b) < 0 ? b : a; }
+  function minPos(a, b) { return cmp(a, b) < 0 ? a : b; }
+
+  // INPUT HANDLING
+
+  function ensureFocus(cm) {
+    if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm); }
+  }
+
+  function isReadOnly(cm) {
+    return cm.options.readOnly || cm.doc.cantEdit;
+  }
+
+  // This will be set to an array of strings when copying, so that,
+  // when pasting, we know what kind of selections the copied text
+  // was made out of.
+  var lastCopied = null;
+
+  function applyTextInput(cm, inserted, deleted, sel) {
+    var doc = cm.doc;
+    cm.display.shift = false;
+    if (!sel) sel = doc.sel;
+
+    var textLines = splitLines(inserted), multiPaste = null;
+    // When pasing N lines into N selections, insert one line per selection
+    if (cm.state.pasteIncoming && sel.ranges.length > 1) {
+      if (lastCopied && lastCopied.join("\n") == inserted)
+        multiPaste = sel.ranges.length % lastCopied.length == 0 && map(lastCopied, splitLines);
+      else if (textLines.length == sel.ranges.length)
+        multiPaste = map(textLines, function(l) { return [l]; });
+    }
+
+    // Normal behavior is to insert the new text into every selection
+    for (var i = sel.ranges.length - 1; i >= 0; i--) {
+      var range = sel.ranges[i];
+      var from = range.from(), to = range.to();
+      if (range.empty()) {
+        if (deleted && deleted > 0) // Handle deletion
+          from = Pos(from.line, from.ch - deleted);
+        else if (cm.state.overwrite && !cm.state.pasteIncoming) // Handle overwrite
+          to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length));
+      }
+      var updateInput = cm.curOp.updateInput;
+      var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i % multiPaste.length] : textLines,
+                         origin: cm.state.pasteIncoming ? "paste" : cm.state.cutIncoming ? "cut" : "+input"};
+      makeChange(cm.doc, changeEvent);
+      signalLater(cm, "inputRead", cm, changeEvent);
+      // When an 'electric' character is inserted, immediately trigger a reindent
+      if (inserted && !cm.state.pasteIncoming && cm.options.electricChars &&
+          cm.options.smartIndent && range.head.ch < 100 &&
+          (!i || sel.ranges[i - 1].head.line != range.head.line)) {
+        var mode = cm.getModeAt(range.head);
+        var end = changeEnd(changeEvent);
+        if (mode.electricChars) {
+          for (var j = 0; j < mode.electricChars.length; j++)
+            if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
+              indentLine(cm, end.line, "smart");
+              break;
+            }
+        } else if (mode.electricInput) {
+          if (mode.electricInput.test(getLine(doc, end.line).text.slice(0, end.ch)))
+            indentLine(cm, end.line, "smart");
+        }
+      }
+    }
+    ensureCursorVisible(cm);
+    cm.curOp.updateInput = updateInput;
+    cm.curOp.typing = true;
+    cm.state.pasteIncoming = cm.state.cutIncoming = false;
+  }
+
+  function copyableRanges(cm) {
+    var text = [], ranges = [];
+    for (var i = 0; i < cm.doc.sel.ranges.length; i++) {
+      var line = cm.doc.sel.ranges[i].head.line;
+      var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)};
+      ranges.push(lineRange);
+      text.push(cm.getRange(lineRange.anchor, lineRange.head));
+    }
+    return {text: text, ranges: ranges};
+  }
+
+  function disableBrowserMagic(field) {
+    field.setAttribute("autocorrect", "off");
+    field.setAttribute("autocapitalize", "off");
+    field.setAttribute("spellcheck", "false");
+  }
+
+  // TEXTAREA INPUT STYLE
+
+  function TextareaInput(cm) {
+    this.cm = cm;
+    // See input.poll and input.reset
+    this.prevInput = "";
+
+    // Flag that indicates whether we expect input to appear real soon
+    // now (after some event like 'keypress' or 'input') and are
+    // polling intensively.
+    this.pollingFast = false;
+    // Self-resetting timeout for the poller
+    this.polling = new Delayed();
+    // Tracks when input.reset has punted to just putting a short
+    // string into the textarea instead of the full selection.
+    this.inaccurateSelection = false;
+    // Used to work around IE issue with selection being forgotten when focus moves away from textarea
+    this.hasSelection = false;
+  };
+
+  function hiddenTextarea() {
+    var te = elt("textarea", null, null, "position: absolute; padding: 0; width: 1px; height: 1em; outline: none");
+    var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;");
+    // The textarea is kept positioned near the cursor to prevent the
+    // fact that it'll be scrolled into view on input from scrolling
+    // our fake cursor out of view. On webkit, when wrap=off, paste is
+    // very slow. So make the area wide instead.
+    if (webkit) te.style.width = "1000px";
+    else te.setAttribute("wrap", "off");
+    // If border: 0; -- iOS fails to open keyboard (issue #1287)
+    if (ios) te.style.border = "1px solid black";
+    disableBrowserMagic(te);
+    return div;
+  }
+
+  TextareaInput.prototype = copyObj({
+    init: function(display) {
+      var input = this, cm = this.cm;
+
+      // Wraps and hides input textarea
+      var div = this.wrapper = hiddenTextarea();
+      // The semihidden textarea that is focused when the editor is
+      // focused, and receives input.
+      var te = this.textarea = div.firstChild;
+      display.wrapper.insertBefore(div, display.wrapper.firstChild);
+
+      // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
+      if (ios) te.style.width = "0px";
+
+      on(te, "input", function() {
+        if (ie && ie_version >= 9 && input.hasSelection) input.hasSelection = null;
+        input.poll();
+      });
+
+      on(te, "paste", function() {
+        // Workaround for webkit bug https://bugs.webkit.org/show_bug.cgi?id=90206
+        // Add a char to the end of textarea before paste occur so that
+        // selection doesn't span to the end of textarea.
+        if (webkit && !cm.state.fakedLastChar && !(new Date - cm.state.lastMiddleDown < 200)) {
+          var start = te.selectionStart, end = te.selectionEnd;
+          te.value += "$";
+          // The selection end needs to be set before the start, otherwise there
+          // can be an intermediate non-empty selection between the two, which
+          // can override the middle-click paste buffer on linux and cause the
+          // wrong thing to get pasted.
+          te.selectionEnd = end;
+          te.selectionStart = start;
+          cm.state.fakedLastChar = true;
+        }
+        cm.state.pasteIncoming = true;
+        input.fastPoll();
+      });
+
+      function prepareCopyCut(e) {
+        if (cm.somethingSelected()) {
+          lastCopied = cm.getSelections();
+          if (input.inaccurateSelection) {
+            input.prevInput = "";
+            input.inaccurateSelection = false;
+            te.value = lastCopied.join("\n");
+            selectInput(te);
+          }
+        } else {
+          var ranges = copyableRanges(cm);
+          lastCopied = ranges.text;
+          if (e.type == "cut") {
+            cm.setSelections(ranges.ranges, null, sel_dontScroll);
+          } else {
+            input.prevInput = "";
+            te.value = ranges.text.join("\n");
+            selectInput(te);
+          }
+        }
+        if (e.type == "cut") cm.state.cutIncoming = true;
+      }
+      on(te, "cut", prepareCopyCut);
+      on(te, "copy", prepareCopyCut);
+
+      on(display.scroller, "paste", function(e) {
+        if (eventInWidget(display, e)) return;
+        cm.state.pasteIncoming = true;
+        input.focus();
+      });
+
+      // Prevent normal selection in the editor (we handle our own)
+      on(display.lineSpace, "selectstart", function(e) {
+        if (!eventInWidget(display, e)) e_preventDefault(e);
+      });
+    },
+
+    prepareSelection: function() {
+      // Redraw the selection and/or cursor
+      var cm = this.cm, display = cm.display, doc = cm.doc;
+      var result = prepareSelection(cm);
+
+      // Move the hidden textarea near the cursor to prevent scrolling artifacts
+      if (cm.options.moveInputWithCursor) {
+        var headPos = cursorCoords(cm, doc.sel.primary().head, "div");
+        var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect();
+        result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
+                                            headPos.top + lineOff.top - wrapOff.top));
+        result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
+                                             headPos.left + lineOff.left - wrapOff.left));
+      }
+
+      return result;
+    },
+
+    showSelection: function(drawn) {
+      var cm = this.cm, display = cm.display;
+      removeChildrenAndAdd(display.cursorDiv, drawn.cursors);
+      removeChildrenAndAdd(display.selectionDiv, drawn.selection);
+      if (drawn.teTop != null) {
+        this.wrapper.style.top = drawn.teTop + "px";
+        this.wrapper.style.left = drawn.teLeft + "px";
+      }
+    },
+
+    // Reset the input to correspond to the selection (or to be empty,
+    // when not typing and nothing is selected)
+    reset: function(typing) {
+      if (this.contextMenuPending) return;
+      var minimal, selected, cm = this.cm, doc = cm.doc;
+      if (cm.somethingSelected()) {
+        this.prevInput = "";
+        var range = doc.sel.primary();
+        minimal = hasCopyEvent &&
+          (range.to().line - range.from().line > 100 || (selected = cm.getSelection()).length > 1000);
+        var content = minimal ? "-" : selected || cm.getSelection();
+        this.textarea.value = content;
+        if (cm.state.focused) selectInput(this.textarea);
+        if (ie && ie_version >= 9) this.hasSelection = content;
+      } else if (!typing) {
+        this.prevInput = this.textarea.value = "";
+        if (ie && ie_version >= 9) this.hasSelection = null;
+      }
+      this.inaccurateSelection = minimal;
+    },
+
+    getField: function() { return this.textarea; },
+
+    supportsTouch: function() { return false; },
+
+    focus: function() {
+      if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) {
+        try { this.textarea.focus(); }
+        catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
+      }
+    },
+
+    blur: function() { this.textarea.blur(); },
+
+    resetPosition: function() {
+      this.wrapper.style.top = this.wrapper.style.left = 0;
+    },
+
+    receivedFocus: function() { this.slowPoll(); },
+
+    // Poll for input changes, using the normal rate of polling. This
+    // runs as long as the editor is focused.
+    slowPoll: function() {
+      var input = this;
+      if (input.pollingFast) return;
+      input.polling.set(this.cm.options.pollInterval, function() {
+        input.poll();
+        if (input.cm.state.focused) input.slowPoll();
+      });
+    },
+
+    // When an event has just come in that is likely to add or change
+    // something in the input textarea, we poll faster, to ensure that
+    // the change appears on the screen quickly.
+    fastPoll: function() {
+      var missed = false, input = this;
+      input.pollingFast = true;
+      function p() {
+        var changed = input.poll();
+        if (!changed && !missed) {missed = true; input.polling.set(60, p);}
+        else {input.pollingFast = false; input.slowPoll();}
+      }
+      input.polling.set(20, p);
+    },
+
+    // Read input from the textarea, and update the document to match.
+    // When something is selected, it is present in the textarea, and
+    // selected (unless it is huge, in which case a placeholder is
+    // used). When nothing is selected, the cursor sits after previously
+    // seen text (can be empty), which is stored in prevInput (we must
+    // not reset the textarea when typing, because that breaks IME).
+    poll: function() {
+      var cm = this.cm, input = this.textarea, prevInput = this.prevInput;
+      // Since this is called a *lot*, try to bail out as cheaply as
+      // possible when it is clear that nothing happened. hasSelection
+      // will be the case when there is a lot of text in the textarea,
+      // in which case reading its value would be expensive.
+      if (!cm.state.focused || (hasSelection(input) && !prevInput) ||
+          isReadOnly(cm) || cm.options.disableInput || cm.state.keySeq)
+        return false;
+      // See paste handler for more on the fakedLastChar kludge
+      if (cm.state.pasteIncoming && cm.state.fakedLastChar) {
+        input.value = input.value.substring(0, input.value.length - 1);
+        cm.state.fakedLastChar = false;
+      }
+      var text = input.value;
+      // If nothing changed, bail.
+      if (text == prevInput && !cm.somethingSelected()) return false;
+      // Work around nonsensical selection resetting in IE9/10, and
+      // inexplicable appearance of private area unicode characters on
+      // some key combos in Mac (#2689).
+      if (ie && ie_version >= 9 && this.hasSelection === text ||
+          mac && /[\uf700-\uf7ff]/.test(text)) {
+        cm.display.input.reset();
+        return false;
+      }
+
+      if (text.charCodeAt(0) == 0x200b && cm.doc.sel == cm.display.selForContextMenu && !prevInput)
+        prevInput = "\u200b";
+      // Find the part of the input that is actually new
+      var same = 0, l = Math.min(prevInput.length, text.length);
+      while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) ++same;
+
+      var self = this;
+      runInOp(cm, function() {
+        applyTextInput(cm, text.slice(same), prevInput.length - same);
+
+        // Don't leave long text in the textarea, since it makes further polling slow
+        if (text.length > 1000 || text.indexOf("\n") > -1) input.value = self.prevInput = "";
+        else self.prevInput = text;
+      });
+      return true;
+    },
+
+    ensurePolled: function() {
+      if (this.pollingFast && this.poll()) this.pollingFast = false;
+    },
+
+    onKeyPress: function() {
+      if (ie && ie_version >= 9) this.hasSelection = null;
+      this.fastPoll();
+    },
+
+    onContextMenu: function(e) {
+      var input = this, cm = input.cm, display = cm.display, te = input.textarea;
+      var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop;
+      if (!pos || presto) return; // Opera is difficult.
+
+      // Reset the current text selection only if the click is done outside of the selection
+      // and 'resetSelectionOnContextMenu' option is true.
+      var reset = cm.options.resetSelectionOnContextMenu;
+      if (reset && cm.doc.sel.contains(pos) == -1)
+        operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll);
+
+      var oldCSS = te.style.cssText;
+      input.wrapper.style.position = "absolute";
+      te.style.cssText = "position: fixed; width: 30px; height: 30px; top: " + (e.clientY - 5) +
+        "px; left: " + (e.clientX - 5) + "px; z-index: 1000; background: " +
+        (ie ? "rgba(255, 255, 255, .05)" : "transparent") +
+        "; outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);";
+      if (webkit) var oldScrollY = window.scrollY; // Work around Chrome issue (#2712)
+      display.input.focus();
+      if (webkit) window.scrollTo(null, oldScrollY);
+      display.input.reset();
+      // Adds "Select all" to context menu in FF
+      if (!cm.somethingSelected()) te.value = input.prevInput = " ";
+      input.contextMenuPending = true;
+      display.selForContextMenu = cm.doc.sel;
+      clearTimeout(display.detectingSelectAll);
+
+      // Select-all will be greyed out if there's nothing to select, so
+      // this adds a zero-width space so that we can later check whether
+      // it got selected.
+      function prepareSelectAllHack() {
+        if (te.selectionStart != null) {
+          var selected = cm.somethingSelected();
+          var extval = te.value = "\u200b" + (selected ? te.value : "");
+          input.prevInput = selected ? "" : "\u200b";
+          te.selectionStart = 1; te.selectionEnd = extval.length;
+          // Re-set this, in case some other handler touched the
+          // selection in the meantime.
+          display.selForContextMenu = cm.doc.sel;
+        }
+      }
+      function rehide() {
+        input.contextMenuPending = false;
+        input.wrapper.style.position = "relative";
+        te.style.cssText = oldCSS;
+        if (ie && ie_version < 9) display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos);
+
+        // Try to detect the user choosing select-all
+        if (te.selectionStart != null) {
+          if (!ie || (ie && ie_version < 9)) prepareSelectAllHack();
+          var i = 0, poll = function() {
+            if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0)
+              operation(cm, commands.selectAll)(cm);
+            else if (i++ < 10) display.detectingSelectAll = setTimeout(poll, 500);
+            else display.input.reset();
+          };
+          display.detectingSelectAll = setTimeout(poll, 200);
+        }
+      }
+
+      if (ie && ie_version >= 9) prepareSelectAllHack();
+      if (captureRightClick) {
+        e_stop(e);
+        var mouseup = function() {
+          off(window, "mouseup", mouseup);
+          setTimeout(rehide, 20);
+        };
+        on(window, "mouseup", mouseup);
+      } else {
+        setTimeout(rehide, 50);
+      }
+    },
+
+    setUneditable: nothing,
+
+    needsContentAttribute: false
+  }, TextareaInput.prototype);
+
+  // CONTENTEDITABLE INPUT STYLE
+
+  function ContentEditableInput(cm) {
+    this.cm = cm;
+    this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null;
+    this.polling = new Delayed();
+  }
+
+  ContentEditableInput.prototype = copyObj({
+    init: function(display) {
+      var input = this, cm = input.cm;
+      var div = input.div = display.lineDiv;
+      div.contentEditable = "true";
+      disableBrowserMagic(div);
+
+      on(div, "paste", function(e) {
+        var pasted = e.clipboardData && e.clipboardData.getData("text/plain");
+        if (pasted) {
+          e.preventDefault();
+          cm.replaceSelection(pasted, null, "paste");
+        }
+      });
+
+      on(div, "compositionstart", function(e) {
+        var data = e.data;
+        input.composing = {sel: cm.doc.sel, data: data, startData: data};
+        if (!data) return;
+        var prim = cm.doc.sel.primary();
+        var line = cm.getLine(prim.head.line);
+        var found = line.indexOf(data, Math.max(0, prim.head.ch - data.length));
+        if (found > -1 && found <= prim.head.ch)
+          input.composing.sel = simpleSelection(Pos(prim.head.line, found),
+                                                Pos(prim.head.line, found + data.length));
+      });
+      on(div, "compositionupdate", function(e) {
+        input.composing.data = e.data;
+      });
+      on(div, "compositionend", function(e) {
+        var ours = input.composing;
+        if (!ours) return;
+        if (e.data != ours.startData && !/\u200b/.test(e.data))
+          ours.data = e.data;
+        // Need a small delay to prevent other code (input event,
+        // selection polling) from doing damage when fired right after
+        // compositionend.
+        setTimeout(function() {
+          if (!ours.handled)
+            input.applyComposition(ours);
+          if (input.composing == ours)
+            input.composing = null;
+        }, 50);
+      });
+
+      on(div, "touchstart", function() {
+        input.forceCompositionEnd();
+      });
+
+      on(div, "input", function() {
+        if (input.composing) return;
+        if (!input.pollContent())
+          runInOp(input.cm, function() {regChange(cm);});
+      });
+
+      function onCopyCut(e) {
+        if (cm.somethingSelected()) {
+          lastCopied = cm.getSelections();
+          if (e.type == "cut") cm.replaceSelection("", null, "cut");
+        } else {
+          var ranges = copyableRanges(cm);
+          lastCopied = ranges.text;
+          if (e.type == "cut") {
+            cm.operation(function() {
+              cm.setSelections(ranges.ranges, 0, sel_dontScroll);
+              cm.replaceSelection("", null, "cut");
+            });
+          }
+        }
+        // iOS exposes the clipboard API, but seems to discard content inserted into it
+        if (e.clipboardData && !ios) {
+          e.preventDefault();
+          e.clipboardData.clearData();
+          e.clipboardData.setData("text/plain", lastCopied.join("\n"));
+        } else {
+          // Old-fashioned briefly-focus-a-textarea hack
+          var kludge = hiddenTextarea(), te = kludge.firstChild;
+          cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild);
+          te.value = lastCopied.join("\n");
+          var hadFocus = document.activeElement;
+          selectInput(te);
+          setTimeout(function() {
+            cm.display.lineSpace.removeChild(kludge);
+            hadFocus.focus();
+          }, 50);
+        }
+      }
+      on(div, "copy", onCopyCut);
+      on(div, "cut", onCopyCut);
+    },
+
+    prepareSelection: function() {
+      var result = prepareSelection(this.cm, false);
+      result.focus = this.cm.state.focused;
+      return result;
+    },
+
+    showSelection: function(info) {
+      if (!info || !this.cm.display.view.length) return;
+      if (info.focus) this.showPrimarySelection();
+      this.showMultipleSelections(info);
+    },
+
+    showPrimarySelection: function() {
+      var sel = window.getSelection(), prim = this.cm.doc.sel.primary();
+      var curAnchor = domToPos(this.cm, sel.anchorNode, sel.anchorOffset);
+      var curFocus = domToPos(this.cm, sel.focusNode, sel.focusOffset);
+      if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&
+          cmp(minPos(curAnchor, curFocus), prim.from()) == 0 &&
+          cmp(maxPos(curAnchor, curFocus), prim.to()) == 0)
+        return;
+
+      var start = posToDOM(this.cm, prim.from());
+      var end = posToDOM(this.cm, prim.to());
+      if (!start && !end) return;
+
+      var view = this.cm.display.view;
+      var old = sel.rangeCount && sel.getRangeAt(0);
+      if (!start) {
+        start = {node: view[0].measure.map[2], offset: 0};
+      } else if (!end) { // FIXME dangerously hacky
+        var measure = view[view.length - 1].measure;
+        var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map;
+        end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]};
+      }
+
+      try { var rng = range(start.node, start.offset, end.offset, end.node); }
+      catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible
+      if (rng) {
+        sel.removeAllRanges();
+        sel.addRange(rng);
+        if (old && sel.anchorNode == null) sel.addRange(old);
+      }
+      this.rememberSelection();
+    },
+
+    showMultipleSelections: function(info) {
+      removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors);
+      removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection);
+    },
+
+    rememberSelection: function() {
+      var sel = window.getSelection();
+      this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset;
+      this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset;
+    },
+
+    selectionInEditor: function() {
+      var sel = window.getSelection();
+      if (!sel.rangeCount) return false;
+      var node = sel.getRangeAt(0).commonAncestorContainer;
+      return contains(this.div, node);
+    },
+
+    focus: function() {
+      if (this.cm.options.readOnly != "nocursor") this.div.focus();
+    },
+    blur: function() { this.div.blur(); },
+    getField: function() { return this.div; },
+
+    supportsTouch: function() { return true; },
+
+    receivedFocus: function() {
+      var input = this;
+      if (this.selectionInEditor())
+        this.pollSelection();
+      else
+        runInOp(this.cm, function() { input.cm.curOp.selectionChanged = true; });
+
+      function poll() {
+        if (input.cm.state.focused) {
+          input.pollSelection();
+          input.polling.set(input.cm.options.pollInterval, poll);
+        }
+      }
+      this.polling.set(this.cm.options.pollInterval, poll);
+    },
+
+    pollSelection: function() {
+      if (this.composing) return;
+
+      var sel = window.getSelection(), cm = this.cm;
+      if (sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
+          sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset) {
+        this.rememberSelection();
+        var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);
+        var head = domToPos(cm, sel.focusNode, sel.focusOffset);
+        if (anchor && head) runInOp(cm, function() {
+          setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll);
+          if (anchor.bad || head.bad) cm.curOp.selectionChanged = true;
+        });
+      }
+    },
+
+    pollContent: function() {
+      var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary();
+      var from = sel.from(), to = sel.to();
+      if (from.line < display.viewFrom || to.line > display.viewTo - 1) return false;
+
+      var fromIndex;
+      if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {
+        var fromLine = lineNo(display.view[0].line);
+        var fromNode = display.view[0].node;
+      } else {
+        var fromLine = lineNo(display.view[fromIndex].line);
+        var fromNode = display.view[fromIndex - 1].node.nextSibling;
+      }
+      var toIndex = findViewIndex(cm, to.line);
+      if (toIndex == display.view.length - 1) {
+        var toLine = display.viewTo - 1;
+        var toNode = display.view[toIndex].node;
+      } else {
+        var toLine = lineNo(display.view[toIndex + 1].line) - 1;
+        var toNode = display.view[toIndex + 1].node.previousSibling;
+      }
+
+      var newText = splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine));
+      var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length));
+      while (newText.length > 1 && oldText.length > 1) {
+        if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine--; }
+        else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++; }
+        else break;
+      }
+
+      var cutFront = 0, cutEnd = 0;
+      var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length);
+      while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))
+        ++cutFront;
+      var newBot = lst(newText), oldBot = lst(oldText);
+      var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),
+                               oldBot.length - (oldText.length == 1 ? cutFront : 0));
+      while (cutEnd < maxCutEnd &&
+             newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))
+        ++cutEnd;
+
+      newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd);
+      newText[0] = newText[0].slice(cutFront);
+
+      var chFrom = Pos(fromLine, cutFront);
+      var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0);
+      if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
+        replaceRange(cm.doc, newText, chFrom, chTo, "+input");
+        return true;
+      }
+    },
+
+    ensurePolled: function() {
+      this.forceCompositionEnd();
+    },
+    reset: function() {
+      this.forceCompositionEnd();
+    },
+    forceCompositionEnd: function() {
+      if (!this.composing || this.composing.handled) return;
+      this.applyComposition(this.composing);
+      this.composing.handled = true;
+      this.div.blur();
+      this.div.focus();
+    },
+    applyComposition: function(composing) {
+      if (composing.data && composing.data != composing.startData)
+        operation(this.cm, applyTextInput)(this.cm, composing.data, 0, composing.sel);
+    },
+
+    setUneditable: function(node) {
+      node.setAttribute("contenteditable", "false");
+    },
+
+    onKeyPress: function(e) {
+      e.preventDefault();
+      operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0);
+    },
+
+    onContextMenu: nothing,
+    resetPosition: nothing,
+
+    needsContentAttribute: true
+  }, ContentEditableInput.prototype);
+
+  function posToDOM(cm, pos) {
+    var view = findViewForLine(cm, pos.line);
+    if (!view || view.hidden) return null;
+    var line = getLine(cm.doc, pos.line);
+    var info = mapFromLineView(view, line, pos.line);
+
+    var order = getOrder(line), side = "left";
+    if (order) {
+      var partPos = getBidiPartAt(order, pos.ch);
+      side = partPos % 2 ? "right" : "left";
+    }
+    var result = nodeAndOffsetInLineMap(info.map, pos.ch, "left");
+    result.offset = result.collapse == "right" ? result.end : result.start;
+    return result;
+  }
+
+  function badPos(pos, bad) { if (bad) pos.bad = true; return pos; }
+
+  function domToPos(cm, node, offset) {
+    var lineNode;
+    if (node == cm.display.lineDiv) {
+      lineNode = cm.display.lineDiv.childNodes[offset];
+      if (!lineNode) return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true);
+      node = null; offset = 0;
+    } else {
+      for (lineNode = node;; lineNode = lineNode.parentNode) {
+        if (!lineNode || lineNode == cm.display.lineDiv) return null;
+        if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) break;
+      }
+    }
+    for (var i = 0; i < cm.display.view.length; i++) {
+      var lineView = cm.display.view[i];
+      if (lineView.node == lineNode)
+        return locateNodeInLineView(lineView, node, offset);
+    }
+  }
+
+  function locateNodeInLineView(lineView, node, offset) {
+    var wrapper = lineView.text.firstChild, bad = false;
+    if (!node || !contains(wrapper, node)) return badPos(Pos(lineNo(lineView.line), 0), true);
+    if (node == wrapper) {
+      bad = true;
+      node = wrapper.childNodes[offset];
+      offset = 0;
+      if (!node) {
+        var line = lineView.rest ? lst(lineView.rest) : lineView.line;
+        return badPos(Pos(lineNo(line), line.text.length), bad);
+      }
+    }
+
+    var textNode = node.nodeType == 3 ? node : null, topNode = node;
+    if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {
+      textNode = node.firstChild;
+      if (offset) offset = textNode.nodeValue.length;
+    }
+    while (topNode.parentNode != wrapper) topNode = topNode.parentNode;
+    var measure = lineView.measure, maps = measure.maps;
+
+    function find(textNode, topNode, offset) {
+      for (var i = -1; i < (maps ? maps.length : 0); i++) {
+        var map = i < 0 ? measure.map : maps[i];
+        for (var j = 0; j < map.length; j += 3) {
+          var curNode = map[j + 2];
+          if (curNode == textNode || curNode == topNode) {
+            var line = lineNo(i < 0 ? lineView.line : lineView.rest[i]);
+            var ch = map[j] + offset;
+            if (offset < 0 || curNode != textNode) ch = map[j + (offset ? 1 : 0)];
+            return Pos(line, ch);
+          }
+        }
+      }
+    }
+    var found = find(textNode, topNode, offset);
+    if (found) return badPos(found, bad);
+
+    // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems
+    for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {
+      found = find(after, after.firstChild, 0);
+      if (found)
+        return badPos(Pos(found.line, found.ch - dist), bad);
+      else
+        dist += after.textContent.length;
+    }
+    for (var before = topNode.previousSibling, dist = offset; before; before = before.previousSibling) {
+      found = find(before, before.firstChild, -1);
+      if (found)
+        return badPos(Pos(found.line, found.ch + dist), bad);
+      else
+        dist += after.textContent.length;
+    }
+  }
+
+  function domTextBetween(cm, from, to, fromLine, toLine) {
+    var text = "", closing = false;
+    function recognizeMarker(id) { return function(marker) { return marker.id == id; }; }
+    function walk(node) {
+      if (node.nodeType == 1) {
+        var cmText = node.getAttribute("cm-text");
+        if (cmText != null) {
+          if (cmText == "") cmText = node.textContent.replace(/\u200b/g, "");
+          text += cmText;
+          return;
+        }
+        var markerID = node.getAttribute("cm-marker"), range;
+        if (markerID) {
+          var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID));
+          if (found.length && (range = found[0].find()))
+            text += getBetween(cm.doc, range.from, range.to).join("\n");
+          return;
+        }
+        if (node.getAttribute("contenteditable") == "false") return;
+        for (var i = 0; i < node.childNodes.length; i++)
+          walk(node.childNodes[i]);
+        if (/^(pre|div|p)$/i.test(node.nodeName))
+          closing = true;
+      } else if (node.nodeType == 3) {
+        var val = node.nodeValue;
+        if (!val) return;
+        if (closing) {
+          text += "\n";
+          closing = false;
+        }
+        text += val;
+      }
+    }
+    for (;;) {
+      walk(from);
+      if (from == to) break;
+      from = from.nextSibling;
+    }
+    return text;
+  }
+
+  CodeMirror.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput};
+
+  // SELECTION / CURSOR
+
+  // Selection objects are immutable. A new one is created every time
+  // the selection changes. A selection is one or more non-overlapping
+  // (and non-touching) ranges, sorted, and an integer that indicates
+  // which one is the primary selection (the one that's scrolled into
+  // view, that getCursor returns, etc).
+  function Selection(ranges, primIndex) {
+    this.ranges = ranges;
+    this.primIndex = primIndex;
+  }
+
+  Selection.prototype = {
+    primary: function() { return this.ranges[this.primIndex]; },
+    equals: function(other) {
+      if (other == this) return true;
+      if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) return false;
+      for (var i = 0; i < this.ranges.length; i++) {
+        var here = this.ranges[i], there = other.ranges[i];
+        if (cmp(here.anchor, there.anchor) != 0 || cmp(here.head, there.head) != 0) return false;
+      }
+      return true;
+    },
+    deepCopy: function() {
+      for (var out = [], i = 0; i < this.ranges.length; i++)
+        out[i] = new Range(copyPos(this.ranges[i].anchor), copyPos(this.ranges[i].head));
+      return new Selection(out, this.primIndex);
+    },
+    somethingSelected: function() {
+      for (var i = 0; i < this.ranges.length; i++)
+        if (!this.ranges[i].empty()) return true;
+      return false;
+    },
+    contains: function(pos, end) {
+      if (!end) end = pos;
+      for (var i = 0; i < this.ranges.length; i++) {
+        var range = this.ranges[i];
+        if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
+          return i;
+      }
+      return -1;
+    }
+  };
+
+  function Range(anchor, head) {
+    this.anchor = anchor; this.head = head;
+  }
+
+  Range.prototype = {
+    from: function() { return minPos(this.anchor, this.head); },
+    to: function() { return maxPos(this.anchor, this.head); },
+    empty: function() {
+      return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch;
+    }
+  };
+
+  // Take an unsorted, potentially overlapping set of ranges, and
+  // build a selection out of it. 'Consumes' ranges array (modifying
+  // it).
+  function normalizeSelection(ranges, primIndex) {
+    var prim = ranges[primIndex];
+    ranges.sort(function(a, b) { return cmp(a.from(), b.from()); });
+    primIndex = indexOf(ranges, prim);
+    for (var i = 1; i < ranges.length; i++) {
+      var cur = ranges[i], prev = ranges[i - 1];
+      if (cmp(prev.to(), cur.from()) >= 0) {
+        var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to());
+        var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head;
+        if (i <= primIndex) --primIndex;
+        ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to));
+      }
+    }
+    return new Selection(ranges, primIndex);
+  }
+
+  function simpleSelection(anchor, head) {
+    return new Selection([new Range(anchor, head || anchor)], 0);
+  }
+
+  // Most of the external API clips given positions to make sure they
+  // actually exist within the document.
+  function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1));}
+  function clipPos(doc, pos) {
+    if (pos.line < doc.first) return Pos(doc.first, 0);
+    var last = doc.first + doc.size - 1;
+    if (pos.line > last) return Pos(last, getLine(doc, last).text.length);
+    return clipToLen(pos, getLine(doc, pos.line).text.length);
+  }
+  function clipToLen(pos, linelen) {
+    var ch = pos.ch;
+    if (ch == null || ch > linelen) return Pos(pos.line, linelen);
+    else if (ch < 0) return Pos(pos.line, 0);
+    else return pos;
+  }
+  function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size;}
+  function clipPosArray(doc, array) {
+    for (var out = [], i = 0; i < array.length; i++) out[i] = clipPos(doc, array[i]);
+    return out;
+  }
+
+  // SELECTION UPDATES
+
+  // The 'scroll' parameter given to many of these indicated whether
+  // the new cursor position should be scrolled into view after
+  // modifying the selection.
+
+  // If shift is held or the extend flag is set, extends a range to
+  // include a given position (and optionally a second position).
+  // Otherwise, simply returns the range between the given positions.
+  // Used for cursor motion and such.
+  function extendRange(doc, range, head, other) {
+    if (doc.cm && doc.cm.display.shift || doc.extend) {
+      var anchor = range.anchor;
+      if (other) {
+        var posBefore = cmp(head, anchor) < 0;
+        if (posBefore != (cmp(other, anchor) < 0)) {
+          anchor = head;
+          head = other;
+        } else if (posBefore != (cmp(head, other) < 0)) {
+          head = other;
+        }
+      }
+      return new Range(anchor, head);
+    } else {
+      return new Range(other || head, head);
+    }
+  }
+
+  // Extend the primary selection range, discard the rest.
+  function extendSelection(doc, head, other, options) {
+    setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options);
+  }
+
+  // Extend all selections (pos is an array of selections with length
+  // equal the number of selections)
+  function extendSelections(doc, heads, options) {
+    for (var out = [], i = 0; i < doc.sel.ranges.length; i++)
+      out[i] = extendRange(doc, doc.sel.ranges[i], heads[i], null);
+    var newSel = normalizeSelection(out, doc.sel.primIndex);
+    setSelection(doc, newSel, options);
+  }
+
+  // Updates a single range in the selection.
+  function replaceOneSelection(doc, i, range, options) {
+    var ranges = doc.sel.ranges.slice(0);
+    ranges[i] = range;
+    setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options);
+  }
+
+  // Reset the selection to a single range.
+  function setSimpleSelection(doc, anchor, head, options) {
+    setSelection(doc, simpleSelection(anchor, head), options);
+  }
+
+  // Give beforeSelectionChange handlers a change to influence a
+  // selection update.
+  function filterSelectionChange(doc, sel) {
+    var obj = {
+      ranges: sel.ranges,
+      update: function(ranges) {
+        this.ranges = [];
+        for (var i = 0; i < ranges.length; i++)
+          this.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),
+                                     clipPos(doc, ranges[i].head));
+      }
+    };
+    signal(doc, "beforeSelectionChange", doc, obj);
+    if (doc.cm) signal(doc.cm, "beforeSelectionChange", doc.cm, obj);
+    if (obj.ranges != sel.ranges) return normalizeSelection(obj.ranges, obj.ranges.length - 1);
+    else return sel;
+  }
+
+  function setSelectionReplaceHistory(doc, sel, options) {
+    var done = doc.history.done, last = lst(done);
+    if (last && last.ranges) {
+      done[done.length - 1] = sel;
+      setSelectionNoUndo(doc, sel, options);
+    } else {
+      setSelection(doc, sel, options);
+    }
+  }
+
+  // Set a new selection.
+  function setSelection(doc, sel, options) {
+    setSelectionNoUndo(doc, sel, options);
+    addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options);
+  }
+
+  function setSelectionNoUndo(doc, sel, options) {
+    if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
+      sel = filterSelectionChange(doc, sel);
+
+    var bias = options && options.bias ||
+      (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1);
+    setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true));
+
+    if (!(options && options.scroll === false) && doc.cm)
+      ensureCursorVisible(doc.cm);
+  }
+
+  function setSelectionInner(doc, sel) {
+    if (sel.equals(doc.sel)) return;
+
+    doc.sel = sel;
+
+    if (doc.cm) {
+      doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true;
+      signalCursorActivity(doc.cm);
+    }
+    signalLater(doc, "cursorActivity", doc);
+  }
+
+  // Verify that the selection does not partially select any atomic
+  // marked ranges.
+  function reCheckSelection(doc) {
+    setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false), sel_dontScroll);
+  }
+
+  // Return a selection that does not partially select any atomic
+  // ranges.
+  function skipAtomicInSelection(doc, sel, bias, mayClear) {
+    var out;
+    for (var i = 0; i < sel.ranges.length; i++) {
+      var range = sel.ranges[i];
+      var newAnchor = skipAtomic(doc, range.anchor, bias, mayClear);
+      var newHead = skipAtomic(doc, range.head, bias, mayClear);
+      if (out || newAnchor != range.anchor || newHead != range.head) {
+        if (!out) out = sel.ranges.slice(0, i);
+        out[i] = new Range(newAnchor, newHead);
+      }
+    }
+    return out ? normalizeSelection(out, sel.primIndex) : sel;
+  }
+
+  // Ensure a given position is not inside an atomic range.
+  function skipAtomic(doc, pos, bias, mayClear) {
+    var flipped = false, curPos = pos;
+    var dir = bias || 1;
+    doc.cantEdit = false;
+    search: for (;;) {
+      var line = getLine(doc, curPos.line);
+      if (line.markedSpans) {
+        for (var i = 0; i < line.markedSpans.length; ++i) {
+          var sp = line.markedSpans[i], m = sp.marker;
+          if ((sp.from == null || (m.inclusiveLeft ? sp.from <= curPos.ch : sp.from < curPos.ch)) &&
+              (sp.to == null || (m.inclusiveRight ? sp.to >= curPos.ch : sp.to > curPos.ch))) {
+            if (mayClear) {
+              signal(m, "beforeCursorEnter");
+              if (m.explicitlyCleared) {
+                if (!line.markedSpans) break;
+                else {--i; continue;}
+              }
+            }
+            if (!m.atomic) continue;
+            var newPos = m.find(dir < 0 ? -1 : 1);
+            if (cmp(newPos, curPos) == 0) {
+              newPos.ch += dir;
+              if (newPos.ch < 0) {
+                if (newPos.line > doc.first) newPos = clipPos(doc, Pos(newPos.line - 1));
+                else newPos = null;
+              } else if (newPos.ch > line.text.length) {
+                if (newPos.line < doc.first + doc.size - 1) newPos = Pos(newPos.line + 1, 0);
+                else newPos = null;
+              }
+              if (!newPos) {
+                if (flipped) {
+                  // Driven in a corner -- no valid cursor position found at all
+                  // -- try again *with* clearing, if we didn't already
+                  if (!mayClear) return skipAtomic(doc, pos, bias, true);
+                  // Otherwise, turn off editing until further notice, and return the start of the doc
+                  doc.cantEdit = true;
+                  return Pos(doc.first, 0);
+                }
+                flipped = true; newPos = pos; dir = -dir;
+              }
+            }
+            curPos = newPos;
+            continue search;
+          }
+        }
+      }
+      return curPos;
+    }
+  }
+
+  // SELECTION DRAWING
+
+  function updateSelection(cm) {
+    cm.display.input.showSelection(cm.display.input.prepareSelection());
+  }
+
+  function prepareSelection(cm, primary) {
+    var doc = cm.doc, result = {};
+    var curFragment = result.cursors = document.createDocumentFragment();
+    var selFragment = result.selection = document.createDocumentFragment();
+
+    for (var i = 0; i < doc.sel.ranges.length; i++) {
+      if (primary === false && i == doc.sel.primIndex) continue;
+      var range = doc.sel.ranges[i];
+      var collapsed = range.empty();
+      if (collapsed || cm.options.showCursorWhenSelecting)
+        drawSelectionCursor(cm, range, curFragment);
+      if (!collapsed)
+        drawSelectionRange(cm, range, selFragment);
+    }
+    return result;
+  }
+
+  // Draws a cursor for the given range
+  function drawSelectionCursor(cm, range, output) {
+    var pos = cursorCoords(cm, range.head, "div", null, null, !cm.options.singleCursorHeightPerLine);
+
+    var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"));
+    cursor.style.left = pos.left + "px";
+    cursor.style.top = pos.top + "px";
+    cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px";
+
+    if (pos.other) {
+      // Secondary cursor, shown when on a 'jump' in bi-directional text
+      var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"));
+      otherCursor.style.display = "";
+      otherCursor.style.left = pos.other.left + "px";
+      otherCursor.style.top = pos.other.top + "px";
+      otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px";
+    }
+  }
+
+  // Draws the given range as a highlighted selection
+  function drawSelectionRange(cm, range, output) {
+    var display = cm.display, doc = cm.doc;
+    var fragment = document.createDocumentFragment();
+    var padding = paddingH(cm.display), leftSide = padding.left;
+    var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right;
+
+    function add(left, top, width, bottom) {
+      if (top < 0) top = 0;
+      top = Math.round(top);
+      bottom = Math.round(bottom);
+      fragment.appendChild(elt("div", null, "CodeMirror-selected", "position: absolute; left: " + left +
+                               "px; top: " + top + "px; width: " + (width == null ? rightSide - left : width) +
+                               "px; height: " + (bottom - top) + "px"));
+    }
+
+    function drawForLine(line, fromArg, toArg) {
+      var lineObj = getLine(doc, line);
+      var lineLen = lineObj.text.length;
+      var start, end;
+      function coords(ch, bias) {
+        return charCoords(cm, Pos(line, ch), "div", lineObj, bias);
+      }
+
+      iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function(from, to, dir) {
+        var leftPos = coords(from, "left"), rightPos, left, right;
+        if (from == to) {
+          rightPos = leftPos;
+          left = right = leftPos.left;
+        } else {
+          rightPos = coords(to - 1, "right");
+          if (dir == "rtl") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp; }
+          left = leftPos.left;
+          right = rightPos.right;
+        }
+        if (fromArg == null && from == 0) left = leftSide;
+        if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part
+          add(left, leftPos.top, null, leftPos.bottom);
+          left = leftSide;
+          if (leftPos.bottom < rightPos.top) add(left, leftPos.bottom, null, rightPos.top);
+        }
+        if (toArg == null && to == lineLen) right = rightSide;
+        if (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left)
+          start = leftPos;
+        if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right)
+          end = rightPos;
+        if (left < leftSide + 1) left = leftSide;
+        add(left, rightPos.top, right - left, rightPos.bottom);
+      });
+      return {start: start, end: end};
+    }
+
+    var sFrom = range.from(), sTo = range.to();
+    if (sFrom.line == sTo.line) {
+      drawForLine(sFrom.line, sFrom.ch, sTo.ch);
+    } else {
+      var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line);
+      var singleVLine = visualLine(fromLine) == visualLine(toLine);
+      var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end;
+      var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start;
+      if (singleVLine) {
+        if (leftEnd.top < rightStart.top - 2) {
+          add(leftEnd.right, leftEnd.top, null, leftEnd.bottom);
+          add(leftSide, rightStart.top, rightStart.left, rightStart.bottom);
+        } else {
+          add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom);
+        }
+      }
+      if (leftEnd.bottom < rightStart.top)
+        add(leftSide, leftEnd.bottom, null, rightStart.top);
+    }
+
+    output.appendChild(fragment);
+  }
+
+  // Cursor-blinking
+  function restartBlink(cm) {
+    if (!cm.state.focused) return;
+    var display = cm.display;
+    clearInterval(display.blinker);
+    var on = true;
+    display.cursorDiv.style.visibility = "";
+    if (cm.options.cursorBlinkRate > 0)
+      display.blinker = setInterval(function() {
+        display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden";
+      }, cm.options.cursorBlinkRate);
+    else if (cm.options.cursorBlinkRate < 0)
+      display.cursorDiv.style.visibility = "hidden";
+  }
+
+  // HIGHLIGHT WORKER
+
+  function startWorker(cm, time) {
+    if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)
+      cm.state.highlight.set(time, bind(highlightWorker, cm));
+  }
+
+  function highlightWorker(cm) {
+    var doc = cm.doc;
+    if (doc.frontier < doc.first) doc.frontier = doc.first;
+    if (doc.frontier >= cm.display.viewTo) return;
+    var end = +new Date + cm.options.workTime;
+    var state = copyState(doc.mode, getStateBefore(cm, doc.frontier));
+    var changedLines = [];
+
+    doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function(line) {
+      if (doc.frontier >= cm.display.viewFrom) { // Visible
+        var oldStyles = line.styles;
+        var highlighted = highlightLine(cm, line, state, true);
+        line.styles = highlighted.styles;
+        var oldCls = line.styleClasses, newCls = highlighted.classes;
+        if (newCls) line.styleClasses = newCls;
+        else if (oldCls) line.styleClasses = null;
+        var ischange = !oldStyles || oldStyles.length != line.styles.length ||
+          oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass);
+        for (var i = 0; !ischange && i < oldStyles.length; ++i) ischange = oldStyles[i] != line.styles[i];
+        if (ischange) changedLines.push(doc.frontier);
+        line.stateAfter = copyState(doc.mode, state);
+      } else {
+        processLine(cm, line.text, state);
+        line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null;
+      }
+      ++doc.frontier;
+      if (+new Date > end) {
+        startWorker(cm, cm.options.workDelay);
+        return true;
+      }
+    });
+    if (changedLines.length) runInOp(cm, function() {
+      for (var i = 0; i < changedLines.length; i++)
+        regLineChange(cm, changedLines[i], "text");
+    });
+  }
+
+  // Finds the line to start with when starting a parse. Tries to
+  // find a line with a stateAfter, so that it can start with a
+  // valid state. If that fails, it returns the line with the
+  // smallest indentation, which tends to need the least context to
+  // parse correctly.
+  function findStartLine(cm, n, precise) {
+    var minindent, minline, doc = cm.doc;
+    var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100);
+    for (var search = n; search > lim; --search) {
+      if (search <= doc.first) return doc.first;
+      var line = getLine(doc, search - 1);
+      if (line.stateAfter && (!precise || search <= doc.frontier)) return search;
+      var indented = countColumn(line.text, null, cm.options.tabSize);
+      if (minline == null || minindent > indented) {
+        minline = search - 1;
+        minindent = indented;
+      }
+    }
+    return minline;
+  }
+
+  function getStateBefore(cm, n, precise) {
+    var doc = cm.doc, display = cm.display;
+    if (!doc.mode.startState) return true;
+    var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos-1).stateAfter;
+    if (!state) state = startState(doc.mode);
+    else state = copyState(doc.mode, state);
+    doc.iter(pos, n, function(line) {
+      processLine(cm, line.text, state);
+      var save = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo;
+      line.stateAfter = save ? copyState(doc.mode, state) : null;
+      ++pos;
+    });
+    if (precise) doc.frontier = pos;
+    return state;
+  }
+
+  // POSITION MEASUREMENT
+
+  function paddingTop(display) {return display.lineSpace.offsetTop;}
+  function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight;}
+  function paddingH(display) {
+    if (display.cachedPaddingH) return display.cachedPaddingH;
+    var e = removeChildrenAndAdd(display.measure, elt("pre", "x"));
+    var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle;
+    var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)};
+    if (!isNaN(data.left) && !isNaN(data.right)) display.cachedPaddingH = data;
+    return data;
+  }
+
+  function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth; }
+  function displayWidth(cm) {
+    return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth;
+  }
+  function displayHeight(cm) {
+    return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight;
+  }
+
+  // Ensure the lineView.wrapping.heights array is populated. This is
+  // an array of bottom offsets for the lines that make up a drawn
+  // line. When lineWrapping is on, there might be more than one
+  // height.
+  function ensureLineHeights(cm, lineView, rect) {
+    var wrapping = cm.options.lineWrapping;
+    var curWidth = wrapping && displayWidth(cm);
+    if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
+      var heights = lineView.measure.heights = [];
+      if (wrapping) {
+        lineView.measure.width = curWidth;
+        var rects = lineView.text.firstChild.getClientRects();
+        for (var i = 0; i < rects.length - 1; i++) {
+          var cur = rects[i], next = rects[i + 1];
+          if (Math.abs(cur.bottom - next.bottom) > 2)
+            heights.push((cur.bottom + next.top) / 2 - rect.top);
+        }
+      }
+      heights.push(rect.bottom - rect.top);
+    }
+  }
+
+  // Find a line map (mapping character offsets to text nodes) and a
+  // measurement cache for the given line number. (A line view might
+  // contain multiple lines when collapsed ranges are present.)
+  function mapFromLineView(lineView, line, lineN) {
+    if (lineView.line == line)
+      return {map: lineView.measure.map, cache: lineView.measure.cache};
+    for (var i = 0; i < lineView.rest.length; i++)
+      if (lineView.rest[i] == line)
+        return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]};
+    for (var i = 0; i < lineView.rest.length; i++)
+      if (lineNo(lineView.rest[i]) > lineN)
+        return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i], before: true};
+  }
+
+  // Render a line into the hidden node display.externalMeasured. Used
+  // when measurement is needed for a line that's not in the viewport.
+  function updateExternalMeasurement(cm, line) {
+    line = visualLine(line);
+    var lineN = lineNo(line);
+    var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN);
+    view.lineN = lineN;
+    var built = view.built = buildLineContent(cm, view);
+    view.text = built.pre;
+    removeChildrenAndAdd(cm.display.lineMeasure, built.pre);
+    return view;
+  }
+
+  // Get a {top, bottom, left, right} box (in line-local coordinates)
+  // for a given character.
+  function measureChar(cm, line, ch, bias) {
+    return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias);
+  }
+
+  // Find a line view that corresponds to the given line number.
+  function findViewForLine(cm, lineN) {
+    if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
+      return cm.display.view[findViewIndex(cm, lineN)];
+    var ext = cm.display.externalMeasured;
+    if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
+      return ext;
+  }
+
+  // Measurement can be split in two steps, the set-up work that
+  // applies to the whole line, and the measurement of the actual
+  // character. Functions like coordsChar, that need to do a lot of
+  // measurements in a row, can thus ensure that the set-up work is
+  // only done once.
+  function prepareMeasureForLine(cm, line) {
+    var lineN = lineNo(line);
+    var view = findViewForLine(cm, lineN);
+    if (view && !view.text)
+      view = null;
+    else if (view && view.changes)
+      updateLineForChanges(cm, view, lineN, getDimensions(cm));
+    if (!view)
+      view = updateExternalMeasurement(cm, line);
+
+    var info = mapFromLineView(view, line, lineN);
+    return {
+      line: line, view: view, rect: null,
+      map: info.map, cache: info.cache, before: info.before,
+      hasHeights: false
+    };
+  }
+
+  // Given a prepared measurement object, measures the position of an
+  // actual character (or fetches it from the cache).
+  function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
+    if (prepared.before) ch = -1;
+    var key = ch + (bias || ""), found;
+    if (prepared.cache.hasOwnProperty(key)) {
+      found = prepared.cache[key];
+    } else {
+      if (!prepared.rect)
+        prepared.rect = prepared.view.text.getBoundingClientRect();
+      if (!prepared.hasHeights) {
+        ensureLineHeights(cm, prepared.view, prepared.rect);
+        prepared.hasHeights = true;
+      }
+      found = measureCharInner(cm, prepared, ch, bias);
+      if (!found.bogus) prepared.cache[key] = found;
+    }
+    return {left: found.left, right: found.right,
+            top: varHeight ? found.rtop : found.top,
+            bottom: varHeight ? found.rbottom : found.bottom};
+  }
+
+  var nullRect = {left: 0, right: 0, top: 0, bottom: 0};
+
+  function nodeAndOffsetInLineMap(map, ch, bias) {
+    var node, start, end, collapse;
+    // First, search the line map for the text node corresponding to,
+    // or closest to, the target character.
+    for (var i = 0; i < map.length; i += 3) {
+      var mStart = map[i], mEnd = map[i + 1];
+      if (ch < mStart) {
+        start = 0; end = 1;
+        collapse = "left";
+      } else if (ch < mEnd) {
+        start = ch - mStart;
+        end = start + 1;
+      } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {
+        end = mEnd - mStart;
+        start = end - 1;
+        if (ch >= mEnd) collapse = "right";
+      }
+      if (start != null) {
+        node = map[i + 2];
+        if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right"))
+          collapse = bias;
+        if (bias == "left" && start == 0)
+          while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {
+            node = map[(i -= 3) + 2];
+            collapse = "left";
+          }
+        if (bias == "right" && start == mEnd - mStart)
+          while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {
+            node = map[(i += 3) + 2];
+            collapse = "right";
+          }
+        break;
+      }
+    }
+    return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd};
+  }
+
+  function measureCharInner(cm, prepared, ch, bias) {
+    var place = nodeAndOffsetInLineMap(prepared.map, ch, bias);
+    var node = place.node, start = place.start, end = place.end, collapse = place.collapse;
+
+    var rect;
+    if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
+      for (var i = 0; i < 4; i++) { // Retry a maximum of 4 times when nonsense rectangles are returned
+        while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) --start;
+        while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) ++end;
+        if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart) {
+          rect = node.parentNode.getBoundingClientRect();
+        } else if (ie && cm.options.lineWrapping) {
+          var rects = range(node, start, end).getClientRects();
+          if (rects.length)
+            rect = rects[bias == "right" ? rects.length - 1 : 0];
+          else
+            rect = nullRect;
+        } else {
+          rect = range(node, start, end).getBoundingClientRect() || nullRect;
+        }
+        if (rect.left || rect.right || start == 0) break;
+        end = start;
+        start = start - 1;
+        collapse = "right";
+      }
+      if (ie && ie_version < 11) rect = maybeUpdateRectForZooming(cm.display.measure, rect);
+    } else { // If it is a widget, simply get the box for the whole widget.
+      if (start > 0) collapse = bias = "right";
+      var rects;
+      if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
+        rect = rects[bias == "right" ? rects.length - 1 : 0];
+      else
+        rect = node.getBoundingClientRect();
+    }
+    if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
+      var rSpan = node.parentNode.getClientRects()[0];
+      if (rSpan)
+        rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom};
+      else
+        rect = nullRect;
+    }
+
+    var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top;
+    var mid = (rtop + rbot) / 2;
+    var heights = prepared.view.measure.heights;
+    for (var i = 0; i < heights.length - 1; i++)
+      if (mid < heights[i]) break;
+    var top = i ? heights[i - 1] : 0, bot = heights[i];
+    var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left,
+                  right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left,
+                  top: top, bottom: bot};
+    if (!rect.left && !rect.right) result.bogus = true;
+    if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot; }
+
+    return result;
+  }
+
+  // Work around problem with bounding client rects on ranges being
+  // returned incorrectly when zoomed on IE10 and below.
+  function maybeUpdateRectForZooming(measure, rect) {
+    if (!window.screen || screen.logicalXDPI == null ||
+        screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
+      return rect;
+    var scaleX = screen.logicalXDPI / screen.deviceXDPI;
+    var scaleY = screen.logicalYDPI / screen.deviceYDPI;
+    return {left: rect.left * scaleX, right: rect.right * scaleX,
+            top: rect.top * scaleY, bottom: rect.bottom * scaleY};
+  }
+
+  function clearLineMeasurementCacheFor(lineView) {
+    if (lineView.measure) {
+      lineView.measure.cache = {};
+      lineView.measure.heights = null;
+      if (lineView.rest) for (var i = 0; i < lineView.rest.length; i++)
+        lineView.measure.caches[i] = {};
+    }
+  }
+
+  function clearLineMeasurementCache(cm) {
+    cm.display.externalMeasure = null;
+    removeChildren(cm.display.lineMeasure);
+    for (var i = 0; i < cm.display.view.length; i++)
+      clearLineMeasurementCacheFor(cm.display.view[i]);
+  }
+
+  function clearCaches(cm) {
+    clearLineMeasurementCache(cm);
+    cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null;
+    if (!cm.options.lineWrapping) cm.display.maxLineChanged = true;
+    cm.display.lineNumChars = null;
+  }
+
+  function pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft; }
+  function pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop; }
+
+  // Converts a {top, bottom, left, right} box from line-local
+  // coordinates into another coordinate system. Context may be one of
+  // "line", "div" (display.lineDiv), "local"/null (editor), "window",
+  // or "page".
+  function intoCoordSystem(cm, lineObj, rect, context) {
+    if (lineObj.widgets) for (var i = 0; i < lineObj.widgets.length; ++i) if (lineObj.widgets[i].above) {
+      var size = widgetHeight(lineObj.widgets[i]);
+      rect.top += size; rect.bottom += size;
+    }
+    if (context == "line") return rect;
+    if (!context) context = "local";
+    var yOff = heightAtLine(lineObj);
+    if (context == "local") yOff += paddingTop(cm.display);
+    else yOff -= cm.display.viewOffset;
+    if (context == "page" || context == "window") {
+      var lOff = cm.display.lineSpace.getBoundingClientRect();
+      yOff += lOff.top + (context == "window" ? 0 : pageScrollY());
+      var xOff = lOff.left + (context == "window" ? 0 : pageScrollX());
+      rect.left += xOff; rect.right += xOff;
+    }
+    rect.top += yOff; rect.bottom += yOff;
+    return rect;
+  }
+
+  // Coverts a box from "div" coords to another coordinate system.
+  // Context may be "window", "page", "div", or "local"/null.
+  function fromCoordSystem(cm, coords, context) {
+    if (context == "div") return coords;
+    var left = coords.left, top = coords.top;
+    // First move into "page" coordinate system
+    if (context == "page") {
+      left -= pageScrollX();
+      top -= pageScrollY();
+    } else if (context == "local" || !context) {
+      var localBox = cm.display.sizer.getBoundingClientRect();
+      left += localBox.left;
+      top += localBox.top;
+    }
+
+    var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();
+    return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top};
+  }
+
+  function charCoords(cm, pos, context, lineObj, bias) {
+    if (!lineObj) lineObj = getLine(cm.doc, pos.line);
+    return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context);
+  }
+
+  // Returns a box for a given cursor position, which may have an
+  // 'other' property containing the position of the secondary cursor
+  // on a bidi boundary.
+  function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
+    lineObj = lineObj || getLine(cm.doc, pos.line);
+    if (!preparedMeasure) preparedMeasure = prepareMeasureForLine(cm, lineObj);
+    function get(ch, right) {
+      var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight);
+      if (right) m.left = m.right; else m.right = m.left;
+      return intoCoordSystem(cm, lineObj, m, context);
+    }
+    function getBidi(ch, partPos) {
+      var part = order[partPos], right = part.level % 2;
+      if (ch == bidiLeft(part) && partPos && part.level < order[partPos - 1].level) {
+        part = order[--partPos];
+        ch = bidiRight(part) - (part.level % 2 ? 0 : 1);
+        right = true;
+      } else if (ch == bidiRight(part) && partPos < order.length - 1 && part.level < order[partPos + 1].level) {
+        part = order[++partPos];
+        ch = bidiLeft(part) - part.level % 2;
+        right = false;
+      }
+      if (right && ch == part.to && ch > part.from) return get(ch - 1);
+      return get(ch, right);
+    }
+    var order = getOrder(lineObj), ch = pos.ch;
+    if (!order) return get(ch);
+    var partPos = getBidiPartAt(order, ch);
+    var val = getBidi(ch, partPos);
+    if (bidiOther != null) val.other = getBidi(ch, bidiOther);
+    return val;
+  }
+
+  // Used to cheaply estimate the coordinates for a position. Used for
+  // intermediate scroll updates.
+  function estimateCoords(cm, pos) {
+    var left = 0, pos = clipPos(cm.doc, pos);
+    if (!cm.options.lineWrapping) left = charWidth(cm.display) * pos.ch;
+    var lineObj = getLine(cm.doc, pos.line);
+    var top = heightAtLine(lineObj) + paddingTop(cm.display);
+    return {left: left, right: left, top: top, bottom: top + lineObj.height};
+  }
+
+  // Positions returned by coordsChar contain some extra information.
+  // xRel is the relative x position of the input coordinates compared
+  // to the found position (so xRel > 0 means the coordinates are to
+  // the right of the character position, for example). When outside
+  // is true, that means the coordinates lie outside the line's
+  // vertical range.
+  function PosWithInfo(line, ch, outside, xRel) {
+    var pos = Pos(line, ch);
+    pos.xRel = xRel;
+    if (outside) pos.outside = true;
+    return pos;
+  }
+
+  // Compute the character position closest to the given coordinates.
+  // Input must be lineSpace-local ("div" coordinate system).
+  function coordsChar(cm, x, y) {
+    var doc = cm.doc;
+    y += cm.display.viewOffset;
+    if (y < 0) return PosWithInfo(doc.first, 0, true, -1);
+    var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1;
+    if (lineN > last)
+      return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, true, 1);
+    if (x < 0) x = 0;
+
+    var lineObj = getLine(doc, lineN);
+    for (;;) {
+      var found = coordsCharInner(cm, lineObj, lineN, x, y);
+      var merged = collapsedSpanAtEnd(lineObj);
+      var mergedPos = merged && merged.find(0, true);
+      if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0))
+        lineN = lineNo(lineObj = mergedPos.to.line);
+      else
+        return found;
+    }
+  }
+
+  function coordsCharInner(cm, lineObj, lineNo, x, y) {
+    var innerOff = y - heightAtLine(lineObj);
+    var wrongLine = false, adjust = 2 * cm.display.wrapper.clientWidth;
+    var preparedMeasure = prepareMeasureForLine(cm, lineObj);
+
+    function getX(ch) {
+      var sp = cursorCoords(cm, Pos(lineNo, ch), "line", lineObj, preparedMeasure);
+      wrongLine = true;
+      if (innerOff > sp.bottom) return sp.left - adjust;
+      else if (innerOff < sp.top) return sp.left + adjust;
+      else wrongLine = false;
+      return sp.left;
+    }
+
+    var bidi = getOrder(lineObj), dist = lineObj.text.length;
+    var from = lineLeft(lineObj), to = lineRight(lineObj);
+    var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine;
+
+    if (x > toX) return PosWithInfo(lineNo, to, toOutside, 1);
+    // Do a binary search between these bounds.
+    for (;;) {
+      if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {
+        var ch = x < fromX || x - fromX <= toX - x ? from : to;
+        var xDiff = x - (ch == from ? fromX : toX);
+        while (isExtendingChar(lineObj.text.charAt(ch))) ++ch;
+        var pos = PosWithInfo(lineNo, ch, ch == from ? fromOutside : toOutside,
+                              xDiff < -1 ? -1 : xDiff > 1 ? 1 : 0);
+        return pos;
+      }
+      var step = Math.ceil(dist / 2), middle = from + step;
+      if (bidi) {
+        middle = from;
+        for (var i = 0; i < step; ++i) middle = moveVisually(lineObj, middle, 1);
+      }
+      var middleX = getX(middle);
+      if (middleX > x) {to = middle; toX = middleX; if (toOutside = wrongLine) toX += 1000; dist = step;}
+      else {from = middle; fromX = middleX; fromOutside = wrongLine; dist -= step;}
+    }
+  }
+
+  var measureText;
+  // Compute the default text height.
+  function textHeight(display) {
+    if (display.cachedTextHeight != null) return display.cachedTextHeight;
+    if (measureText == null) {
+      measureText = elt("pre");
+      // Measure a bunch of lines, for browsers that compute
+      // fractional heights.
+      for (var i = 0; i < 49; ++i) {
+        measureText.appendChild(document.createTextNode("x"));
+        measureText.appendChild(elt("br"));
+      }
+      measureText.appendChild(document.createTextNode("x"));
+    }
+    removeChildrenAndAdd(display.measure, measureText);
+    var height = measureText.offsetHeight / 50;
+    if (height > 3) display.cachedTextHeight = height;
+    removeChildren(display.measure);
+    return height || 1;
+  }
+
+  // Compute the default character width.
+  function charWidth(display) {
+    if (display.cachedCharWidth != null) return display.cachedCharWidth;
+    var anchor = elt("span", "xxxxxxxxxx");
+    var pre = elt("pre", [anchor]);
+    removeChildrenAndAdd(display.measure, pre);
+    var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10;
+    if (width > 2) display.cachedCharWidth = width;
+    return width || 10;
+  }
+
+  // OPERATIONS
+
+  // Operations are used to wrap a series of changes to the editor
+  // state in such a way that each change won't have to update the
+  // cursor and display (which would be awkward, slow, and
+  // error-prone). Instead, display updates are batched and then all
+  // combined and executed at once.
+
+  var operationGroup = null;
+
+  var nextOpId = 0;
+  // Start a new operation.
+  function startOperation(cm) {
+    cm.curOp = {
+      cm: cm,
+      viewChanged: false,      // Flag that indicates that lines might need to be redrawn
+      startHeight: cm.doc.height, // Used to detect need to update scrollbar
+      forceUpdate: false,      // Used to force a redraw
+      updateInput: null,       // Whether to reset the input textarea
+      typing: false,           // Whether this reset should be careful to leave existing text (for compositing)
+      changeObjs: null,        // Accumulated changes, for firing change events
+      cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
+      cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
+      selectionChanged: false, // Whether the selection needs to be redrawn
+      updateMaxLine: false,    // Set when the widest line needs to be determined anew
+      scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
+      scrollToPos: null,       // Used to scroll to a specific position
+      id: ++nextOpId           // Unique ID
+    };
+    if (operationGroup) {
+      operationGroup.ops.push(cm.curOp);
+    } else {
+      cm.curOp.ownsGroup = operationGroup = {
+        ops: [cm.curOp],
+        delayedCallbacks: []
+      };
+    }
+  }
+
+  function fireCallbacksForOps(group) {
+    // Calls delayed callbacks and cursorActivity handlers until no
+    // new ones appear
+    var callbacks = group.delayedCallbacks, i = 0;
+    do {
+      for (; i < callbacks.length; i++)
+        callbacks[i]();
+      for (var j = 0; j < group.ops.length; j++) {
+        var op = group.ops[j];
+        if (op.cursorActivityHandlers)
+          while (op.cursorActivityCalled < op.cursorActivityHandlers.length)
+            op.cursorActivityHandlers[op.cursorActivityCalled++](op.cm);
+      }
+    } while (i < callbacks.length);
+  }
+
+  // Finish an operation, updating the display and signalling delayed events
+  function endOperation(cm) {
+    var op = cm.curOp, group = op.ownsGroup;
+    if (!group) return;
+
+    try { fireCallbacksForOps(group); }
+    finally {
+      operationGroup = null;
+      for (var i = 0; i < group.ops.length; i++)
+        group.ops[i].cm.curOp = null;
+      endOperations(group);
+    }
+  }
+
+  // The DOM updates done when an operation finishes are batched so
+  // that the minimum number of relayouts are required.
+  function endOperations(group) {
+    var ops = group.ops;
+    for (var i = 0; i < ops.length; i++) // Read DOM
+      endOperation_R1(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Write DOM (maybe)
+      endOperation_W1(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Read DOM
+      endOperation_R2(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Write DOM (maybe)
+      endOperation_W2(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Read DOM
+      endOperation_finish(ops[i]);
+  }
+
+  function endOperation_R1(op) {
+    var cm = op.cm, display = cm.display;
+    maybeClipScrollbars(cm);
+    if (op.updateMaxLine) findMaxLine(cm);
+
+    op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
+      op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
+                         op.scrollToPos.to.line >= display.viewTo) ||
+      display.maxLineChanged && cm.options.lineWrapping;
+    op.update = op.mustUpdate &&
+      new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate);
+  }
+
+  function endOperation_W1(op) {
+    op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update);
+  }
+
+  function endOperation_R2(op) {
+    var cm = op.cm, display = cm.display;
+    if (op.updatedDisplay) updateHeightsInViewport(cm);
+
+    op.barMeasure = measureForScrollbars(cm);
+
+    // If the max line changed since it was last measured, measure it,
+    // and ensure the document's width matches it.
+    // updateDisplay_W2 will use these properties to do the actual resizing
+    if (display.maxLineChanged && !cm.options.lineWrapping) {
+      op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3;
+      cm.display.sizerWidth = op.adjustWidthTo;
+      op.barMeasure.scrollWidth =
+        Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth);
+      op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm));
+    }
+
+    if (op.updatedDisplay || op.selectionChanged)
+      op.preparedSelection = display.input.prepareSelection();
+  }
+
+  function endOperation_W2(op) {
+    var cm = op.cm;
+
+    if (op.adjustWidthTo != null) {
+      cm.display.sizer.style.minWidth = op.adjustWidthTo + "px";
+      if (op.maxScrollLeft < cm.doc.scrollLeft)
+        setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true);
+      cm.display.maxLineChanged = false;
+    }
+
+    if (op.preparedSelection)
+      cm.display.input.showSelection(op.preparedSelection);
+    if (op.updatedDisplay)
+      setDocumentHeight(cm, op.barMeasure);
+    if (op.updatedDisplay || op.startHeight != cm.doc.height)
+      updateScrollbars(cm, op.barMeasure);
+
+    if (op.selectionChanged) restartBlink(cm);
+
+    if (cm.state.focused && op.updateInput)
+      cm.display.input.reset(op.typing);
+  }
+
+  function endOperation_finish(op) {
+    var cm = op.cm, display = cm.display, doc = cm.doc;
+
+    if (op.updatedDisplay) postUpdateDisplay(cm, op.update);
+
+    // Abort mouse wheel delta measurement, when scrolling explicitly
+    if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
+      display.wheelStartX = display.wheelStartY = null;
+
+    // Propagate the scroll position to the actual DOM scroller
+    if (op.scrollTop != null && (display.scroller.scrollTop != op.scrollTop || op.forceScroll)) {
+      doc.scrollTop = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, op.scrollTop));
+      display.scrollbars.setScrollTop(doc.scrollTop);
+      display.scroller.scrollTop = doc.scrollTop;
+    }
+    if (op.scrollLeft != null && (display.scroller.scrollLeft != op.scrollLeft || op.forceScroll)) {
+      doc.scrollLeft = Math.max(0, Math.min(display.scroller.scrollWidth - displayWidth(cm), op.scrollLeft));
+      display.scrollbars.setScrollLeft(doc.scrollLeft);
+      display.scroller.scrollLeft = doc.scrollLeft;
+      alignHorizontally(cm);
+    }
+    // If we need to scroll a specific position into view, do so.
+    if (op.scrollToPos) {
+      var coords = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
+                                     clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin);
+      if (op.scrollToPos.isCursor && cm.state.focused) maybeScrollWindow(cm, coords);
+    }
+
+    // Fire events for markers that are hidden/unidden by editing or
+    // undoing
+    var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers;
+    if (hidden) for (var i = 0; i < hidden.length; ++i)
+      if (!hidden[i].lines.length) signal(hidden[i], "hide");
+    if (unhidden) for (var i = 0; i < unhidden.length; ++i)
+      if (unhidden[i].lines.length) signal(unhidden[i], "unhide");
+
+    if (display.wrapper.offsetHeight)
+      doc.scrollTop = cm.display.scroller.scrollTop;
+
+    // Fire change events, and delayed event handlers
+    if (op.changeObjs)
+      signal(cm, "changes", cm, op.changeObjs);
+    if (op.update)
+      op.update.finish();
+  }
+
+  // Run the given function in an operation
+  function runInOp(cm, f) {
+    if (cm.curOp) return f();
+    startOperation(cm);
+    try { return f(); }
+    finally { endOperation(cm); }
+  }
+  // Wraps a function in an operation. Returns the wrapped function.
+  function operation(cm, f) {
+    return function() {
+      if (cm.curOp) return f.apply(cm, arguments);
+      startOperation(cm);
+      try { return f.apply(cm, arguments); }
+      finally { endOperation(cm); }
+    };
+  }
+  // Used to add methods to editor and doc instances, wrapping them in
+  // operations.
+  function methodOp(f) {
+    return function() {
+      if (this.curOp) return f.apply(this, arguments);
+      startOperation(this);
+      try { return f.apply(this, arguments); }
+      finally { endOperation(this); }
+    };
+  }
+  function docMethodOp(f) {
+    return function() {
+      var cm = this.cm;
+      if (!cm || cm.curOp) return f.apply(this, arguments);
+      startOperation(cm);
+      try { return f.apply(this, arguments); }
+      finally { endOperation(cm); }
+    };
+  }
+
+  // VIEW TRACKING
+
+  // These objects are used to represent the visible (currently drawn)
+  // part of the document. A LineView may correspond to multiple
+  // logical lines, if those are connected by collapsed ranges.
+  function LineView(doc, line, lineN) {
+    // The starting line
+    this.line = line;
+    // Continuing lines, if any
+    this.rest = visualLineContinued(line);
+    // Number of logical lines in this visual line
+    this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;
+    this.node = this.text = null;
+    this.hidden = lineIsHidden(doc, line);
+  }
+
+  // Create a range of LineView objects for the given lines.
+  function buildViewArray(cm, from, to) {
+    var array = [], nextPos;
+    for (var pos = from; pos < to; pos = nextPos) {
+      var view = new LineView(cm.doc, getLine(cm.doc, pos), pos);
+      nextPos = pos + view.size;
+      array.push(view);
+    }
+    return array;
+  }
+
+  // Updates the display.view data structure for a given change to the
+  // document. From and to are in pre-change coordinates. Lendiff is
+  // the amount of lines added or subtracted by the change. This is
+  // used for changes that span multiple lines, or change the way
+  // lines are divided into visual lines. regLineChange (below)
+  // registers single-line changes.
+  function regChange(cm, from, to, lendiff) {
+    if (from == null) from = cm.doc.first;
+    if (to == null) to = cm.doc.first + cm.doc.size;
+    if (!lendiff) lendiff = 0;
+
+    var display = cm.display;
+    if (lendiff && to < display.viewTo &&
+        (display.updateLineNumbers == null || display.updateLineNumbers > from))
+      display.updateLineNumbers = from;
+
+    cm.curOp.viewChanged = true;
+
+    if (from >= display.viewTo) { // Change after
+      if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
+        resetView(cm);
+    } else if (to <= display.viewFrom) { // Change before
+      if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
+        resetView(cm);
+      } else {
+        display.viewFrom += lendiff;
+        display.viewTo += lendiff;
+      }
+    } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
+      resetView(cm);
+    } else if (from <= display.viewFrom) { // Top overlap
+      var cut = viewCuttingPoint(cm, to, to + lendiff, 1);
+      if (cut) {
+        display.view = display.view.slice(cut.index);
+        display.viewFrom = cut.lineN;
+        display.viewTo += lendiff;
+      } else {
+        resetView(cm);
+      }
+    } else if (to >= display.viewTo) { // Bottom overlap
+      var cut = viewCuttingPoint(cm, from, from, -1);
+      if (cut) {
+        display.view = display.view.slice(0, cut.index);
+        display.viewTo = cut.lineN;
+      } else {
+        resetView(cm);
+      }
+    } else { // Gap in the middle
+      var cutTop = viewCuttingPoint(cm, from, from, -1);
+      var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1);
+      if (cutTop && cutBot) {
+        display.view = display.view.slice(0, cutTop.index)
+          .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
+          .concat(display.view.slice(cutBot.index));
+        display.viewTo += lendiff;
+      } else {
+        resetView(cm);
+      }
+    }
+
+    var ext = display.externalMeasured;
+    if (ext) {
+      if (to < ext.lineN)
+        ext.lineN += lendiff;
+      else if (from < ext.lineN + ext.size)
+        display.externalMeasured = null;
+    }
+  }
+
+  // Register a change to a single line. Type must be one of "text",
+  // "gutter", "class", "widget"
+  function regLineChange(cm, line, type) {
+    cm.curOp.viewChanged = true;
+    var display = cm.display, ext = cm.display.externalMeasured;
+    if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
+      display.externalMeasured = null;
+
+    if (line < display.viewFrom || line >= display.viewTo) return;
+    var lineView = display.view[findViewIndex(cm, line)];
+    if (lineView.node == null) return;
+    var arr = lineView.changes || (lineView.changes = []);
+    if (indexOf(arr, type) == -1) arr.push(type);
+  }
+
+  // Clear the view.
+  function resetView(cm) {
+    cm.display.viewFrom = cm.display.viewTo = cm.doc.first;
+    cm.display.view = [];
+    cm.display.viewOffset = 0;
+  }
+
+  // Find the view element corresponding to a given line. Return null
+  // when the line isn't visible.
+  function findViewIndex(cm, n) {
+    if (n >= cm.display.viewTo) return null;
+    n -= cm.display.viewFrom;
+    if (n < 0) return null;
+    var view = cm.display.view;
+    for (var i = 0; i < view.length; i++) {
+      n -= view[i].size;
+      if (n < 0) return i;
+    }
+  }
+
+  function viewCuttingPoint(cm, oldN, newN, dir) {
+    var index = findViewIndex(cm, oldN), diff, view = cm.display.view;
+    if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)
+      return {index: index, lineN: newN};
+    for (var i = 0, n = cm.display.viewFrom; i < index; i++)
+      n += view[i].size;
+    if (n != oldN) {
+      if (dir > 0) {
+        if (index == view.length - 1) return null;
+        diff = (n + view[index].size) - oldN;
+        index++;
+      } else {
+        diff = n - oldN;
+      }
+      oldN += diff; newN += diff;
+    }
+    while (visualLineNo(cm.doc, newN) != newN) {
+      if (index == (dir < 0 ? 0 : view.length - 1)) return null;
+      newN += dir * view[index - (dir < 0 ? 1 : 0)].size;
+      index += dir;
+    }
+    return {index: index, lineN: newN};
+  }
+
+  // Force the view to cover a given range, adding empty view element
+  // or clipping off existing ones as needed.
+  function adjustView(cm, from, to) {
+    var display = cm.display, view = display.view;
+    if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
+      display.view = buildViewArray(cm, from, to);
+      display.viewFrom = from;
+    } else {
+      if (display.viewFrom > from)
+        display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view);
+      else if (display.viewFrom < from)
+        display.view = display.view.slice(findViewIndex(cm, from));
+      display.viewFrom = from;
+      if (display.viewTo < to)
+        display.view = display.view.concat(buildViewArray(cm, display.viewTo, to));
+      else if (display.viewTo > to)
+        display.view = display.view.slice(0, findViewIndex(cm, to));
+    }
+    display.viewTo = to;
+  }
+
+  // Count the number of lines in the view whose DOM representation is
+  // out of date (or nonexistent).
+  function countDirtyView(cm) {
+    var view = cm.display.view, dirty = 0;
+    for (var i = 0; i < view.length; i++) {
+      var lineView = view[i];
+      if (!lineView.hidden && (!lineView.node || lineView.changes)) ++dirty;
+    }
+    return dirty;
+  }
+
+  // EVENT HANDLERS
+
+  // Attach the necessary event handlers when initializing the editor
+  function registerEventHandlers(cm) {
+    var d = cm.display;
+    on(d.scroller, "mousedown", operation(cm, onMouseDown));
+    // Older IE's will not fire a second mousedown for a double click
+    if (ie && ie_version < 11)
+      on(d.scroller, "dblclick", operation(cm, function(e) {
+        if (signalDOMEvent(cm, e)) return;
+        var pos = posFromMouse(cm, e);
+        if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return;
+        e_preventDefault(e);
+        var word = cm.findWordAt(pos);
+        extendSelection(cm.doc, word.anchor, word.head);
+      }));
+    else
+      on(d.scroller, "dblclick", function(e) { signalDOMEvent(cm, e) || e_preventDefault(e); });
+    // Some browsers fire contextmenu *after* opening the menu, at
+    // which point we can't mess with it anymore. Context menu is
+    // handled in onMouseDown for these browsers.
+    if (!captureRightClick) on(d.scroller, "contextmenu", function(e) {onContextMenu(cm, e);});
+
+    // Used to suppress mouse event handling when a touch happens
+    var touchFinished, prevTouch = {end: 0};
+    function finishTouch() {
+      if (d.activeTouch) {
+        touchFinished = setTimeout(function() {d.activeTouch = null;}, 1000);
+        prevTouch = d.activeTouch;
+        prevTouch.end = +new Date;
+      }
+    };
+    function isMouseLikeTouchEvent(e) {
+      if (e.touches.length != 1) return false;
+      var touch = e.touches[0];
+      return touch.radiusX <= 1 && touch.radiusY <= 1;
+    }
+    function farAway(touch, other) {
+      if (other.left == null) return true;
+      var dx = other.left - touch.left, dy = other.top - touch.top;
+      return dx * dx + dy * dy > 20 * 20;
+    }
+    on(d.scroller, "touchstart", function(e) {
+      if (!isMouseLikeTouchEvent(e)) {
+        clearTimeout(touchFinished);
+        var now = +new Date;
+        d.activeTouch = {start: now, moved: false,
+                         prev: now - prevTouch.end <= 300 ? prevTouch : null};
+        if (e.touches.length == 1) {
+          d.activeTouch.left = e.touches[0].pageX;
+          d.activeTouch.top = e.touches[0].pageY;
+        }
+      }
+    });
+    on(d.scroller, "touchmove", function() {
+      if (d.activeTouch) d.activeTouch.moved = true;
+    });
+    on(d.scroller, "touchend", function(e) {
+      var touch = d.activeTouch;
+      if (touch && !eventInWidget(d, e) && touch.left != null &&
+          !touch.moved && new Date - touch.start < 300) {
+        var pos = cm.coordsChar(d.activeTouch, "page"), range;
+        if (!touch.prev || farAway(touch, touch.prev)) // Single tap
+          range = new Range(pos, pos);
+        else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
+          range = cm.findWordAt(pos);
+        else // Triple tap
+          range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)));
+        cm.setSelection(range.anchor, range.head);
+        cm.focus();
+        e_preventDefault(e);
+      }
+      finishTouch();
+    });
+    on(d.scroller, "touchcancel", finishTouch);
+
+    // Sync scrolling between fake scrollbars and real scrollable
+    // area, ensure viewport is updated when scrolling.
+    on(d.scroller, "scroll", function() {
+      if (d.scroller.clientHeight) {
+        setScrollTop(cm, d.scroller.scrollTop);
+        setScrollLeft(cm, d.scroller.scrollLeft, true);
+        signal(cm, "scroll", cm);
+      }
+    });
+
+    // Listen to wheel events in order to try and update the viewport on time.
+    on(d.scroller, "mousewheel", function(e){onScrollWheel(cm, e);});
+    on(d.scroller, "DOMMouseScroll", function(e){onScrollWheel(cm, e);});
+
+    // Prevent wrapper from ever scrolling
+    on(d.wrapper, "scroll", function() { d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });
+
+    function drag_(e) {
+      if (!signalDOMEvent(cm, e)) e_stop(e);
+    }
+    if (cm.options.dragDrop) {
+      on(d.scroller, "dragstart", function(e){onDragStart(cm, e);});
+      on(d.scroller, "dragenter", drag_);
+      on(d.scroller, "dragover", drag_);
+      on(d.scroller, "drop", operation(cm, onDrop));
+    }
+
+    var inp = d.input.getField();
+    on(inp, "keyup", function(e) { onKeyUp.call(cm, e); });
+    on(inp, "keydown", operation(cm, onKeyDown));
+    on(inp, "keypress", operation(cm, onKeyPress));
+    on(inp, "focus", bind(onFocus, cm));
+    on(inp, "blur", bind(onBlur, cm));
+  }
+
+  // Called when the window resizes
+  function onResize(cm) {
+    var d = cm.display;
+    if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)
+      return;
+    // Might be a text scaling operation, clear size caches.
+    d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
+    d.scrollbarsClipped = false;
+    cm.setSize();
+  }
+
+  // MOUSE EVENTS
+
+  // Return true when the given mouse event happened in a widget
+  function eventInWidget(display, e) {
+    for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
+      if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
+          (n.parentNode == display.sizer && n != display.mover))
+        return true;
+    }
+  }
+
+  // Given a mouse event, find the corresponding position. If liberal
+  // is false, it checks whether a gutter or scrollbar was clicked,
+  // and returns null if it was. forRect is used by rectangular
+  // selections, and tries to estimate a character position even for
+  // coordinates beyond the right of the text.
+  function posFromMouse(cm, e, liberal, forRect) {
+    var display = cm.display;
+    if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") return null;
+
+    var x, y, space = display.lineSpace.getBoundingClientRect();
+    // Fails unpredictably on IE[67] when mouse is dragged around quickly.
+    try { x = e.clientX - space.left; y = e.clientY - space.top; }
+    catch (e) { return null; }
+    var coords = coordsChar(cm, x, y), line;
+    if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {
+      var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length;
+      coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff));
+    }
+    return coords;
+  }
+
+  // A mouse down can be a single click, double click, triple click,
+  // start of selection drag, start of text drag, new cursor
+  // (ctrl-click), rectangle drag (alt-drag), or xwin
+  // middle-click-paste. Or it might be a click on something we should
+  // not interfere with, such as a scrollbar or widget.
+  function onMouseDown(e) {
+    var cm = this, display = cm.display;
+    if (display.activeTouch && display.input.supportsTouch() || signalDOMEvent(cm, e)) return;
+    display.shift = e.shiftKey;
+
+    if (eventInWidget(display, e)) {
+      if (!webkit) {
+        // Briefly turn off draggability, to allow widgets to do
+        // normal dragging things.
+        display.scroller.draggable = false;
+        setTimeout(function(){display.scroller.draggable = true;}, 100);
+      }
+      return;
+    }
+    if (clickInGutter(cm, e)) return;
+    var start = posFromMouse(cm, e);
+    window.focus();
+
+    switch (e_button(e)) {
+    case 1:
+      if (start)
+        leftButtonDown(cm, e, start);
+      else if (e_target(e) == display.scroller)
+        e_preventDefault(e);
+      break;
+    case 2:
+      if (webkit) cm.state.lastMiddleDown = +new Date;
+      if (start) extendSelection(cm.doc, start);
+      setTimeout(function() {display.input.focus();}, 20);
+      e_preventDefault(e);
+      break;
+    case 3:
+      if (captureRightClick) onContextMenu(cm, e);
+      break;
+    }
+  }
+
+  var lastClick, lastDoubleClick;
+  function leftButtonDown(cm, e, start) {
+    if (ie) setTimeout(bind(ensureFocus, cm), 0);
+    else ensureFocus(cm);
+
+    var now = +new Date, type;
+    if (lastDoubleClick && lastDoubleClick.time > now - 400 && cmp(lastDoubleClick.pos, start) == 0) {
+      type = "triple";
+    } else if (lastClick && lastClick.time > now - 400 && cmp(lastClick.pos, start) == 0) {
+      type = "double";
+      lastDoubleClick = {time: now, pos: start};
+    } else {
+      type = "single";
+      lastClick = {time: now, pos: start};
+    }
+
+    var sel = cm.doc.sel, modifier = mac ? e.metaKey : e.ctrlKey, contained;
+    if (cm.options.dragDrop && dragAndDrop && !isReadOnly(cm) &&
+        type == "single" && (contained = sel.contains(start)) > -1 &&
+        !sel.ranges[contained].empty())
+      leftButtonStartDrag(cm, e, start, modifier);
+    else
+      leftButtonSelect(cm, e, start, type, modifier);
+  }
+
+  // Start a text drag. When it ends, see if any dragging actually
+  // happen, and treat as a click if it didn't.
+  function leftButtonStartDrag(cm, e, start, modifier) {
+    var display = cm.display;
+    var dragEnd = operation(cm, function(e2) {
+      if (webkit) display.scroller.draggable = false;
+      cm.state.draggingText = false;
+      off(document, "mouseup", dragEnd);
+      off(display.scroller, "drop", dragEnd);
+      if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {
+        e_preventDefault(e2);
+        if (!modifier)
+          extendSelection(cm.doc, start);
+        display.input.focus();
+        // Work around unexplainable focus problem in IE9 (#2127)
+        if (ie && ie_version == 9)
+          setTimeout(function() {document.body.focus(); display.input.focus();}, 20);
+      }
+    });
+    // Let the drag handler handle this.
+    if (webkit) display.scroller.draggable = true;
+    cm.state.draggingText = dragEnd;
+    // IE's approach to draggable
+    if (display.scroller.dragDrop) display.scroller.dragDrop();
+    on(document, "mouseup", dragEnd);
+    on(display.scroller, "drop", dragEnd);
+  }
+
+  // Normal selection, as opposed to text dragging.
+  function leftButtonSelect(cm, e, start, type, addNew) {
+    var display = cm.display, doc = cm.doc;
+    e_preventDefault(e);
+
+    var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges;
+    if (addNew && !e.shiftKey) {
+      ourIndex = doc.sel.contains(start);
+      if (ourIndex > -1)
+        ourRange = ranges[ourIndex];
+      else
+        ourRange = new Range(start, start);
+    } else {
+      ourRange = doc.sel.primary();
+    }
+
+    if (e.altKey) {
+      type = "rect";
+      if (!addNew) ourRange = new Range(start, start);
+      start = posFromMouse(cm, e, true, true);
+      ourIndex = -1;
+    } else if (type == "double") {
+      var word = cm.findWordAt(start);
+      if (cm.display.shift || doc.extend)
+        ourRange = extendRange(doc, ourRange, word.anchor, word.head);
+      else
+        ourRange = word;
+    } else if (type == "triple") {
+      var line = new Range(Pos(start.line, 0), clipPos(doc, Pos(start.line + 1, 0)));
+      if (cm.display.shift || doc.extend)
+        ourRange = extendRange(doc, ourRange, line.anchor, line.head);
+      else
+        ourRange = line;
+    } else {
+      ourRange = extendRange(doc, ourRange, start);
+    }
+
+    if (!addNew) {
+      ourIndex = 0;
+      setSelection(doc, new Selection([ourRange], 0), sel_mouse);
+      startSel = doc.sel;
+    } else if (ourIndex == -1) {
+      ourIndex = ranges.length;
+      setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),
+                   {scroll: false, origin: "*mouse"});
+    } else if (ranges.length > 1 && ranges[ourIndex].empty() && type == "single") {
+      setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0));
+      startSel = doc.sel;
+    } else {
+      replaceOneSelection(doc, ourIndex, ourRange, sel_mouse);
+    }
+
+    var lastPos = start;
+    function extendTo(pos) {
+      if (cmp(lastPos, pos) == 0) return;
+      lastPos = pos;
+
+      if (type == "rect") {
+        var ranges = [], tabSize = cm.options.tabSize;
+        var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize);
+        var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize);
+        var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol);
+        for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
+             line <= end; line++) {
+          var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize);
+          if (left == right)
+            ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos)));
+          else if (text.length > leftPos)
+            ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize))));
+        }
+        if (!ranges.length) ranges.push(new Range(start, start));
+        setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
+                     {origin: "*mouse", scroll: false});
+        cm.scrollIntoView(pos);
+      } else {
+        var oldRange = ourRange;
+        var anchor = oldRange.anchor, head = pos;
+        if (type != "single") {
+          if (type == "double")
+            var range = cm.findWordAt(pos);
+          else
+            var range = new Range(Pos(pos.line, 0), clipPos(doc, Pos(pos.line + 1, 0)));
+          if (cmp(range.anchor, anchor) > 0) {
+            head = range.head;
+            anchor = minPos(oldRange.from(), range.anchor);
+          } else {
+            head = range.anchor;
+            anchor = maxPos(oldRange.to(), range.head);
+          }
+        }
+        var ranges = startSel.ranges.slice(0);
+        ranges[ourIndex] = new Range(clipPos(doc, anchor), head);
+        setSelection(doc, normalizeSelection(ranges, ourIndex), sel_mouse);
+      }
+    }
+
+    var editorSize = display.wrapper.getBoundingClientRect();
+    // Used to ensure timeout re-tries don't fire when another extend
+    // happened in the meantime (clearTimeout isn't reliable -- at
+    // least on Chrome, the timeouts still happen even when cleared,
+    // if the clear happens after their scheduled firing time).
+    var counter = 0;
+
+    function extend(e) {
+      var curCount = ++counter;
+      var cur = posFromMouse(cm, e, true, type == "rect");
+      if (!cur) return;
+      if (cmp(cur, lastPos) != 0) {
+        ensureFocus(cm);
+        extendTo(cur);
+        var visible = visibleLines(display, doc);
+        if (cur.line >= visible.to || cur.line < visible.from)
+          setTimeout(operation(cm, function(){if (counter == curCount) extend(e);}), 150);
+      } else {
+        var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0;
+        if (outside) setTimeout(operation(cm, function() {
+          if (counter != curCount) return;
+          display.scroller.scrollTop += outside;
+          extend(e);
+        }), 50);
+      }
+    }
+
+    function done(e) {
+      counter = Infinity;
+      e_preventDefault(e);
+      display.input.focus();
+      off(document, "mousemove", move);
+      off(document, "mouseup", up);
+      doc.history.lastSelOrigin = null;
+    }
+
+    var move = operation(cm, function(e) {
+      if (!e_button(e)) done(e);
+      else extend(e);
+    });
+    var up = operation(cm, done);
+    on(document, "mousemove", move);
+    on(document, "mouseup", up);
+  }
+
+  // Determines whether an event happened in the gutter, and fires the
+  // handlers for the corresponding event.
+  function gutterEvent(cm, e, type, prevent, signalfn) {
+    try { var mX = e.clientX, mY = e.clientY; }
+    catch(e) { return false; }
+    if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) return false;
+    if (prevent) e_preventDefault(e);
+
+    var display = cm.display;
+    var lineBox = display.lineDiv.getBoundingClientRect();
+
+    if (mY > lineBox.bottom || !hasHandler(cm, type)) return e_defaultPrevented(e);
+    mY -= lineBox.top - display.viewOffset;
+
+    for (var i = 0; i < cm.options.gutters.length; ++i) {
+      var g = display.gutters.childNodes[i];
+      if (g && g.getBoundingClientRect().right >= mX) {
+        var line = lineAtHeight(cm.doc, mY);
+        var gutter = cm.options.gutters[i];
+        signalfn(cm, type, cm, line, gutter, e);
+        return e_defaultPrevented(e);
+      }
+    }
+  }
+
+  function clickInGutter(cm, e) {
+    return gutterEvent(cm, e, "gutterClick", true, signalLater);
+  }
+
+  // Kludge to work around strange IE behavior where it'll sometimes
+  // re-fire a series of drag-related events right after the drop (#1551)
+  var lastDrop = 0;
+
+  function onDrop(e) {
+    var cm = this;
+    if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
+      return;
+    e_preventDefault(e);
+    if (ie) lastDrop = +new Date;
+    var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files;
+    if (!pos || isReadOnly(cm)) return;
+    // Might be a file drop, in which case we simply extract the text
+    // and insert it.
+    if (files && files.length && window.FileReader && window.File) {
+      var n = files.length, text = Array(n), read = 0;
+      var loadFile = function(file, i) {
+        var reader = new FileReader;
+        reader.onload = operation(cm, function() {
+          text[i] = reader.result;
+          if (++read == n) {
+            pos = clipPos(cm.doc, pos);
+            var change = {from: pos, to: pos, text: splitLines(text.join("\n")), origin: "paste"};
+            makeChange(cm.doc, change);
+            setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)));
+          }
+        });
+        reader.readAsText(file);
+      };
+      for (var i = 0; i < n; ++i) loadFile(files[i], i);
+    } else { // Normal drop
+      // Don't do a replace if the drop happened inside of the selected text.
+      if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
+        cm.state.draggingText(e);
+        // Ensure the editor is re-focused
+        setTimeout(function() {cm.display.input.focus();}, 20);
+        return;
+      }
+      try {
+        var text = e.dataTransfer.getData("Text");
+        if (text) {
+          if (cm.state.draggingText && !(mac ? e.metaKey : e.ctrlKey))
+            var selected = cm.listSelections();
+          setSelectionNoUndo(cm.doc, simpleSelection(pos, pos));
+          if (selected) for (var i = 0; i < selected.length; ++i)
+            replaceRange(cm.doc, "", selected[i].anchor, selected[i].head, "drag");
+          cm.replaceSelection(text, "around", "paste");
+          cm.display.input.focus();
+        }
+      }
+      catch(e){}
+    }
+  }
+
+  function onDragStart(cm, e) {
+    if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return; }
+    if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) return;
+
+    e.dataTransfer.setData("Text", cm.getSelection());
+
+    // Use dummy image instead of default browsers image.
+    // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
+    if (e.dataTransfer.setDragImage && !safari) {
+      var img = elt("img", null, null, "position: fixed; left: 0; top: 0;");
+      img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
+      if (presto) {
+        img.width = img.height = 1;
+        cm.display.wrapper.appendChild(img);
+        // Force a relayout, or Opera won't use our image for some obscure reason
+        img._top = img.offsetTop;
+      }
+      e.dataTransfer.setDragImage(img, 0, 0);
+      if (presto) img.parentNode.removeChild(img);
+    }
+  }
+
+  // SCROLL EVENTS
+
+  // Sync the scrollable area and scrollbars, ensure the viewport
+  // covers the visible area.
+  function setScrollTop(cm, val) {
+    if (Math.abs(cm.doc.scrollTop - val) < 2) return;
+    cm.doc.scrollTop = val;
+    if (!gecko) updateDisplaySimple(cm, {top: val});
+    if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val;
+    cm.display.scrollbars.setScrollTop(val);
+    if (gecko) updateDisplaySimple(cm);
+    startWorker(cm, 100);
+  }
+  // Sync scroller and scrollbar, ensure the gutter elements are
+  // aligned.
+  function setScrollLeft(cm, val, isScroller) {
+    if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) return;
+    val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth);
+    cm.doc.scrollLeft = val;
+    alignHorizontally(cm);
+    if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val;
+    cm.display.scrollbars.setScrollLeft(val);
+  }
+
+  // Since the delta values reported on mouse wheel events are
+  // unstandardized between browsers and even browser versions, and
+  // generally horribly unpredictable, this code starts by measuring
+  // the scroll effect that the first few mouse wheel events have,
+  // and, from that, detects the way it can convert deltas to pixel
+  // offsets afterwards.
+  //
+  // The reason we want to know the amount a wheel event will scroll
+  // is that it gives us a chance to update the display before the
+  // actual scrolling happens, reducing flickering.
+
+  var wheelSamples = 0, wheelPixelsPerUnit = null;
+  // Fill in a browser-detected starting value on browsers where we
+  // know one. These don't have to be accurate -- the result of them
+  // being wrong would just be a slight flicker on the first wheel
+  // scroll (if it is large enough).
+  if (ie) wheelPixelsPerUnit = -.53;
+  else if (gecko) wheelPixelsPerUnit = 15;
+  else if (chrome) wheelPixelsPerUnit = -.7;
+  else if (safari) wheelPixelsPerUnit = -1/3;
+
+  var wheelEventDelta = function(e) {
+    var dx = e.wheelDeltaX, dy = e.wheelDeltaY;
+    if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail;
+    if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail;
+    else if (dy == null) dy = e.wheelDelta;
+    return {x: dx, y: dy};
+  };
+  CodeMirror.wheelEventPixels = function(e) {
+    var delta = wheelEventDelta(e);
+    delta.x *= wheelPixelsPerUnit;
+    delta.y *= wheelPixelsPerUnit;
+    return delta;
+  };
+
+  function onScrollWheel(cm, e) {
+    var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y;
+
+    var display = cm.display, scroll = display.scroller;
+    // Quit if there's nothing to scroll here
+    if (!(dx && scroll.scrollWidth > scroll.clientWidth ||
+          dy && scroll.scrollHeight > scroll.clientHeight)) return;
+
+    // Webkit browsers on OS X abort momentum scrolls when the target
+    // of the scroll event is removed from the scrollable element.
+    // This hack (see related code in patchDisplay) makes sure the
+    // element is kept around.
+    if (dy && mac && webkit) {
+      outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
+        for (var i = 0; i < view.length; i++) {
+          if (view[i].node == cur) {
+            cm.display.currentWheelTarget = cur;
+            break outer;
+          }
+        }
+      }
+    }
+
+    // On some browsers, horizontal scrolling will cause redraws to
+    // happen before the gutter has been realigned, causing it to
+    // wriggle around in a most unseemly way. When we have an
+    // estimated pixels/delta value, we just handle horizontal
+    // scrolling entirely here. It'll be slightly off from native, but
+    // better than glitching out.
+    if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {
+      if (dy)
+        setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight)));
+      setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)));
+      e_preventDefault(e);
+      display.wheelStartX = null; // Abort measurement, if in progress
+      return;
+    }
+
+    // 'Project' the visible viewport to cover the area that is being
+    // scrolled into view (if we know enough to estimate it).
+    if (dy && wheelPixelsPerUnit != null) {
+      var pixels = dy * wheelPixelsPerUnit;
+      var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight;
+      if (pixels < 0) top = Math.max(0, top + pixels - 50);
+      else bot = Math.min(cm.doc.height, bot + pixels + 50);
+      updateDisplaySimple(cm, {top: top, bottom: bot});
+    }
+
+    if (wheelSamples < 20) {
+      if (display.wheelStartX == null) {
+        display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop;
+        display.wheelDX = dx; display.wheelDY = dy;
+        setTimeout(function() {
+          if (display.wheelStartX == null) return;
+          var movedX = scroll.scrollLeft - display.wheelStartX;
+          var movedY = scroll.scrollTop - display.wheelStartY;
+          var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
+            (movedX && display.wheelDX && movedX / display.wheelDX);
+          display.wheelStartX = display.wheelStartY = null;
+          if (!sample) return;
+          wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);
+          ++wheelSamples;
+        }, 200);
+      } else {
+        display.wheelDX += dx; display.wheelDY += dy;
+      }
+    }
+  }
+
+  // KEY EVENTS
+
+  // Run a handler that was bound to a key.
+  function doHandleBinding(cm, bound, dropShift) {
+    if (typeof bound == "string") {
+      bound = commands[bound];
+      if (!bound) return false;
+    }
+    // Ensure previous input has been read, so that the handler sees a
+    // consistent view of the document
+    cm.display.input.ensurePolled();
+    var prevShift = cm.display.shift, done = false;
+    try {
+      if (isReadOnly(cm)) cm.state.suppressEdits = true;
+      if (dropShift) cm.display.shift = false;
+      done = bound(cm) != Pass;
+    } finally {
+      cm.display.shift = prevShift;
+      cm.state.suppressEdits = false;
+    }
+    return done;
+  }
+
+  function lookupKeyForEditor(cm, name, handle) {
+    for (var i = 0; i < cm.state.keyMaps.length; i++) {
+      var result = lookupKey(name, cm.state.keyMaps[i], handle, cm);
+      if (result) return result;
+    }
+    return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))
+      || lookupKey(name, cm.options.keyMap, handle, cm);
+  }
+
+  var stopSeq = new Delayed;
+  function dispatchKey(cm, name, e, handle) {
+    var seq = cm.state.keySeq;
+    if (seq) {
+      if (isModifierKey(name)) return "handled";
+      stopSeq.set(50, function() {
+        if (cm.state.keySeq == seq) {
+          cm.state.keySeq = null;
+          cm.display.input.reset();
+        }
+      });
+      name = seq + " " + name;
+    }
+    var result = lookupKeyForEditor(cm, name, handle);
+
+    if (result == "multi")
+      cm.state.keySeq = name;
+    if (result == "handled")
+      signalLater(cm, "keyHandled", cm, name, e);
+
+    if (result == "handled" || result == "multi") {
+      e_preventDefault(e);
+      restartBlink(cm);
+    }
+
+    if (seq && !result && /\'$/.test(name)) {
+      e_preventDefault(e);
+      return true;
+    }
+    return !!result;
+  }
+
+  // Handle a key from the keydown event.
+  function handleKeyBinding(cm, e) {
+    var name = keyName(e, true);
+    if (!name) return false;
+
+    if (e.shiftKey && !cm.state.keySeq) {
+      // First try to resolve full name (including 'Shift-'). Failing
+      // that, see if there is a cursor-motion command (starting with
+      // 'go') bound to the keyname without 'Shift-'.
+      return dispatchKey(cm, "Shift-" + name, e, function(b) {return doHandleBinding(cm, b, true);})
+          || dispatchKey(cm, name, e, function(b) {
+               if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
+                 return doHandleBinding(cm, b);
+             });
+    } else {
+      return dispatchKey(cm, name, e, function(b) { return doHandleBinding(cm, b); });
+    }
+  }
+
+  // Handle a key from the keypress event
+  function handleCharBinding(cm, e, ch) {
+    return dispatchKey(cm, "'" + ch + "'", e,
+                       function(b) { return doHandleBinding(cm, b, true); });
+  }
+
+  var lastStoppedKey = null;
+  function onKeyDown(e) {
+    var cm = this;
+    ensureFocus(cm);
+    if (signalDOMEvent(cm, e)) return;
+    // IE does strange things with escape.
+    if (ie && ie_version < 11 && e.keyCode == 27) e.returnValue = false;
+    var code = e.keyCode;
+    cm.display.shift = code == 16 || e.shiftKey;
+    var handled = handleKeyBinding(cm, e);
+    if (presto) {
+      lastStoppedKey = handled ? code : null;
+      // Opera has no cut event... we try to at least catch the key combo
+      if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
+        cm.replaceSelection("", null, "cut");
+    }
+
+    // Turn mouse into crosshair when Alt is held on Mac.
+    if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
+      showCrossHair(cm);
+  }
+
+  function showCrossHair(cm) {
+    var lineDiv = cm.display.lineDiv;
+    addClass(lineDiv, "CodeMirror-crosshair");
+
+    function up(e) {
+      if (e.keyCode == 18 || !e.altKey) {
+        rmClass(lineDiv, "CodeMirror-crosshair");
+        off(document, "keyup", up);
+        off(document, "mouseover", up);
+      }
+    }
+    on(document, "keyup", up);
+    on(document, "mouseover", up);
+  }
+
+  function onKeyUp(e) {
+    if (e.keyCode == 16) this.doc.sel.shift = false;
+    signalDOMEvent(this, e);
+  }
+
+  function onKeyPress(e) {
+    var cm = this;
+    if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) return;
+    var keyCode = e.keyCode, charCode = e.charCode;
+    if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return;}
+    if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) return;
+    var ch = String.fromCharCode(charCode == null ? keyCode : charCode);
+    if (handleCharBinding(cm, e, ch)) return;
+    cm.display.input.onKeyPress(e);
+  }
+
+  // FOCUS/BLUR EVENTS
+
+  function onFocus(cm) {
+    if (cm.options.readOnly == "nocursor") return;
+    if (!cm.state.focused) {
+      signal(cm, "focus", cm);
+      cm.state.focused = true;
+      addClass(cm.display.wrapper, "CodeMirror-focused");
+      // This test prevents this from firing when a context
+      // menu is closed (since the input reset would kill the
+      // select-all detection hack)
+      if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
+        cm.display.input.reset();
+        if (webkit) setTimeout(function() { cm.display.input.reset(true); }, 20); // Issue #1730
+      }
+      cm.display.input.receivedFocus();
+    }
+    restartBlink(cm);
+  }
+  function onBlur(cm) {
+    if (cm.state.focused) {
+      signal(cm, "blur", cm);
+      cm.state.focused = false;
+      rmClass(cm.display.wrapper, "CodeMirror-focused");
+    }
+    clearInterval(cm.display.blinker);
+    setTimeout(function() {if (!cm.state.focused) cm.display.shift = false;}, 150);
+  }
+
+  // CONTEXT MENU HANDLING
+
+  // To make the context menu work, we need to briefly unhide the
+  // textarea (making it as unobtrusive as possible) to let the
+  // right-click take effect on it.
+  function onContextMenu(cm, e) {
+    if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) return;
+    cm.display.input.onContextMenu(e);
+  }
+
+  function contextMenuInGutter(cm, e) {
+    if (!hasHandler(cm, "gutterContextMenu")) return false;
+    return gutterEvent(cm, e, "gutterContextMenu", false, signal);
+  }
+
+  // UPDATING
+
+  // Compute the position of the end of a change (its 'to' property
+  // refers to the pre-change end).
+  var changeEnd = CodeMirror.changeEnd = function(change) {
+    if (!change.text) return change.to;
+    return Pos(change.from.line + change.text.length - 1,
+               lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0));
+  };
+
+  // Adjust a position to refer to the post-change position of the
+  // same text, or the end of the change if the change covers it.
+  function adjustForChange(pos, change) {
+    if (cmp(pos, change.from) < 0) return pos;
+    if (cmp(pos, change.to) <= 0) return changeEnd(change);
+
+    var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch;
+    if (pos.line == change.to.line) ch += changeEnd(change).ch - change.to.ch;
+    return Pos(line, ch);
+  }
+
+  function computeSelAfterChange(doc, change) {
+    var out = [];
+    for (var i = 0; i < doc.sel.ranges.length; i++) {
+      var range = doc.sel.ranges[i];
+      out.push(new Range(adjustForChange(range.anchor, change),
+                         adjustForChange(range.head, change)));
+    }
+    return normalizeSelection(out, doc.sel.primIndex);
+  }
+
+  function offsetPos(pos, old, nw) {
+    if (pos.line == old.line)
+      return Pos(nw.line, pos.ch - old.ch + nw.ch);
+    else
+      return Pos(nw.line + (pos.line - old.line), pos.ch);
+  }
+
+  // Used by replaceSelections to allow moving the selection to the
+  // start or around the replaced test. Hint may be "start" or "around".
+  function computeReplacedSel(doc, changes, hint) {
+    var out = [];
+    var oldPrev = Pos(doc.first, 0), newPrev = oldPrev;
+    for (var i = 0; i < changes.length; i++) {
+      var change = changes[i];
+      var from = offsetPos(change.from, oldPrev, newPrev);
+      var to = offsetPos(changeEnd(change), oldPrev, newPrev);
+      oldPrev = change.to;
+      newPrev = to;
+      if (hint == "around") {
+        var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0;
+        out[i] = new Range(inv ? to : from, inv ? from : to);
+      } else {
+        out[i] = new Range(from, from);
+      }
+    }
+    return new Selection(out, doc.sel.primIndex);
+  }
+
+  // Allow "beforeChange" event handlers to influence a change
+  function filterChange(doc, change, update) {
+    var obj = {
+      canceled: false,
+      from: change.from,
+      to: change.to,
+      text: change.text,
+      origin: change.origin,
+      cancel: function() { this.canceled = true; }
+    };
+    if (update) obj.update = function(from, to, text, origin) {
+      if (from) this.from = clipPos(doc, from);
+      if (to) this.to = clipPos(doc, to);
+      if (text) this.text = text;
+      if (origin !== undefined) this.origin = origin;
+    };
+    signal(doc, "beforeChange", doc, obj);
+    if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj);
+
+    if (obj.canceled) return null;
+    return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin};
+  }
+
+  // Apply a change to a document, and add it to the document's
+  // history, and propagating it to all linked documents.
+  function makeChange(doc, change, ignoreReadOnly) {
+    if (doc.cm) {
+      if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly);
+      if (doc.cm.state.suppressEdits) return;
+    }
+
+    if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
+      change = filterChange(doc, change, true);
+      if (!change) return;
+    }
+
+    // Possibly split or suppress the update based on the presence
+    // of read-only spans in its range.
+    var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to);
+    if (split) {
+      for (var i = split.length - 1; i >= 0; --i)
+        makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text});
+    } else {
+      makeChangeInner(doc, change);
+    }
+  }
+
+  function makeChangeInner(doc, change) {
+    if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) return;
+    var selAfter = computeSelAfterChange(doc, change);
+    addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN);
+
+    makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change));
+    var rebased = [];
+
+    linkedDocs(doc, function(doc, sharedHist) {
+      if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+        rebaseHist(doc.history, change);
+        rebased.push(doc.history);
+      }
+      makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change));
+    });
+  }
+
+  // Revert a change stored in a document's history.
+  function makeChangeFromHistory(doc, type, allowSelectionOnly) {
+    if (doc.cm && doc.cm.state.suppressEdits) return;
+
+    var hist = doc.history, event, selAfter = doc.sel;
+    var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done;
+
+    // Verify that there is a useable event (so that ctrl-z won't
+    // needlessly clear selection events)
+    for (var i = 0; i < source.length; i++) {
+      event = source[i];
+      if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
+        break;
+    }
+    if (i == source.length) return;
+    hist.lastOrigin = hist.lastSelOrigin = null;
+
+    for (;;) {
+      event = source.pop();
+      if (event.ranges) {
+        pushSelectionToHistory(event, dest);
+        if (allowSelectionOnly && !event.equals(doc.sel)) {
+          setSelection(doc, event, {clearRedo: false});
+          return;
+        }
+        selAfter = event;
+      }
+      else break;
+    }
+
+    // Build up a reverse change object to add to the opposite history
+    // stack (redo when undoing, and vice versa).
+    var antiChanges = [];
+    pushSelectionToHistory(selAfter, dest);
+    dest.push({changes: antiChanges, generation: hist.generation});
+    hist.generation = event.generation || ++hist.maxGeneration;
+
+    var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange");
+
+    for (var i = event.changes.length - 1; i >= 0; --i) {
+      var change = event.changes[i];
+      change.origin = type;
+      if (filter && !filterChange(doc, change, false)) {
+        source.length = 0;
+        return;
+      }
+
+      antiChanges.push(historyChangeFromChange(doc, change));
+
+      var after = i ? computeSelAfterChange(doc, change) : lst(source);
+      makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change));
+      if (!i && doc.cm) doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)});
+      var rebased = [];
+
+      // Propagate to the linked documents
+      linkedDocs(doc, function(doc, sharedHist) {
+        if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+          rebaseHist(doc.history, change);
+          rebased.push(doc.history);
+        }
+        makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change));
+      });
+    }
+  }
+
+  // Sub-views need their line numbers shifted when text is added
+  // above or below them in the parent document.
+  function shiftDoc(doc, distance) {
+    if (distance == 0) return;
+    doc.first += distance;
+    doc.sel = new Selection(map(doc.sel.ranges, function(range) {
+      return new Range(Pos(range.anchor.line + distance, range.anchor.ch),
+                       Pos(range.head.line + distance, range.head.ch));
+    }), doc.sel.primIndex);
+    if (doc.cm) {
+      regChange(doc.cm, doc.first, doc.first - distance, distance);
+      for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
+        regLineChange(doc.cm, l, "gutter");
+    }
+  }
+
+  // More lower-level change function, handling only a single document
+  // (not linked ones).
+  function makeChangeSingleDoc(doc, change, selAfter, spans) {
+    if (doc.cm && !doc.cm.curOp)
+      return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans);
+
+    if (change.to.line < doc.first) {
+      shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line));
+      return;
+    }
+    if (change.from.line > doc.lastLine()) return;
+
+    // Clip the change to the size of this doc
+    if (change.from.line < doc.first) {
+      var shift = change.text.length - 1 - (doc.first - change.from.line);
+      shiftDoc(doc, shift);
+      change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
+                text: [lst(change.text)], origin: change.origin};
+    }
+    var last = doc.lastLine();
+    if (change.to.line > last) {
+      change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
+                text: [change.text[0]], origin: change.origin};
+    }
+
+    change.removed = getBetween(doc, change.from, change.to);
+
+    if (!selAfter) selAfter = computeSelAfterChange(doc, change);
+    if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans);
+    else updateDoc(doc, change, spans);
+    setSelectionNoUndo(doc, selAfter, sel_dontScroll);
+  }
+
+  // Handle the interaction of a change to a document with the editor
+  // that this document is part of.
+  function makeChangeSingleDocInEditor(cm, change, spans) {
+    var doc = cm.doc, display = cm.display, from = change.from, to = change.to;
+
+    var recomputeMaxLength = false, checkWidthStart = from.line;
+    if (!cm.options.lineWrapping) {
+      checkWidthStart = lineNo(visualLine(getLine(doc, from.line)));
+      doc.iter(checkWidthStart, to.line + 1, function(line) {
+        if (line == display.maxLine) {
+          recomputeMaxLength = true;
+          return true;
+        }
+      });
+    }
+
+    if (doc.sel.contains(change.from, change.to) > -1)
+      signalCursorActivity(cm);
+
+    updateDoc(doc, change, spans, estimateHeight(cm));
+
+    if (!cm.options.lineWrapping) {
+      doc.iter(checkWidthStart, from.line + change.text.length, function(line) {
+        var len = lineLength(line);
+        if (len > display.maxLineLength) {
+          display.maxLine = line;
+          display.maxLineLength = len;
+          display.maxLineChanged = true;
+          recomputeMaxLength = false;
+        }
+      });
+      if (recomputeMaxLength) cm.curOp.updateMaxLine = true;
+    }
+
+    // Adjust frontier, schedule worker
+    doc.frontier = Math.min(doc.frontier, from.line);
+    startWorker(cm, 400);
+
+    var lendiff = change.text.length - (to.line - from.line) - 1;
+    // Remember that these lines changed, for updating the display
+    if (change.full)
+      regChange(cm);
+    else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
+      regLineChange(cm, from.line, "text");
+    else
+      regChange(cm, from.line, to.line + 1, lendiff);
+
+    var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change");
+    if (changeHandler || changesHandler) {
+      var obj = {
+        from: from, to: to,
+        text: change.text,
+        removed: change.removed,
+        origin: change.origin
+      };
+      if (changeHandler) signalLater(cm, "change", cm, obj);
+      if (changesHandler) (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj);
+    }
+    cm.display.selForContextMenu = null;
+  }
+
+  function replaceRange(doc, code, from, to, origin) {
+    if (!to) to = from;
+    if (cmp(to, from) < 0) { var tmp = to; to = from; from = tmp; }
+    if (typeof code == "string") code = splitLines(code);
+    makeChange(doc, {from: from, to: to, text: code, origin: origin});
+  }
+
+  // SCROLLING THINGS INTO VIEW
+
+  // If an editor sits on the top or bottom of the window, partially
+  // scrolled out of view, this ensures that the cursor is visible.
+  function maybeScrollWindow(cm, coords) {
+    if (signalDOMEvent(cm, "scrollCursorIntoView")) return;
+
+    var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null;
+    if (coords.top + box.top < 0) doScroll = true;
+    else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) doScroll = false;
+    if (doScroll != null && !phantom) {
+      var scrollNode = elt("div", "\u200b", null, "position: absolute; top: " +
+                           (coords.top - display.viewOffset - paddingTop(cm.display)) + "px; height: " +
+                           (coords.bottom - coords.top + scrollGap(cm) + display.barHeight) + "px; left: " +
+                           coords.left + "px; width: 2px;");
+      cm.display.lineSpace.appendChild(scrollNode);
+      scrollNode.scrollIntoView(doScroll);
+      cm.display.lineSpace.removeChild(scrollNode);
+    }
+  }
+
+  // Scroll a given position into view (immediately), verifying that
+  // it actually became visible (as line heights are accurately
+  // measured, the position of something may 'drift' during drawing).
+  function scrollPosIntoView(cm, pos, end, margin) {
+    if (margin == null) margin = 0;
+    for (var limit = 0; limit < 5; limit++) {
+      var changed = false, coords = cursorCoords(cm, pos);
+      var endCoords = !end || end == pos ? coords : cursorCoords(cm, end);
+      var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left),
+                                         Math.min(coords.top, endCoords.top) - margin,
+                                         Math.max(coords.left, endCoords.left),
+                                         Math.max(coords.bottom, endCoords.bottom) + margin);
+      var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft;
+      if (scrollPos.scrollTop != null) {
+        setScrollTop(cm, scrollPos.scrollTop);
+        if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true;
+      }
+      if (scrollPos.scrollLeft != null) {
+        setScrollLeft(cm, scrollPos.scrollLeft);
+        if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true;
+      }
+      if (!changed) break;
+    }
+    return coords;
+  }
+
+  // Scroll a given set of coordinates into view (immediately).
+  function scrollIntoView(cm, x1, y1, x2, y2) {
+    var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2);
+    if (scrollPos.scrollTop != null) setScrollTop(cm, scrollPos.scrollTop);
+    if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft);
+  }
+
+  // Calculate a new scroll position needed to scroll the given
+  // rectangle into view. Returns an object with scrollTop and
+  // scrollLeft properties. When these are undefined, the
+  // vertical/horizontal position does not need to be adjusted.
+  function calculateScrollPos(cm, x1, y1, x2, y2) {
+    var display = cm.display, snapMargin = textHeight(cm.display);
+    if (y1 < 0) y1 = 0;
+    var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop;
+    var screen = displayHeight(cm), result = {};
+    if (y2 - y1 > screen) y2 = y1 + screen;
+    var docBottom = cm.doc.height + paddingVert(display);
+    var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin;
+    if (y1 < screentop) {
+      result.scrollTop = atTop ? 0 : y1;
+    } else if (y2 > screentop + screen) {
+      var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen);
+      if (newTop != screentop) result.scrollTop = newTop;
+    }
+
+    var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft;
+    var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0);
+    var tooWide = x2 - x1 > screenw;
+    if (tooWide) x2 = x1 + screenw;
+    if (x1 < 10)
+      result.scrollLeft = 0;
+    else if (x1 < screenleft)
+      result.scrollLeft = Math.max(0, x1 - (tooWide ? 0 : 10));
+    else if (x2 > screenw + screenleft - 3)
+      result.scrollLeft = x2 + (tooWide ? 0 : 10) - screenw;
+    return result;
+  }
+
+  // Store a relative adjustment to the scroll position in the current
+  // operation (to be applied when the operation finishes).
+  function addToScrollPos(cm, left, top) {
+    if (left != null || top != null) resolveScrollToPos(cm);
+    if (left != null)
+      cm.curOp.scrollLeft = (cm.curOp.scrollLeft == null ? cm.doc.scrollLeft : cm.curOp.scrollLeft) + left;
+    if (top != null)
+      cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top;
+  }
+
+  // Make sure that at the end of the operation the current cursor is
+  // shown.
+  function ensureCursorVisible(cm) {
+    resolveScrollToPos(cm);
+    var cur = cm.getCursor(), from = cur, to = cur;
+    if (!cm.options.lineWrapping) {
+      from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur;
+      to = Pos(cur.line, cur.ch + 1);
+    }
+    cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true};
+  }
+
+  // When an operation has its scrollToPos property set, and another
+  // scroll action is applied before the end of the operation, this
+  // 'simulates' scrolling that position into view in a cheap way, so
+  // that the effect of intermediate scroll commands is not ignored.
+  function resolveScrollToPos(cm) {
+    var range = cm.curOp.scrollToPos;
+    if (range) {
+      cm.curOp.scrollToPos = null;
+      var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to);
+      var sPos = calculateScrollPos(cm, Math.min(from.left, to.left),
+                                    Math.min(from.top, to.top) - range.margin,
+                                    Math.max(from.right, to.right),
+                                    Math.max(from.bottom, to.bottom) + range.margin);
+      cm.scrollTo(sPos.scrollLeft, sPos.scrollTop);
+    }
+  }
+
+  // API UTILITIES
+
+  // Indent the given line. The how parameter can be "smart",
+  // "add"/null, "subtract", or "prev". When aggressive is false
+  // (typically set to true for forced single-line indents), empty
+  // lines are not indented, and places where the mode returns Pass
+  // are left alone.
+  function indentLine(cm, n, how, aggressive) {
+    var doc = cm.doc, state;
+    if (how == null) how = "add";
+    if (how == "smart") {
+      // Fall back to "prev" when the mode doesn't have an indentation
+      // method.
+      if (!doc.mode.indent) how = "prev";
+      else state = getStateBefore(cm, n);
+    }
+
+    var tabSize = cm.options.tabSize;
+    var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize);
+    if (line.stateAfter) line.stateAfter = null;
+    var curSpaceString = line.text.match(/^\s*/)[0], indentation;
+    if (!aggressive && !/\S/.test(line.text)) {
+      indentation = 0;
+      how = "not";
+    } else if (how == "smart") {
+      indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text);
+      if (indentation == Pass || indentation > 150) {
+        if (!aggressive) return;
+        how = "prev";
+      }
+    }
+    if (how == "prev") {
+      if (n > doc.first) indentation = countColumn(getLine(doc, n-1).text, null, tabSize);
+      else indentation = 0;
+    } else if (how == "add") {
+      indentation = curSpace + cm.options.indentUnit;
+    } else if (how == "subtract") {
+      indentation = curSpace - cm.options.indentUnit;
+    } else if (typeof how == "number") {
+      indentation = curSpace + how;
+    }
+    indentation = Math.max(0, indentation);
+
+    var indentString = "", pos = 0;
+    if (cm.options.indentWithTabs)
+      for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";}
+    if (pos < indentation) indentString += spaceStr(indentation - pos);
+
+    if (indentString != curSpaceString) {
+      replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input");
+    } else {
+      // Ensure that, if the cursor was in the whitespace at the start
+      // of the line, it is moved to the end of that space.
+      for (var i = 0; i < doc.sel.ranges.length; i++) {
+        var range = doc.sel.ranges[i];
+        if (range.head.line == n && range.head.ch < curSpaceString.length) {
+          var pos = Pos(n, curSpaceString.length);
+          replaceOneSelection(doc, i, new Range(pos, pos));
+          break;
+        }
+      }
+    }
+    line.stateAfter = null;
+  }
+
+  // Utility for applying a change to a line by handle or number,
+  // returning the number and optionally registering the line as
+  // changed.
+  function changeLine(doc, handle, changeType, op) {
+    var no = handle, line = handle;
+    if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle));
+    else no = lineNo(handle);
+    if (no == null) return null;
+    if (op(line, no) && doc.cm) regLineChange(doc.cm, no, changeType);
+    return line;
+  }
+
+  // Helper for deleting text near the selection(s), used to implement
+  // backspace, delete, and similar functionality.
+  function deleteNearSelection(cm, compute) {
+    var ranges = cm.doc.sel.ranges, kill = [];
+    // Build up a set of ranges to kill first, merging overlapping
+    // ranges.
+    for (var i = 0; i < ranges.length; i++) {
+      var toKill = compute(ranges[i]);
+      while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
+        var replaced = kill.pop();
+        if (cmp(replaced.from, toKill.from) < 0) {
+          toKill.from = replaced.from;
+          break;
+        }
+      }
+      kill.push(toKill);
+    }
+    // Next, remove those actual ranges.
+    runInOp(cm, function() {
+      for (var i = kill.length - 1; i >= 0; i--)
+        replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete");
+      ensureCursorVisible(cm);
+    });
+  }
+
+  // Used for horizontal relative motion. Dir is -1 or 1 (left or
+  // right), unit can be "char", "column" (like char, but doesn't
+  // cross line boundaries), "word" (across next word), or "group" (to
+  // the start of next group of word or non-word-non-whitespace
+  // chars). The visually param controls whether, in right-to-left
+  // text, direction 1 means to move towards the next index in the
+  // string, or towards the character to the right of the current
+  // position. The resulting position will have a hitSide=true
+  // property if it reached the end of the document.
+  function findPosH(doc, pos, dir, unit, visually) {
+    var line = pos.line, ch = pos.ch, origDir = dir;
+    var lineObj = getLine(doc, line);
+    var possible = true;
+    function findNextLine() {
+      var l = line + dir;
+      if (l < doc.first || l >= doc.first + doc.size) return (possible = false);
+      line = l;
+      return lineObj = getLine(doc, l);
+    }
+    function moveOnce(boundToLine) {
+      var next = (visually ? moveVisually : moveLogically)(lineObj, ch, dir, true);
+      if (next == null) {
+        if (!boundToLine && findNextLine()) {
+          if (visually) ch = (dir < 0 ? lineRight : lineLeft)(lineObj);
+          else ch = dir < 0 ? lineObj.text.length : 0;
+        } else return (possible = false);
+      } else ch = next;
+      return true;
+    }
+
+    if (unit == "char") moveOnce();
+    else if (unit == "column") moveOnce(true);
+    else if (unit == "word" || unit == "group") {
+      var sawType = null, group = unit == "group";
+      var helper = doc.cm && doc.cm.getHelper(pos, "wordChars");
+      for (var first = true;; first = false) {
+        if (dir < 0 && !moveOnce(!first)) break;
+        var cur = lineObj.text.charAt(ch) || "\n";
+        var type = isWordChar(cur, helper) ? "w"
+          : group && cur == "\n" ? "n"
+          : !group || /\s/.test(cur) ? null
+          : "p";
+        if (group && !first && !type) type = "s";
+        if (sawType && sawType != type) {
+          if (dir < 0) {dir = 1; moveOnce();}
+          break;
+        }
+
+        if (type) sawType = type;
+        if (dir > 0 && !moveOnce(!first)) break;
+      }
+    }
+    var result = skipAtomic(doc, Pos(line, ch), origDir, true);
+    if (!possible) result.hitSide = true;
+    return result;
+  }
+
+  // For relative vertical movement. Dir may be -1 or 1. Unit can be
+  // "page" or "line". The resulting position will have a hitSide=true
+  // property if it reached the end of the document.
+  function findPosV(cm, pos, dir, unit) {
+    var doc = cm.doc, x = pos.left, y;
+    if (unit == "page") {
+      var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight);
+      y = pos.top + dir * (pageSize - (dir < 0 ? 1.5 : .5) * textHeight(cm.display));
+    } else if (unit == "line") {
+      y = dir > 0 ? pos.bottom + 3 : pos.top - 3;
+    }
+    for (;;) {
+      var target = coordsChar(cm, x, y);
+      if (!target.outside) break;
+      if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break; }
+      y += dir * 5;
+    }
+    return target;
+  }
+
+  // EDITOR METHODS
+
+  // The publicly visible API. Note that methodOp(f) means
+  // 'wrap f in an operation, performed on its `this` parameter'.
+
+  // This is not the complete set of editor methods. Most of the
+  // methods defined on the Doc type are also injected into
+  // CodeMirror.prototype, for backwards compatibility and
+  // convenience.
+
+  CodeMirror.prototype = {
+    constructor: CodeMirror,
+    focus: function(){window.focus(); this.display.input.focus();},
+
+    setOption: function(option, value) {
+      var options = this.options, old = options[option];
+      if (options[option] == value && option != "mode") return;
+      options[option] = value;
+      if (optionHandlers.hasOwnProperty(option))
+        operation(this, optionHandlers[option])(this, value, old);
+    },
+
+    getOption: function(option) {return this.options[option];},
+    getDoc: function() {return this.doc;},
+
+    addKeyMap: function(map, bottom) {
+      this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map));
+    },
+    removeKeyMap: function(map) {
+      var maps = this.state.keyMaps;
+      for (var i = 0; i < maps.length; ++i)
+        if (maps[i] == map || maps[i].name == map) {
+          maps.splice(i, 1);
+          return true;
+        }
+    },
+
+    addOverlay: methodOp(function(spec, options) {
+      var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec);
+      if (mode.startState) throw new Error("Overlays may not be stateful.");
+      this.state.overlays.push({mode: mode, modeSpec: spec, opaque: options && options.opaque});
+      this.state.modeGen++;
+      regChange(this);
+    }),
+    removeOverlay: methodOp(function(spec) {
+      var overlays = this.state.overlays;
+      for (var i = 0; i < overlays.length; ++i) {
+        var cur = overlays[i].modeSpec;
+        if (cur == spec || typeof spec == "string" && cur.name == spec) {
+          overlays.splice(i, 1);
+          this.state.modeGen++;
+          regChange(this);
+          return;
+        }
+      }
+    }),
+
+    indentLine: methodOp(function(n, dir, aggressive) {
+      if (typeof dir != "string" && typeof dir != "number") {
+        if (dir == null) dir = this.options.smartIndent ? "smart" : "prev";
+        else dir = dir ? "add" : "subtract";
+      }
+      if (isLine(this.doc, n)) indentLine(this, n, dir, aggressive);
+    }),
+    indentSelection: methodOp(function(how) {
+      var ranges = this.doc.sel.ranges, end = -1;
+      for (var i = 0; i < ranges.length; i++) {
+        var range = ranges[i];
+        if (!range.empty()) {
+          var from = range.from(), to = range.to();
+          var start = Math.max(end, from.line);
+          end = Math.min(this.lastLine(), to.line - (to.ch ? 0 : 1)) + 1;
+          for (var j = start; j < end; ++j)
+            indentLine(this, j, how);
+          var newRanges = this.doc.sel.ranges;
+          if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)
+            replaceOneSelection(this.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll);
+        } else if (range.head.line > end) {
+          indentLine(this, range.head.line, how, true);
+          end = range.head.line;
+          if (i == this.doc.sel.primIndex) ensureCursorVisible(this);
+        }
+      }
+    }),
+
+    // Fetch the parser token for a given character. Useful for hacks
+    // that want to inspect the mode state (say, for completion).
+    getTokenAt: function(pos, precise) {
+      return takeToken(this, pos, precise);
+    },
+
+    getLineTokens: function(line, precise) {
+      return takeToken(this, Pos(line), precise, true);
+    },
+
+    getTokenTypeAt: function(pos) {
+      pos = clipPos(this.doc, pos);
+      var styles = getLineStyles(this, getLine(this.doc, pos.line));
+      var before = 0, after = (styles.length - 1) / 2, ch = pos.ch;
+      var type;
+      if (ch == 0) type = styles[2];
+      else for (;;) {
+        var mid = (before + after) >> 1;
+        if ((mid ? styles[mid * 2 - 1] : 0) >= ch) after = mid;
+        else if (styles[mid * 2 + 1] < ch) before = mid + 1;
+        else { type = styles[mid * 2 + 2]; break; }
+      }
+      var cut = type ? type.indexOf("cm-overlay ") : -1;
+      return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1);
+    },
+
+    getModeAt: function(pos) {
+      var mode = this.doc.mode;
+      if (!mode.innerMode) return mode;
+      return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode;
+    },
+
+    getHelper: function(pos, type) {
+      return this.getHelpers(pos, type)[0];
+    },
+
+    getHelpers: function(pos, type) {
+      var found = [];
+      if (!helpers.hasOwnProperty(type)) return helpers;
+      var help = helpers[type], mode = this.getModeAt(pos);
+      if (typeof mode[type] == "string") {
+        if (help[mode[type]]) found.push(help[mode[type]]);
+      } else if (mode[type]) {
+        for (var i = 0; i < mode[type].length; i++) {
+          var val = help[mode[type][i]];
+          if (val) found.push(val);
+        }
+      } else if (mode.helperType && help[mode.helperType]) {
+        found.push(help[mode.helperType]);
+      } else if (help[mode.name]) {
+        found.push(help[mode.name]);
+      }
+      for (var i = 0; i < help._global.length; i++) {
+        var cur = help._global[i];
+        if (cur.pred(mode, this) && indexOf(found, cur.val) == -1)
+          found.push(cur.val);
+      }
+      return found;
+    },
+
+    getStateAfter: function(line, precise) {
+      var doc = this.doc;
+      line = clipLine(doc, line == null ? doc.first + doc.size - 1: line);
+      return getStateBefore(this, line + 1, precise);
+    },
+
+    cursorCoords: function(start, mode) {
+      var pos, range = this.doc.sel.primary();
+      if (start == null) pos = range.head;
+      else if (typeof start == "object") pos = clipPos(this.doc, start);
+      else pos = start ? range.from() : range.to();
+      return cursorCoords(this, pos, mode || "page");
+    },
+
+    charCoords: function(pos, mode) {
+      return charCoords(this, clipPos(this.doc, pos), mode || "page");
+    },
+
+    coordsChar: function(coords, mode) {
+      coords = fromCoordSystem(this, coords, mode || "page");
+      return coordsChar(this, coords.left, coords.top);
+    },
+
+    lineAtHeight: function(height, mode) {
+      height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top;
+      return lineAtHeight(this.doc, height + this.display.viewOffset);
+    },
+    heightAtLine: function(line, mode) {
+      var end = false, last = this.doc.first + this.doc.size - 1;
+      if (line < this.doc.first) line = this.doc.first;
+      else if (line > last) { line = last; end = true; }
+      var lineObj = getLine(this.doc, line);
+      return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page").top +
+        (end ? this.doc.height - heightAtLine(lineObj) : 0);
+    },
+
+    defaultTextHeight: function() { return textHeight(this.display); },
+    defaultCharWidth: function() { return charWidth(this.display); },
+
+    setGutterMarker: methodOp(function(line, gutterID, value) {
+      return changeLine(this.doc, line, "gutter", function(line) {
+        var markers = line.gutterMarkers || (line.gutterMarkers = {});
+        markers[gutterID] = value;
+        if (!value && isEmpty(markers)) line.gutterMarkers = null;
+        return true;
+      });
+    }),
+
+    clearGutter: methodOp(function(gutterID) {
+      var cm = this, doc = cm.doc, i = doc.first;
+      doc.iter(function(line) {
+        if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
+          line.gutterMarkers[gutterID] = null;
+          regLineChange(cm, i, "gutter");
+          if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null;
+        }
+        ++i;
+      });
+    }),
+
+    addLineWidget: methodOp(function(handle, node, options) {
+      return addLineWidget(this, handle, node, options);
+    }),
+
+    removeLineWidget: function(widget) { widget.clear(); },
+
+    lineInfo: function(line) {
+      if (typeof line == "number") {
+        if (!isLine(this.doc, line)) return null;
+        var n = line;
+        line = getLine(this.doc, line);
+        if (!line) return null;
+      } else {
+        var n = lineNo(line);
+        if (n == null) return null;
+      }
+      return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
+              textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
+              widgets: line.widgets};
+    },
+
+    getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo};},
+
+    addWidget: function(pos, node, scroll, vert, horiz) {
+      var display = this.display;
+      pos = cursorCoords(this, clipPos(this.doc, pos));
+      var top = pos.bottom, left = pos.left;
+      node.style.position = "absolute";
+      node.setAttribute("cm-ignore-events", "true");
+      this.display.input.setUneditable(node);
+      display.sizer.appendChild(node);
+      if (vert == "over") {
+        top = pos.top;
+      } else if (vert == "above" || vert == "near") {
+        var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
+        hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth);
+        // Default to positioning above (if specified and possible); otherwise default to positioning below
+        if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
+          top = pos.top - node.offsetHeight;
+        else if (pos.bottom + node.offsetHeight <= vspace)
+          top = pos.bottom;
+        if (left + node.offsetWidth > hspace)
+          left = hspace - node.offsetWidth;
+      }
+      node.style.top = top + "px";
+      node.style.left = node.style.right = "";
+      if (horiz == "right") {
+        left = display.sizer.clientWidth - node.offsetWidth;
+        node.style.right = "0px";
+      } else {
+        if (horiz == "left") left = 0;
+        else if (horiz == "middle") left = (display.sizer.clientWidth - node.offsetWidth) / 2;
+        node.style.left = left + "px";
+      }
+      if (scroll)
+        scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight);
+    },
+
+    triggerOnKeyDown: methodOp(onKeyDown),
+    triggerOnKeyPress: methodOp(onKeyPress),
+    triggerOnKeyUp: onKeyUp,
+
+    execCommand: function(cmd) {
+      if (commands.hasOwnProperty(cmd))
+        return commands[cmd](this);
+    },
+
+    findPosH: function(from, amount, unit, visually) {
+      var dir = 1;
+      if (amount < 0) { dir = -1; amount = -amount; }
+      for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
+        cur = findPosH(this.doc, cur, dir, unit, visually);
+        if (cur.hitSide) break;
+      }
+      return cur;
+    },
+
+    moveH: methodOp(function(dir, unit) {
+      var cm = this;
+      cm.extendSelectionsBy(function(range) {
+        if (cm.display.shift || cm.doc.extend || range.empty())
+          return findPosH(cm.doc, range.head, dir, unit, cm.options.rtlMoveVisually);
+        else
+          return dir < 0 ? range.from() : range.to();
+      }, sel_move);
+    }),
+
+    deleteH: methodOp(function(dir, unit) {
+      var sel = this.doc.sel, doc = this.doc;
+      if (sel.somethingSelected())
+        doc.replaceSelection("", null, "+delete");
+      else
+        deleteNearSelection(this, function(range) {
+          var other = findPosH(doc, range.head, dir, unit, false);
+          return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other};
+        });
+    }),
+
+    findPosV: function(from, amount, unit, goalColumn) {
+      var dir = 1, x = goalColumn;
+      if (amount < 0) { dir = -1; amount = -amount; }
+      for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
+        var coords = cursorCoords(this, cur, "div");
+        if (x == null) x = coords.left;
+        else coords.left = x;
+        cur = findPosV(this, coords, dir, unit);
+        if (cur.hitSide) break;
+      }
+      return cur;
+    },
+
+    moveV: methodOp(function(dir, unit) {
+      var cm = this, doc = this.doc, goals = [];
+      var collapse = !cm.display.shift && !doc.extend && doc.sel.somethingSelected();
+      doc.extendSelectionsBy(function(range) {
+        if (collapse)
+          return dir < 0 ? range.from() : range.to();
+        var headPos = cursorCoords(cm, range.head, "div");
+        if (range.goalColumn != null) headPos.left = range.goalColumn;
+        goals.push(headPos.left);
+        var pos = findPosV(cm, headPos, dir, unit);
+        if (unit == "page" && range == doc.sel.primary())
+          addToScrollPos(cm, null, charCoords(cm, pos, "div").top - headPos.top);
+        return pos;
+      }, sel_move);
+      if (goals.length) for (var i = 0; i < doc.sel.ranges.length; i++)
+        doc.sel.ranges[i].goalColumn = goals[i];
+    }),
+
+    // Find the word at the given position (as returned by coordsChar).
+    findWordAt: function(pos) {
+      var doc = this.doc, line = getLine(doc, pos.line).text;
+      var start = pos.ch, end = pos.ch;
+      if (line) {
+        var helper = this.getHelper(pos, "wordChars");
+        if ((pos.xRel < 0 || end == line.length) && start) --start; else ++end;
+        var startChar = line.charAt(start);
+        var check = isWordChar(startChar, helper)
+          ? function(ch) { return isWordChar(ch, helper); }
+          : /\s/.test(startChar) ? function(ch) {return /\s/.test(ch);}
+          : function(ch) {return !/\s/.test(ch) && !isWordChar(ch);};
+        while (start > 0 && check(line.charAt(start - 1))) --start;
+        while (end < line.length && check(line.charAt(end))) ++end;
+      }
+      return new Range(Pos(pos.line, start), Pos(pos.line, end));
+    },
+
+    toggleOverwrite: function(value) {
+      if (value != null && value == this.state.overwrite) return;
+      if (this.state.overwrite = !this.state.overwrite)
+        addClass(this.display.cursorDiv, "CodeMirror-overwrite");
+      else
+        rmClass(this.display.cursorDiv, "CodeMirror-overwrite");
+
+      signal(this, "overwriteToggle", this, this.state.overwrite);
+    },
+    hasFocus: function() { return this.display.input.getField() == activeElt(); },
+
+    scrollTo: methodOp(function(x, y) {
+      if (x != null || y != null) resolveScrollToPos(this);
+      if (x != null) this.curOp.scrollLeft = x;
+      if (y != null) this.curOp.scrollTop = y;
+    }),
+    getScrollInfo: function() {
+      var scroller = this.display.scroller;
+      return {left: scroller.scrollLeft, top: scroller.scrollTop,
+              height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,
+              width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,
+              clientHeight: displayHeight(this), clientWidth: displayWidth(this)};
+    },
+
+    scrollIntoView: methodOp(function(range, margin) {
+      if (range == null) {
+        range = {from: this.doc.sel.primary().head, to: null};
+        if (margin == null) margin = this.options.cursorScrollMargin;
+      } else if (typeof range == "number") {
+        range = {from: Pos(range, 0), to: null};
+      } else if (range.from == null) {
+        range = {from: range, to: null};
+      }
+      if (!range.to) range.to = range.from;
+      range.margin = margin || 0;
+
+      if (range.from.line != null) {
+        resolveScrollToPos(this);
+        this.curOp.scrollToPos = range;
+      } else {
+        var sPos = calculateScrollPos(this, Math.min(range.from.left, range.to.left),
+                                      Math.min(range.from.top, range.to.top) - range.margin,
+                                      Math.max(range.from.right, range.to.right),
+                                      Math.max(range.from.bottom, range.to.bottom) + range.margin);
+        this.scrollTo(sPos.scrollLeft, sPos.scrollTop);
+      }
+    }),
+
+    setSize: methodOp(function(width, height) {
+      var cm = this;
+      function interpret(val) {
+        return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val;
+      }
+      if (width != null) cm.display.wrapper.style.width = interpret(width);
+      if (height != null) cm.display.wrapper.style.height = interpret(height);
+      if (cm.options.lineWrapping) clearLineMeasurementCache(this);
+      var lineNo = cm.display.viewFrom;
+      cm.doc.iter(lineNo, cm.display.viewTo, function(line) {
+        if (line.widgets) for (var i = 0; i < line.widgets.length; i++)
+          if (line.widgets[i].noHScroll) { regLineChange(cm, lineNo, "widget"); break; }
+        ++lineNo;
+      });
+      cm.curOp.forceUpdate = true;
+      signal(cm, "refresh", this);
+    }),
+
+    operation: function(f){return runInOp(this, f);},
+
+    refresh: methodOp(function() {
+      var oldHeight = this.display.cachedTextHeight;
+      regChange(this);
+      this.curOp.forceUpdate = true;
+      clearCaches(this);
+      this.scrollTo(this.doc.scrollLeft, this.doc.scrollTop);
+      updateGutterSpace(this);
+      if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)
+        estimateLineHeights(this);
+      signal(this, "refresh", this);
+    }),
+
+    swapDoc: methodOp(function(doc) {
+      var old = this.doc;
+      old.cm = null;
+      attachDoc(this, doc);
+      clearCaches(this);
+      this.display.input.reset();
+      this.scrollTo(doc.scrollLeft, doc.scrollTop);
+      this.curOp.forceScroll = true;
+      signalLater(this, "swapDoc", this, old);
+      return old;
+    }),
+
+    getInputField: function(){return this.display.input.getField();},
+    getWrapperElement: function(){return this.display.wrapper;},
+    getScrollerElement: function(){return this.display.scroller;},
+    getGutterElement: function(){return this.display.gutters;}
+  };
+  eventMixin(CodeMirror);
+
+  // OPTION DEFAULTS
+
+  // The default configuration options.
+  var defaults = CodeMirror.defaults = {};
+  // Functions to run when options are changed.
+  var optionHandlers = CodeMirror.optionHandlers = {};
+
+  function option(name, deflt, handle, notOnInit) {
+    CodeMirror.defaults[name] = deflt;
+    if (handle) optionHandlers[name] =
+      notOnInit ? function(cm, val, old) {if (old != Init) handle(cm, val, old);} : handle;
+  }
+
+  // Passed to option handlers when there is no old value.
+  var Init = CodeMirror.Init = {toString: function(){return "CodeMirror.Init";}};
+
+  // These two are, on init, called from the constructor because they
+  // have to be initialized before the editor can start at all.
+  option("value", "", function(cm, val) {
+    cm.setValue(val);
+  }, true);
+  option("mode", null, function(cm, val) {
+    cm.doc.modeOption = val;
+    loadMode(cm);
+  }, true);
+
+  option("indentUnit", 2, loadMode, true);
+  option("indentWithTabs", false);
+  option("smartIndent", true);
+  option("tabSize", 4, function(cm) {
+    resetModeState(cm);
+    clearCaches(cm);
+    regChange(cm);
+  }, true);
+  option("specialChars", /[\t\u0000-\u0019\u00ad\u200b-\u200f\u2028\u2029\ufeff]/g, function(cm, val) {
+    cm.options.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g");
+    cm.refresh();
+  }, true);
+  option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function(cm) {cm.refresh();}, true);
+  option("electricChars", true);
+  option("inputStyle", mobile ? "contenteditable" : "textarea", function() {
+    throw new Error("inputStyle can not (yet) be changed in a running editor"); // FIXME
+  }, true);
+  option("rtlMoveVisually", !windows);
+  option("wholeLineUpdateBefore", true);
+
+  option("theme", "default", function(cm) {
+    themeChanged(cm);
+    guttersChanged(cm);
+  }, true);
+  option("keyMap", "default", function(cm, val, old) {
+    var next = getKeyMap(val);
+    var prev = old != CodeMirror.Init && getKeyMap(old);
+    if (prev && prev.detach) prev.detach(cm, next);
+    if (next.attach) next.attach(cm, prev || null);
+  });
+  option("extraKeys", null);
+
+  option("lineWrapping", false, wrappingChanged, true);
+  option("gutters", [], function(cm) {
+    setGuttersForLineNumbers(cm.options);
+    guttersChanged(cm);
+  }, true);
+  option("fixedGutter", true, function(cm, val) {
+    cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0";
+    cm.refresh();
+  }, true);
+  option("coverGutterNextToScrollbar", false, function(cm) {updateScrollbars(cm);}, true);
+  option("scrollbarStyle", "native", function(cm) {
+    initScrollbars(cm);
+    updateScrollbars(cm);
+    cm.display.scrollbars.setScrollTop(cm.doc.scrollTop);
+    cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft);
+  }, true);
+  option("lineNumbers", false, function(cm) {
+    setGuttersForLineNumbers(cm.options);
+    guttersChanged(cm);
+  }, true);
+  option("firstLineNumber", 1, guttersChanged, true);
+  option("lineNumberFormatter", function(integer) {return integer;}, guttersChanged, true);
+  option("showCursorWhenSelecting", false, updateSelection, true);
+
+  option("resetSelectionOnContextMenu", true);
+
+  option("readOnly", false, function(cm, val) {
+    if (val == "nocursor") {
+      onBlur(cm);
+      cm.display.input.blur();
+      cm.display.disabled = true;
+    } else {
+      cm.display.disabled = false;
+      if (!val) cm.display.input.reset();
+    }
+  });
+  option("disableInput", false, function(cm, val) {if (!val) cm.display.input.reset();}, true);
+  option("dragDrop", true);
+
+  option("cursorBlinkRate", 530);
+  option("cursorScrollMargin", 0);
+  option("cursorHeight", 1, updateSelection, true);
+  option("singleCursorHeightPerLine", true, updateSelection, true);
+  option("workTime", 100);
+  option("workDelay", 100);
+  option("flattenSpans", true, resetModeState, true);
+  option("addModeClass", false, resetModeState, true);
+  option("pollInterval", 100);
+  option("undoDepth", 200, function(cm, val){cm.doc.history.undoDepth = val;});
+  option("historyEventDelay", 1250);
+  option("viewportMargin", 10, function(cm){cm.refresh();}, true);
+  option("maxHighlightLength", 10000, resetModeState, true);
+  option("moveInputWithCursor", true, function(cm, val) {
+    if (!val) cm.display.input.resetPosition();
+  });
+
+  option("tabindex", null, function(cm, val) {
+    cm.display.input.getField().tabIndex = val || "";
+  });
+  option("autofocus", null);
+
+  // MODE DEFINITION AND QUERYING
+
+  // Known modes, by name and by MIME
+  var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {};
+
+  // Extra arguments are stored as the mode's dependencies, which is
+  // used by (legacy) mechanisms like loadmode.js to automatically
+  // load a mode. (Preferred mechanism is the require/define calls.)
+  CodeMirror.defineMode = function(name, mode) {
+    if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name;
+    if (arguments.length > 2)
+      mode.dependencies = Array.prototype.slice.call(arguments, 2);
+    modes[name] = mode;
+  };
+
+  CodeMirror.defineMIME = function(mime, spec) {
+    mimeModes[mime] = spec;
+  };
+
+  // Given a MIME type, a {name, ...options} config object, or a name
+  // string, return a mode config object.
+  CodeMirror.resolveMode = function(spec) {
+    if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
+      spec = mimeModes[spec];
+    } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
+      var found = mimeModes[spec.name];
+      if (typeof found == "string") found = {name: found};
+      spec = createObj(found, spec);
+      spec.name = found.name;
+    } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
+      return CodeMirror.resolveMode("application/xml");
+    }
+    if (typeof spec == "string") return {name: spec};
+    else return spec || {name: "null"};
+  };
+
+  // Given a mode spec (anything that resolveMode accepts), find and
+  // initialize an actual mode object.
+  CodeMirror.getMode = function(options, spec) {
+    var spec = CodeMirror.resolveMode(spec);
+    var mfactory = modes[spec.name];
+    if (!mfactory) return CodeMirror.getMode(options, "text/plain");
+    var modeObj = mfactory(options, spec);
+    if (modeExtensions.hasOwnProperty(spec.name)) {
+      var exts = modeExtensions[spec.name];
+      for (var prop in exts) {
+        if (!exts.hasOwnProperty(prop)) continue;
+        if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop];
+        modeObj[prop] = exts[prop];
+      }
+    }
+    modeObj.name = spec.name;
+    if (spec.helperType) modeObj.helperType = spec.helperType;
+    if (spec.modeProps) for (var prop in spec.modeProps)
+      modeObj[prop] = spec.modeProps[prop];
+
+    return modeObj;
+  };
+
+  // Minimal default mode.
+  CodeMirror.defineMode("null", function() {
+    return {token: function(stream) {stream.skipToEnd();}};
+  });
+  CodeMirror.defineMIME("text/plain", "null");
+
+  // This can be used to attach properties to mode objects from
+  // outside the actual mode definition.
+  var modeExtensions = CodeMirror.modeExtensions = {};
+  CodeMirror.extendMode = function(mode, properties) {
+    var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});
+    copyObj(properties, exts);
+  };
+
+  // EXTENSIONS
+
+  CodeMirror.defineExtension = function(name, func) {
+    CodeMirror.prototype[name] = func;
+  };
+  CodeMirror.defineDocExtension = function(name, func) {
+    Doc.prototype[name] = func;
+  };
+  CodeMirror.defineOption = option;
+
+  var initHooks = [];
+  CodeMirror.defineInitHook = function(f) {initHooks.push(f);};
+
+  var helpers = CodeMirror.helpers = {};
+  CodeMirror.registerHelper = function(type, name, value) {
+    if (!helpers.hasOwnProperty(type)) helpers[type] = CodeMirror[type] = {_global: []};
+    helpers[type][name] = value;
+  };
+  CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {
+    CodeMirror.registerHelper(type, name, value);
+    helpers[type]._global.push({pred: predicate, val: value});
+  };
+
+  // MODE STATE HANDLING
+
+  // Utility functions for working with state. Exported because nested
+  // modes need to do this for their inner modes.
+
+  var copyState = CodeMirror.copyState = function(mode, state) {
+    if (state === true) return state;
+    if (mode.copyState) return mode.copyState(state);
+    var nstate = {};
+    for (var n in state) {
+      var val = state[n];
+      if (val instanceof Array) val = val.concat([]);
+      nstate[n] = val;
+    }
+    return nstate;
+  };
+
+  var startState = CodeMirror.startState = function(mode, a1, a2) {
+    return mode.startState ? mode.startState(a1, a2) : true;
+  };
+
+  // Given a mode and a state (for that mode), find the inner mode and
+  // state at the position that the state refers to.
+  CodeMirror.innerMode = function(mode, state) {
+    while (mode.innerMode) {
+      var info = mode.innerMode(state);
+      if (!info || info.mode == mode) break;
+      state = info.state;
+      mode = info.mode;
+    }
+    return info || {mode: mode, state: state};
+  };
+
+  // STANDARD COMMANDS
+
+  // Commands are parameter-less actions that can be performed on an
+  // editor, mostly used for keybindings.
+  var commands = CodeMirror.commands = {
+    selectAll: function(cm) {cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll);},
+    singleSelection: function(cm) {
+      cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll);
+    },
+    killLine: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        if (range.empty()) {
+          var len = getLine(cm.doc, range.head.line).text.length;
+          if (range.head.ch == len && range.head.line < cm.lastLine())
+            return {from: range.head, to: Pos(range.head.line + 1, 0)};
+          else
+            return {from: range.head, to: Pos(range.head.line, len)};
+        } else {
+          return {from: range.from(), to: range.to()};
+        }
+      });
+    },
+    deleteLine: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        return {from: Pos(range.from().line, 0),
+                to: clipPos(cm.doc, Pos(range.to().line + 1, 0))};
+      });
+    },
+    delLineLeft: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        return {from: Pos(range.from().line, 0), to: range.from()};
+      });
+    },
+    delWrappedLineLeft: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        var leftPos = cm.coordsChar({left: 0, top: top}, "div");
+        return {from: leftPos, to: range.from()};
+      });
+    },
+    delWrappedLineRight: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div");
+        return {from: range.from(), to: rightPos };
+      });
+    },
+    undo: function(cm) {cm.undo();},
+    redo: function(cm) {cm.redo();},
+    undoSelection: function(cm) {cm.undoSelection();},
+    redoSelection: function(cm) {cm.redoSelection();},
+    goDocStart: function(cm) {cm.extendSelection(Pos(cm.firstLine(), 0));},
+    goDocEnd: function(cm) {cm.extendSelection(Pos(cm.lastLine()));},
+    goLineStart: function(cm) {
+      cm.extendSelectionsBy(function(range) { return lineStart(cm, range.head.line); },
+                            {origin: "+move", bias: 1});
+    },
+    goLineStartSmart: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        return lineStartSmart(cm, range.head);
+      }, {origin: "+move", bias: 1});
+    },
+    goLineEnd: function(cm) {
+      cm.extendSelectionsBy(function(range) { return lineEnd(cm, range.head.line); },
+                            {origin: "+move", bias: -1});
+    },
+    goLineRight: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div");
+      }, sel_move);
+    },
+    goLineLeft: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        return cm.coordsChar({left: 0, top: top}, "div");
+      }, sel_move);
+    },
+    goLineLeftSmart: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        var pos = cm.coordsChar({left: 0, top: top}, "div");
+        if (pos.ch < cm.getLine(pos.line).search(/\S/)) return lineStartSmart(cm, range.head);
+        return pos;
+      }, sel_move);
+    },
+    goLineUp: function(cm) {cm.moveV(-1, "line");},
+    goLineDown: function(cm) {cm.moveV(1, "line");},
+    goPageUp: function(cm) {cm.moveV(-1, "page");},
+    goPageDown: function(cm) {cm.moveV(1, "page");},
+    goCharLeft: function(cm) {cm.moveH(-1, "char");},
+    goCharRight: function(cm) {cm.moveH(1, "char");},
+    goColumnLeft: function(cm) {cm.moveH(-1, "column");},
+    goColumnRight: function(cm) {cm.moveH(1, "column");},
+    goWordLeft: function(cm) {cm.moveH(-1, "word");},
+    goGroupRight: function(cm) {cm.moveH(1, "group");},
+    goGroupLeft: function(cm) {cm.moveH(-1, "group");},
+    goWordRight: function(cm) {cm.moveH(1, "word");},
+    delCharBefore: function(cm) {cm.deleteH(-1, "char");},
+    delCharAfter: function(cm) {cm.deleteH(1, "char");},
+    delWordBefore: function(cm) {cm.deleteH(-1, "word");},
+    delWordAfter: function(cm) {cm.deleteH(1, "word");},
+    delGroupBefore: function(cm) {cm.deleteH(-1, "group");},
+    delGroupAfter: function(cm) {cm.deleteH(1, "group");},
+    indentAuto: function(cm) {cm.indentSelection("smart");},
+    indentMore: function(cm) {cm.indentSelection("add");},
+    indentLess: function(cm) {cm.indentSelection("subtract");},
+    insertTab: function(cm) {cm.replaceSelection("\t");},
+    insertSoftTab: function(cm) {
+      var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize;
+      for (var i = 0; i < ranges.length; i++) {
+        var pos = ranges[i].from();
+        var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize);
+        spaces.push(new Array(tabSize - col % tabSize + 1).join(" "));
+      }
+      cm.replaceSelections(spaces);
+    },
+    defaultTab: function(cm) {
+      if (cm.somethingSelected()) cm.indentSelection("add");
+      else cm.execCommand("insertTab");
+    },
+    transposeChars: function(cm) {
+      runInOp(cm, function() {
+        var ranges = cm.listSelections(), newSel = [];
+        for (var i = 0; i < ranges.length; i++) {
+          var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text;
+          if (line) {
+            if (cur.ch == line.length) cur = new Pos(cur.line, cur.ch - 1);
+            if (cur.ch > 0) {
+              cur = new Pos(cur.line, cur.ch + 1);
+              cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
+                              Pos(cur.line, cur.ch - 2), cur, "+transpose");
+            } else if (cur.line > cm.doc.first) {
+              var prev = getLine(cm.doc, cur.line - 1).text;
+              if (prev)
+                cm.replaceRange(line.charAt(0) + "\n" + prev.charAt(prev.length - 1),
+                                Pos(cur.line - 1, prev.length - 1), Pos(cur.line, 1), "+transpose");
+            }
+          }
+          newSel.push(new Range(cur, cur));
+        }
+        cm.setSelections(newSel);
+      });
+    },
+    newlineAndIndent: function(cm) {
+      runInOp(cm, function() {
+        var len = cm.listSelections().length;
+        for (var i = 0; i < len; i++) {
+          var range = cm.listSelections()[i];
+          cm.replaceRange("\n", range.anchor, range.head, "+input");
+          cm.indentLine(range.from().line + 1, null, true);
+          ensureCursorVisible(cm);
+        }
+      });
+    },
+    toggleOverwrite: function(cm) {cm.toggleOverwrite();}
+  };
+
+
+  // STANDARD KEYMAPS
+
+  var keyMap = CodeMirror.keyMap = {};
+
+  keyMap.basic = {
+    "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
+    "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
+    "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
+    "Tab": "defaultTab", "Shift-Tab": "indentAuto",
+    "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
+    "Esc": "singleSelection"
+  };
+  // Note that the save and find-related commands aren't defined by
+  // default. User code or addons can define them. Unknown commands
+  // are simply ignored.
+  keyMap.pcDefault = {
+    "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
+    "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
+    "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
+    "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
+    "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
+    "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
+    "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
+    fallthrough: "basic"
+  };
+  // Very basic readline/emacs-style bindings, which are standard on Mac.
+  keyMap.emacsy = {
+    "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
+    "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
+    "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
+    "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars"
+  };
+  keyMap.macDefault = {
+    "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
+    "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
+    "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
+    "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
+    "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
+    "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
+    "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
+    fallthrough: ["basic", "emacsy"]
+  };
+  keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault;
+
+  // KEYMAP DISPATCH
+
+  function normalizeKeyName(name) {
+    var parts = name.split(/-(?!$)/), name = parts[parts.length - 1];
+    var alt, ctrl, shift, cmd;
+    for (var i = 0; i < parts.length - 1; i++) {
+      var mod = parts[i];
+      if (/^(cmd|meta|m)$/i.test(mod)) cmd = true;
+      else if (/^a(lt)?$/i.test(mod)) alt = true;
+      else if (/^(c|ctrl|control)$/i.test(mod)) ctrl = true;
+      else if (/^s(hift)$/i.test(mod)) shift = true;
+      else throw new Error("Unrecognized modifier name: " + mod);
+    }
+    if (alt) name = "Alt-" + name;
+    if (ctrl) name = "Ctrl-" + name;
+    if (cmd) name = "Cmd-" + name;
+    if (shift) name = "Shift-" + name;
+    return name;
+  }
+
+  // This is a kludge to keep keymaps mostly working as raw objects
+  // (backwards compatibility) while at the same time support features
+  // like normalization and multi-stroke key bindings. It compiles a
+  // new normalized keymap, and then updates the old object to reflect
+  // this.
+  CodeMirror.normalizeKeyMap = function(keymap) {
+    var copy = {};
+    for (var keyname in keymap) if (keymap.hasOwnProperty(keyname)) {
+      var value = keymap[keyname];
+      if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) continue;
+      if (value == "...") { delete keymap[keyname]; continue; }
+
+      var keys = map(keyname.split(" "), normalizeKeyName);
+      for (var i = 0; i < keys.length; i++) {
+        var val, name;
+        if (i == keys.length - 1) {
+          name = keyname;
+          val = value;
+        } else {
+          name = keys.slice(0, i + 1).join(" ");
+          val = "...";
+        }
+        var prev = copy[name];
+        if (!prev) copy[name] = val;
+        else if (prev != val) throw new Error("Inconsistent bindings for " + name);
+      }
+      delete keymap[keyname];
+    }
+    for (var prop in copy) keymap[prop] = copy[prop];
+    return keymap;
+  };
+
+  var lookupKey = CodeMirror.lookupKey = function(key, map, handle, context) {
+    map = getKeyMap(map);
+    var found = map.call ? map.call(key, context) : map[key];
+    if (found === false) return "nothing";
+    if (found === "...") return "multi";
+    if (found != null && handle(found)) return "handled";
+
+    if (map.fallthrough) {
+      if (Object.prototype.toString.call(map.fallthrough) != "[object Array]")
+        return lookupKey(key, map.fallthrough, handle, context);
+      for (var i = 0; i < map.fallthrough.length; i++) {
+        var result = lookupKey(key, map.fallthrough[i], handle, context);
+        if (result) return result;
+      }
+    }
+  };
+
+  // Modifier key presses don't count as 'real' key presses for the
+  // purpose of keymap fallthrough.
+  var isModifierKey = CodeMirror.isModifierKey = function(value) {
+    var name = typeof value == "string" ? value : keyNames[value.keyCode];
+    return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod";
+  };
+
+  // Look up the name of a key as indicated by an event object.
+  var keyName = CodeMirror.keyName = function(event, noShift) {
+    if (presto && event.keyCode == 34 && event["char"]) return false;
+    var base = keyNames[event.keyCode], name = base;
+    if (name == null || event.altGraphKey) return false;
+    if (event.altKey && base != "Alt") name = "Alt-" + name;
+    if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") name = "Ctrl-" + name;
+    if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") name = "Cmd-" + name;
+    if (!noShift && event.shiftKey && base != "Shift") name = "Shift-" + name;
+    return name;
+  };
+
+  function getKeyMap(val) {
+    return typeof val == "string" ? keyMap[val] : val;
+  }
+
+  // FROMTEXTAREA
+
+  CodeMirror.fromTextArea = function(textarea, options) {
+    options = options ? copyObj(options) : {};
+    options.value = textarea.value;
+    if (!options.tabindex && textarea.tabIndex)
+      options.tabindex = textarea.tabIndex;
+    if (!options.placeholder && textarea.placeholder)
+      options.placeholder = textarea.placeholder;
+    // Set autofocus to true if this textarea is focused, or if it has
+    // autofocus and no other element is focused.
+    if (options.autofocus == null) {
+      var hasFocus = activeElt();
+      options.autofocus = hasFocus == textarea ||
+        textarea.getAttribute("autofocus") != null && hasFocus == document.body;
+    }
+
+    function save() {textarea.value = cm.getValue();}
+    if (textarea.form) {
+      on(textarea.form, "submit", save);
+      // Deplorable hack to make the submit method do the right thing.
+      if (!options.leaveSubmitMethodAlone) {
+        var form = textarea.form, realSubmit = form.submit;
+        try {
+          var wrappedSubmit = form.submit = function() {
+            save();
+            form.submit = realSubmit;
+            form.submit();
+            form.submit = wrappedSubmit;
+          };
+        } catch(e) {}
+      }
+    }
+
+    options.finishInit = function(cm) {
+      cm.save = save;
+      cm.getTextArea = function() { return textarea; };
+      cm.toTextArea = function() {
+        cm.toTextArea = isNaN; // Prevent this from being ran twice
+        save();
+        textarea.parentNode.removeChild(cm.getWrapperElement());
+        textarea.style.display = "";
+        if (textarea.form) {
+          off(textarea.form, "submit", save);
+          if (typeof textarea.form.submit == "function")
+            textarea.form.submit = realSubmit;
+        }
+      };
+    };
+
+    textarea.style.display = "none";
+    var cm = CodeMirror(function(node) {
+      textarea.parentNode.insertBefore(node, textarea.nextSibling);
+    }, options);
+    return cm;
+  };
+
+  // STRING STREAM
+
+  // Fed to the mode parsers, provides helper functions to make
+  // parsers more succinct.
+
+  var StringStream = CodeMirror.StringStream = function(string, tabSize) {
+    this.pos = this.start = 0;
+    this.string = string;
+    this.tabSize = tabSize || 8;
+    this.lastColumnPos = this.lastColumnValue = 0;
+    this.lineStart = 0;
+  };
+
+  StringStream.prototype = {
+    eol: function() {return this.pos >= this.string.length;},
+    sol: function() {return this.pos == this.lineStart;},
+    peek: function() {return this.string.charAt(this.pos) || undefined;},
+    next: function() {
+      if (this.pos < this.string.length)
+        return this.string.charAt(this.pos++);
+    },
+    eat: function(match) {
+      var ch = this.string.charAt(this.pos);
+      if (typeof match == "string") var ok = ch == match;
+      else var ok = ch && (match.test ? match.test(ch) : match(ch));
+      if (ok) {++this.pos; return ch;}
+    },
+    eatWhile: function(match) {
+      var start = this.pos;
+      while (this.eat(match)){}
+      return this.pos > start;
+    },
+    eatSpace: function() {
+      var start = this.pos;
+      while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
+      return this.pos > start;
+    },
+    skipToEnd: function() {this.pos = this.string.length;},
+    skipTo: function(ch) {
+      var found = this.string.indexOf(ch, this.pos);
+      if (found > -1) {this.pos = found; return true;}
+    },
+    backUp: function(n) {this.pos -= n;},
+    column: function() {
+      if (this.lastColumnPos < this.start) {
+        this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);
+        this.lastColumnPos = this.start;
+      }
+      return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
+    },
+    indentation: function() {
+      return countColumn(this.string, null, this.tabSize) -
+        (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
+    },
+    match: function(pattern, consume, caseInsensitive) {
+      if (typeof pattern == "string") {
+        var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
+        var substr = this.string.substr(this.pos, pattern.length);
+        if (cased(substr) == cased(pattern)) {
+          if (consume !== false) this.pos += pattern.length;
+          return true;
+        }
+      } else {
+        var match = this.string.slice(this.pos).match(pattern);
+        if (match && match.index > 0) return null;
+        if (match && consume !== false) this.pos += match[0].length;
+        return match;
+      }
+    },
+    current: function(){return this.string.slice(this.start, this.pos);},
+    hideFirstChars: function(n, inner) {
+      this.lineStart += n;
+      try { return inner(); }
+      finally { this.lineStart -= n; }
+    }
+  };
+
+  // TEXTMARKERS
+
+  // Created with markText and setBookmark methods. A TextMarker is a
+  // handle that can be used to clear or find a marked position in the
+  // document. Line objects hold arrays (markedSpans) containing
+  // {from, to, marker} object pointing to such marker objects, and
+  // indicating that such a marker is present on that line. Multiple
+  // lines may point to the same marker when it spans across lines.
+  // The spans will have null for their from/to properties when the
+  // marker continues beyond the start/end of the line. Markers have
+  // links back to the lines they currently touch.
+
+  var nextMarkerId = 0;
+
+  var TextMarker = CodeMirror.TextMarker = function(doc, type) {
+    this.lines = [];
+    this.type = type;
+    this.doc = doc;
+    this.id = ++nextMarkerId;
+  };
+  eventMixin(TextMarker);
+
+  // Clear the marker.
+  TextMarker.prototype.clear = function() {
+    if (this.explicitlyCleared) return;
+    var cm = this.doc.cm, withOp = cm && !cm.curOp;
+    if (withOp) startOperation(cm);
+    if (hasHandler(this, "clear")) {
+      var found = this.find();
+      if (found) signalLater(this, "clear", found.from, found.to);
+    }
+    var min = null, max = null;
+    for (var i = 0; i < this.lines.length; ++i) {
+      var line = this.lines[i];
+      var span = getMarkedSpanFor(line.markedSpans, this);
+      if (cm && !this.collapsed) regLineChange(cm, lineNo(line), "text");
+      else if (cm) {
+        if (span.to != null) max = lineNo(line);
+        if (span.from != null) min = lineNo(line);
+      }
+      line.markedSpans = removeMarkedSpan(line.markedSpans, span);
+      if (span.from == null && this.collapsed && !lineIsHidden(this.doc, line) && cm)
+        updateLineHeight(line, textHeight(cm.display));
+    }
+    if (cm && this.collapsed && !cm.options.lineWrapping) for (var i = 0; i < this.lines.length; ++i) {
+      var visual = visualLine(this.lines[i]), len = lineLength(visual);
+      if (len > cm.display.maxLineLength) {
+        cm.display.maxLine = visual;
+        cm.display.maxLineLength = len;
+        cm.display.maxLineChanged = true;
+      }
+    }
+
+    if (min != null && cm && this.collapsed) regChange(cm, min, max + 1);
+    this.lines.length = 0;
+    this.explicitlyCleared = true;
+    if (this.atomic && this.doc.cantEdit) {
+      this.doc.cantEdit = false;
+      if (cm) reCheckSelection(cm.doc);
+    }
+    if (cm) signalLater(cm, "markerCleared", cm, this);
+    if (withOp) endOperation(cm);
+    if (this.parent) this.parent.clear();
+  };
+
+  // Find the position of the marker in the document. Returns a {from,
+  // to} object by default. Side can be passed to get a specific side
+  // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
+  // Pos objects returned contain a line object, rather than a line
+  // number (used to prevent looking up the same line twice).
+  TextMarker.prototype.find = function(side, lineObj) {
+    if (side == null && this.type == "bookmark") side = 1;
+    var from, to;
+    for (var i = 0; i < this.lines.length; ++i) {
+      var line = this.lines[i];
+      var span = getMarkedSpanFor(line.markedSpans, this);
+      if (span.from != null) {
+        from = Pos(lineObj ? line : lineNo(line), span.from);
+        if (side == -1) return from;
+      }
+      if (span.to != null) {
+        to = Pos(lineObj ? line : lineNo(line), span.to);
+        if (side == 1) return to;
+      }
+    }
+    return from && {from: from, to: to};
+  };
+
+  // Signals that the marker's widget changed, and surrounding layout
+  // should be recomputed.
+  TextMarker.prototype.changed = function() {
+    var pos = this.find(-1, true), widget = this, cm = this.doc.cm;
+    if (!pos || !cm) return;
+    runInOp(cm, function() {
+      var line = pos.line, lineN = lineNo(pos.line);
+      var view = findViewForLine(cm, lineN);
+      if (view) {
+        clearLineMeasurementCacheFor(view);
+        cm.curOp.selectionChanged = cm.curOp.forceUpdate = true;
+      }
+      cm.curOp.updateMaxLine = true;
+      if (!lineIsHidden(widget.doc, line) && widget.height != null) {
+        var oldHeight = widget.height;
+        widget.height = null;
+        var dHeight = widgetHeight(widget) - oldHeight;
+        if (dHeight)
+          updateLineHeight(line, line.height + dHeight);
+      }
+    });
+  };
+
+  TextMarker.prototype.attachLine = function(line) {
+    if (!this.lines.length && this.doc.cm) {
+      var op = this.doc.cm.curOp;
+      if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
+        (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this);
+    }
+    this.lines.push(line);
+  };
+  TextMarker.prototype.detachLine = function(line) {
+    this.lines.splice(indexOf(this.lines, line), 1);
+    if (!this.lines.length && this.doc.cm) {
+      var op = this.doc.cm.curOp;
+      (op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this);
+    }
+  };
+
+  // Collapsed markers have unique ids, in order to be able to order
+  // them, which is needed for uniquely determining an outer marker
+  // when they overlap (they may nest, but not partially overlap).
+  var nextMarkerId = 0;
+
+  // Create a marker, wire it up to the right lines, and
+  function markText(doc, from, to, options, type) {
+    // Shared markers (across linked documents) are handled separately
+    // (markTextShared will call out to this again, once per
+    // document).
+    if (options && options.shared) return markTextShared(doc, from, to, options, type);
+    // Ensure we are in an operation.
+    if (doc.cm && !doc.cm.curOp) return operation(doc.cm, markText)(doc, from, to, options, type);
+
+    var marker = new TextMarker(doc, type), diff = cmp(from, to);
+    if (options) copyObj(options, marker, false);
+    // Don't connect empty markers unless clearWhenEmpty is false
+    if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)
+      return marker;
+    if (marker.replacedWith) {
+      // Showing up as a widget implies collapsed (widget replaces text)
+      marker.collapsed = true;
+      marker.widgetNode = elt("span", [marker.replacedWith], "CodeMirror-widget");
+      if (!options.handleMouseEvents) marker.widgetNode.setAttribute("cm-ignore-events", "true");
+      if (options.insertLeft) marker.widgetNode.insertLeft = true;
+    }
+    if (marker.collapsed) {
+      if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||
+          from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))
+        throw new Error("Inserting collapsed marker partially overlapping an existing one");
+      sawCollapsedSpans = true;
+    }
+
+    if (marker.addToHistory)
+      addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN);
+
+    var curLine = from.line, cm = doc.cm, updateMaxLine;
+    doc.iter(curLine, to.line + 1, function(line) {
+      if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)
+        updateMaxLine = true;
+      if (marker.collapsed && curLine != from.line) updateLineHeight(line, 0);
+      addMarkedSpan(line, new MarkedSpan(marker,
+                                         curLine == from.line ? from.ch : null,
+                                         curLine == to.line ? to.ch : null));
+      ++curLine;
+    });
+    // lineIsHidden depends on the presence of the spans, so needs a second pass
+    if (marker.collapsed) doc.iter(from.line, to.line + 1, function(line) {
+      if (lineIsHidden(doc, line)) updateLineHeight(line, 0);
+    });
+
+    if (marker.clearOnEnter) on(marker, "beforeCursorEnter", function() { marker.clear(); });
+
+    if (marker.readOnly) {
+      sawReadOnlySpans = true;
+      if (doc.history.done.length || doc.history.undone.length)
+        doc.clearHistory();
+    }
+    if (marker.collapsed) {
+      marker.id = ++nextMarkerId;
+      marker.atomic = true;
+    }
+    if (cm) {
+      // Sync editor state
+      if (updateMaxLine) cm.curOp.updateMaxLine = true;
+      if (marker.collapsed)
+        regChange(cm, from.line, to.line + 1);
+      else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)
+        for (var i = from.line; i <= to.line; i++) regLineChange(cm, i, "text");
+      if (marker.atomic) reCheckSelection(cm.doc);
+      signalLater(cm, "markerAdded", cm, marker);
+    }
+    return marker;
+  }
+
+  // SHARED TEXTMARKERS
+
+  // A shared marker spans multiple linked documents. It is
+  // implemented as a meta-marker-object controlling multiple normal
+  // markers.
+  var SharedTextMarker = CodeMirror.SharedTextMarker = function(markers, primary) {
+    this.markers = markers;
+    this.primary = primary;
+    for (var i = 0; i < markers.length; ++i)
+      markers[i].parent = this;
+  };
+  eventMixin(SharedTextMarker);
+
+  SharedTextMarker.prototype.clear = function() {
+    if (this.explicitlyCleared) return;
+    this.explicitlyCleared = true;
+    for (var i = 0; i < this.markers.length; ++i)
+      this.markers[i].clear();
+    signalLater(this, "clear");
+  };
+  SharedTextMarker.prototype.find = function(side, lineObj) {
+    return this.primary.find(side, lineObj);
+  };
+
+  function markTextShared(doc, from, to, options, type) {
+    options = copyObj(options);
+    options.shared = false;
+    var markers = [markText(doc, from, to, options, type)], primary = markers[0];
+    var widget = options.widgetNode;
+    linkedDocs(doc, function(doc) {
+      if (widget) options.widgetNode = widget.cloneNode(true);
+      markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type));
+      for (var i = 0; i < doc.linked.length; ++i)
+        if (doc.linked[i].isParent) return;
+      primary = lst(markers);
+    });
+    return new SharedTextMarker(markers, primary);
+  }
+
+  function findSharedMarkers(doc) {
+    return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())),
+                         function(m) { return m.parent; });
+  }
+
+  function copySharedMarkers(doc, markers) {
+    for (var i = 0; i < markers.length; i++) {
+      var marker = markers[i], pos = marker.find();
+      var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to);
+      if (cmp(mFrom, mTo)) {
+        var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type);
+        marker.markers.push(subMark);
+        subMark.parent = marker;
+      }
+    }
+  }
+
+  function detachSharedMarkers(markers) {
+    for (var i = 0; i < markers.length; i++) {
+      var marker = markers[i], linked = [marker.primary.doc];;
+      linkedDocs(marker.primary.doc, function(d) { linked.push(d); });
+      for (var j = 0; j < marker.markers.length; j++) {
+        var subMarker = marker.markers[j];
+        if (indexOf(linked, subMarker.doc) == -1) {
+          subMarker.parent = null;
+          marker.markers.splice(j--, 1);
+        }
+      }
+    }
+  }
+
+  // TEXTMARKER SPANS
+
+  function MarkedSpan(marker, from, to) {
+    this.marker = marker;
+    this.from = from; this.to = to;
+  }
+
+  // Search an array of spans for a span matching the given marker.
+  function getMarkedSpanFor(spans, marker) {
+    if (spans) for (var i = 0; i < spans.length; ++i) {
+      var span = spans[i];
+      if (span.marker == marker) return span;
+    }
+  }
+  // Remove a span from an array, returning undefined if no spans are
+  // left (we don't store arrays for lines without spans).
+  function removeMarkedSpan(spans, span) {
+    for (var r, i = 0; i < spans.length; ++i)
+      if (spans[i] != span) (r || (r = [])).push(spans[i]);
+    return r;
+  }
+  // Add a span to a line.
+  function addMarkedSpan(line, span) {
+    line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span];
+    span.marker.attachLine(line);
+  }
+
+  // Used for the algorithm that adjusts markers for a change in the
+  // document. These functions cut an array of spans at a given
+  // character position, returning an array of remaining chunks (or
+  // undefined if nothing remains).
+  function markedSpansBefore(old, startCh, isInsert) {
+    if (old) for (var i = 0, nw; i < old.length; ++i) {
+      var span = old[i], marker = span.marker;
+      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh);
+      if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
+        var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh);
+        (nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to));
+      }
+    }
+    return nw;
+  }
+  function markedSpansAfter(old, endCh, isInsert) {
+    if (old) for (var i = 0, nw; i < old.length; ++i) {
+      var span = old[i], marker = span.marker;
+      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh);
+      if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
+        var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh);
+        (nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
+                                              span.to == null ? null : span.to - endCh));
+      }
+    }
+    return nw;
+  }
+
+  // Given a change object, compute the new set of marker spans that
+  // cover the line in which the change took place. Removes spans
+  // entirely within the change, reconnects spans belonging to the
+  // same marker that appear on both sides of the change, and cuts off
+  // spans partially within the change. Returns an array of span
+  // arrays with one element for each line in (after) the change.
+  function stretchSpansOverChange(doc, change) {
+    if (change.full) return null;
+    var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans;
+    var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans;
+    if (!oldFirst && !oldLast) return null;
+
+    var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0;
+    // Get the spans that 'stick out' on both sides
+    var first = markedSpansBefore(oldFirst, startCh, isInsert);
+    var last = markedSpansAfter(oldLast, endCh, isInsert);
+
+    // Next, merge those two ends
+    var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0);
+    if (first) {
+      // Fix up .to properties of first
+      for (var i = 0; i < first.length; ++i) {
+        var span = first[i];
+        if (span.to == null) {
+          var found = getMarkedSpanFor(last, span.marker);
+          if (!found) span.to = startCh;
+          else if (sameLine) span.to = found.to == null ? null : found.to + offset;
+        }
+      }
+    }
+    if (last) {
+      // Fix up .from in last (or move them into first in case of sameLine)
+      for (var i = 0; i < last.length; ++i) {
+        var span = last[i];
+        if (span.to != null) span.to += offset;
+        if (span.from == null) {
+          var found = getMarkedSpanFor(first, span.marker);
+          if (!found) {
+            span.from = offset;
+            if (sameLine) (first || (first = [])).push(span);
+          }
+        } else {
+          span.from += offset;
+          if (sameLine) (first || (first = [])).push(span);
+        }
+      }
+    }
+    // Make sure we didn't create any zero-length spans
+    if (first) first = clearEmptySpans(first);
+    if (last && last != first) last = clearEmptySpans(last);
+
+    var newMarkers = [first];
+    if (!sameLine) {
+      // Fill gap with whole-line-spans
+      var gap = change.text.length - 2, gapMarkers;
+      if (gap > 0 && first)
+        for (var i = 0; i < first.length; ++i)
+          if (first[i].to == null)
+            (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i].marker, null, null));
+      for (var i = 0; i < gap; ++i)
+        newMarkers.push(gapMarkers);
+      newMarkers.push(last);
+    }
+    return newMarkers;
+  }
+
+  // Remove spans that are empty and don't have a clearWhenEmpty
+  // option of false.
+  function clearEmptySpans(spans) {
+    for (var i = 0; i < spans.length; ++i) {
+      var span = spans[i];
+      if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
+        spans.splice(i--, 1);
+    }
+    if (!spans.length) return null;
+    return spans;
+  }
+
+  // Used for un/re-doing changes from the history. Combines the
+  // result of computing the existing spans with the set of spans that
+  // existed in the history (so that deleting around a span and then
+  // undoing brings back the span).
+  function mergeOldSpans(doc, change) {
+    var old = getOldSpans(doc, change);
+    var stretched = stretchSpansOverChange(doc, change);
+    if (!old) return stretched;
+    if (!stretched) return old;
+
+    for (var i = 0; i < old.length; ++i) {
+      var oldCur = old[i], stretchCur = stretched[i];
+      if (oldCur && stretchCur) {
+        spans: for (var j = 0; j < stretchCur.length; ++j) {
+          var span = stretchCur[j];
+          for (var k = 0; k < oldCur.length; ++k)
+            if (oldCur[k].marker == span.marker) continue spans;
+          oldCur.push(span);
+        }
+      } else if (stretchCur) {
+        old[i] = stretchCur;
+      }
+    }
+    return old;
+  }
+
+  // Used to 'clip' out readOnly ranges when making a change.
+  function removeReadOnlyRanges(doc, from, to) {
+    var markers = null;
+    doc.iter(from.line, to.line + 1, function(line) {
+      if (line.markedSpans) for (var i = 0; i < line.markedSpans.length; ++i) {
+        var mark = line.markedSpans[i].marker;
+        if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
+          (markers || (markers = [])).push(mark);
+      }
+    });
+    if (!markers) return null;
+    var parts = [{from: from, to: to}];
+    for (var i = 0; i < markers.length; ++i) {
+      var mk = markers[i], m = mk.find(0);
+      for (var j = 0; j < parts.length; ++j) {
+        var p = parts[j];
+        if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) continue;
+        var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to);
+        if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
+          newParts.push({from: p.from, to: m.from});
+        if (dto > 0 || !mk.inclusiveRight && !dto)
+          newParts.push({from: m.to, to: p.to});
+        parts.splice.apply(parts, newParts);
+        j += newParts.length - 1;
+      }
+    }
+    return parts;
+  }
+
+  // Connect or disconnect spans from a line.
+  function detachMarkedSpans(line) {
+    var spans = line.markedSpans;
+    if (!spans) return;
+    for (var i = 0; i < spans.length; ++i)
+      spans[i].marker.detachLine(line);
+    line.markedSpans = null;
+  }
+  function attachMarkedSpans(line, spans) {
+    if (!spans) return;
+    for (var i = 0; i < spans.length; ++i)
+      spans[i].marker.attachLine(line);
+    line.markedSpans = spans;
+  }
+
+  // Helpers used when computing which overlapping collapsed span
+  // counts as the larger one.
+  function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0; }
+  function extraRight(marker) { return marker.inclusiveRight ? 1 : 0; }
+
+  // Returns a number indicating which of two overlapping collapsed
+  // spans is larger (and thus includes the other). Falls back to
+  // comparing ids when the spans cover exactly the same range.
+  function compareCollapsedMarkers(a, b) {
+    var lenDiff = a.lines.length - b.lines.length;
+    if (lenDiff != 0) return lenDiff;
+    var aPos = a.find(), bPos = b.find();
+    var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);
+    if (fromCmp) return -fromCmp;
+    var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);
+    if (toCmp) return toCmp;
+    return b.id - a.id;
+  }
+
+  // Find out whether a line ends or starts in a collapsed span. If
+  // so, return the marker for that span.
+  function collapsedSpanAtSide(line, start) {
+    var sps = sawCollapsedSpans && line.markedSpans, found;
+    if (sps) for (var sp, i = 0; i < sps.length; ++i) {
+      sp = sps[i];
+      if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
+          (!found || compareCollapsedMarkers(found, sp.marker) < 0))
+        found = sp.marker;
+    }
+    return found;
+  }
+  function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true); }
+  function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false); }
+
+  // Test whether there exists a collapsed span that partially
+  // overlaps (covers the start or end, but not both) of a new span.
+  // Such overlap is not allowed.
+  function conflictingCollapsedRange(doc, lineNo, from, to, marker) {
+    var line = getLine(doc, lineNo);
+    var sps = sawCollapsedSpans && line.markedSpans;
+    if (sps) for (var i = 0; i < sps.length; ++i) {
+      var sp = sps[i];
+      if (!sp.marker.collapsed) continue;
+      var found = sp.marker.find(0);
+      var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker);
+      var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker);
+      if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) continue;
+      if (fromCmp <= 0 && (cmp(found.to, from) > 0 || (sp.marker.inclusiveRight && marker.inclusiveLeft)) ||
+          fromCmp >= 0 && (cmp(found.from, to) < 0 || (sp.marker.inclusiveLeft && marker.inclusiveRight)))
+        return true;
+    }
+  }
+
+  // A visual line is a line as drawn on the screen. Folding, for
+  // example, can cause multiple logical lines to appear on the same
+  // visual line. This finds the start of the visual line that the
+  // given line is part of (usually that is the line itself).
+  function visualLine(line) {
+    var merged;
+    while (merged = collapsedSpanAtStart(line))
+      line = merged.find(-1, true).line;
+    return line;
+  }
+
+  // Returns an array of logical lines that continue the visual line
+  // started by the argument, or undefined if there are no such lines.
+  function visualLineContinued(line) {
+    var merged, lines;
+    while (merged = collapsedSpanAtEnd(line)) {
+      line = merged.find(1, true).line;
+      (lines || (lines = [])).push(line);
+    }
+    return lines;
+  }
+
+  // Get the line number of the start of the visual line that the
+  // given line number is part of.
+  function visualLineNo(doc, lineN) {
+    var line = getLine(doc, lineN), vis = visualLine(line);
+    if (line == vis) return lineN;
+    return lineNo(vis);
+  }
+  // Get the line number of the start of the next visual line after
+  // the given line.
+  function visualLineEndNo(doc, lineN) {
+    if (lineN > doc.lastLine()) return lineN;
+    var line = getLine(doc, lineN), merged;
+    if (!lineIsHidden(doc, line)) return lineN;
+    while (merged = collapsedSpanAtEnd(line))
+      line = merged.find(1, true).line;
+    return lineNo(line) + 1;
+  }
+
+  // Compute whether a line is hidden. Lines count as hidden when they
+  // are part of a visual line that starts with another line, or when
+  // they are entirely covered by collapsed, non-widget span.
+  function lineIsHidden(doc, line) {
+    var sps = sawCollapsedSpans && line.markedSpans;
+    if (sps) for (var sp, i = 0; i < sps.length; ++i) {
+      sp = sps[i];
+      if (!sp.marker.collapsed) continue;
+      if (sp.from == null) return true;
+      if (sp.marker.widgetNode) continue;
+      if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
+        return true;
+    }
+  }
+  function lineIsHiddenInner(doc, line, span) {
+    if (span.to == null) {
+      var end = span.marker.find(1, true);
+      return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker));
+    }
+    if (span.marker.inclusiveRight && span.to == line.text.length)
+      return true;
+    for (var sp, i = 0; i < line.markedSpans.length; ++i) {
+      sp = line.markedSpans[i];
+      if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
+          (sp.to == null || sp.to != span.from) &&
+          (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
+          lineIsHiddenInner(doc, line, sp)) return true;
+    }
+  }
+
+  // LINE WIDGETS
+
+  // Line widgets are block elements displayed above or below a line.
+
+  var LineWidget = CodeMirror.LineWidget = function(cm, node, options) {
+    if (options) for (var opt in options) if (options.hasOwnProperty(opt))
+      this[opt] = options[opt];
+    this.cm = cm;
+    this.node = node;
+  };
+  eventMixin(LineWidget);
+
+  function adjustScrollWhenAboveVisible(cm, line, diff) {
+    if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
+      addToScrollPos(cm, null, diff);
+  }
+
+  LineWidget.prototype.clear = function() {
+    var cm = this.cm, ws = this.line.widgets, line = this.line, no = lineNo(line);
+    if (no == null || !ws) return;
+    for (var i = 0; i < ws.length; ++i) if (ws[i] == this) ws.splice(i--, 1);
+    if (!ws.length) line.widgets = null;
+    var height = widgetHeight(this);
+    runInOp(cm, function() {
+      adjustScrollWhenAboveVisible(cm, line, -height);
+      regLineChange(cm, no, "widget");
+      updateLineHeight(line, Math.max(0, line.height - height));
+    });
+  };
+  LineWidget.prototype.changed = function() {
+    var oldH = this.height, cm = this.cm, line = this.line;
+    this.height = null;
+    var diff = widgetHeight(this) - oldH;
+    if (!diff) return;
+    runInOp(cm, function() {
+      cm.curOp.forceUpdate = true;
+      adjustScrollWhenAboveVisible(cm, line, diff);
+      updateLineHeight(line, line.height + diff);
+    });
+  };
+
+  function widgetHeight(widget) {
+    if (widget.height != null) return widget.height;
+    if (!contains(document.body, widget.node)) {
+      var parentStyle = "position: relative;";
+      if (widget.coverGutter)
+        parentStyle += "margin-left: -" + widget.cm.display.gutters.offsetWidth + "px;";
+      if (widget.noHScroll)
+        parentStyle += "width: " + widget.cm.display.wrapper.clientWidth + "px;";
+      removeChildrenAndAdd(widget.cm.display.measure, elt("div", [widget.node], null, parentStyle));
+    }
+    return widget.height = widget.node.offsetHeight;
+  }
+
+  function addLineWidget(cm, handle, node, options) {
+    var widget = new LineWidget(cm, node, options);
+    if (widget.noHScroll) cm.display.alignWidgets = true;
+    changeLine(cm.doc, handle, "widget", function(line) {
+      var widgets = line.widgets || (line.widgets = []);
+      if (widget.insertAt == null) widgets.push(widget);
+      else widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget);
+      widget.line = line;
+      if (!lineIsHidden(cm.doc, line)) {
+        var aboveVisible = heightAtLine(line) < cm.doc.scrollTop;
+        updateLineHeight(line, line.height + widgetHeight(widget));
+        if (aboveVisible) addToScrollPos(cm, null, widget.height);
+        cm.curOp.forceUpdate = true;
+      }
+      return true;
+    });
+    return widget;
+  }
+
+  // LINE DATA STRUCTURE
+
+  // Line objects. These hold state related to a line, including
+  // highlighting info (the styles array).
+  var Line = CodeMirror.Line = function(text, markedSpans, estimateHeight) {
+    this.text = text;
+    attachMarkedSpans(this, markedSpans);
+    this.height = estimateHeight ? estimateHeight(this) : 1;
+  };
+  eventMixin(Line);
+  Line.prototype.lineNo = function() { return lineNo(this); };
+
+  // Change the content (text, markers) of a line. Automatically
+  // invalidates cached information and tries to re-estimate the
+  // line's height.
+  function updateLine(line, text, markedSpans, estimateHeight) {
+    line.text = text;
+    if (line.stateAfter) line.stateAfter = null;
+    if (line.styles) line.styles = null;
+    if (line.order != null) line.order = null;
+    detachMarkedSpans(line);
+    attachMarkedSpans(line, markedSpans);
+    var estHeight = estimateHeight ? estimateHeight(line) : 1;
+    if (estHeight != line.height) updateLineHeight(line, estHeight);
+  }
+
+  // Detach a line from the document tree and its markers.
+  function cleanUpLine(line) {
+    line.parent = null;
+    detachMarkedSpans(line);
+  }
+
+  function extractLineClasses(type, output) {
+    if (type) for (;;) {
+      var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/);
+      if (!lineClass) break;
+      type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length);
+      var prop = lineClass[1] ? "bgClass" : "textClass";
+      if (output[prop] == null)
+        output[prop] = lineClass[2];
+      else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
+        output[prop] += " " + lineClass[2];
+    }
+    return type;
+  }
+
+  function callBlankLine(mode, state) {
+    if (mode.blankLine) return mode.blankLine(state);
+    if (!mode.innerMode) return;
+    var inner = CodeMirror.innerMode(mode, state);
+    if (inner.mode.blankLine) return inner.mode.blankLine(inner.state);
+  }
+
+  function readToken(mode, stream, state, inner) {
+    for (var i = 0; i < 10; i++) {
+      if (inner) inner[0] = CodeMirror.innerMode(mode, state).mode;
+      var style = mode.token(stream, state);
+      if (stream.pos > stream.start) return style;
+    }
+    throw new Error("Mode " + mode.name + " failed to advance stream.");
+  }
+
+  // Utility for getTokenAt and getLineTokens
+  function takeToken(cm, pos, precise, asArray) {
+    function getObj(copy) {
+      return {start: stream.start, end: stream.pos,
+              string: stream.current(),
+              type: style || null,
+              state: copy ? copyState(doc.mode, state) : state};
+    }
+
+    var doc = cm.doc, mode = doc.mode, style;
+    pos = clipPos(doc, pos);
+    var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise);
+    var stream = new StringStream(line.text, cm.options.tabSize), tokens;
+    if (asArray) tokens = [];
+    while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
+      stream.start = stream.pos;
+      style = readToken(mode, stream, state);
+      if (asArray) tokens.push(getObj(true));
+    }
+    return asArray ? tokens : getObj();
+  }
+
+  // Run the given mode's parser over a line, calling f for each token.
+  function runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {
+    var flattenSpans = mode.flattenSpans;
+    if (flattenSpans == null) flattenSpans = cm.options.flattenSpans;
+    var curStart = 0, curStyle = null;
+    var stream = new StringStream(text, cm.options.tabSize), style;
+    var inner = cm.options.addModeClass && [null];
+    if (text == "") extractLineClasses(callBlankLine(mode, state), lineClasses);
+    while (!stream.eol()) {
+      if (stream.pos > cm.options.maxHighlightLength) {
+        flattenSpans = false;
+        if (forceToEnd) processLine(cm, text, state, stream.pos);
+        stream.pos = text.length;
+        style = null;
+      } else {
+        style = extractLineClasses(readToken(mode, stream, state, inner), lineClasses);
+      }
+      if (inner) {
+        var mName = inner[0].name;
+        if (mName) style = "m-" + (style ? mName + " " + style : mName);
+      }
+      if (!flattenSpans || curStyle != style) {
+        while (curStart < stream.start) {
+          curStart = Math.min(stream.start, curStart + 50000);
+          f(curStart, curStyle);
+        }
+        curStyle = style;
+      }
+      stream.start = stream.pos;
+    }
+    while (curStart < stream.pos) {
+      // Webkit seems to refuse to render text nodes longer than 57444 characters
+      var pos = Math.min(stream.pos, curStart + 50000);
+      f(pos, curStyle);
+      curStart = pos;
+    }
+  }
+
+  // Compute a style array (an array starting with a mode generation
+  // -- for invalidation -- followed by pairs of end positions and
+  // style strings), which is used to highlight the tokens on the
+  // line.
+  function highlightLine(cm, line, state, forceToEnd) {
+    // A styles array always starts with a number identifying the
+    // mode/overlays that it is based on (for easy invalidation).
+    var st = [cm.state.modeGen], lineClasses = {};
+    // Compute the base array of styles
+    runMode(cm, line.text, cm.doc.mode, state, function(end, style) {
+      st.push(end, style);
+    }, lineClasses, forceToEnd);
+
+    // Run overlays, adjust style array.
+    for (var o = 0; o < cm.state.overlays.length; ++o) {
+      var overlay = cm.state.overlays[o], i = 1, at = 0;
+      runMode(cm, line.text, overlay.mode, true, function(end, style) {
+        var start = i;
+        // Ensure there's a token end at the current position, and that i points at it
+        while (at < end) {
+          var i_end = st[i];
+          if (i_end > end)
+            st.splice(i, 1, end, st[i+1], i_end);
+          i += 2;
+          at = Math.min(end, i_end);
+        }
+        if (!style) return;
+        if (overlay.opaque) {
+          st.splice(start, i - start, end, "cm-overlay " + style);
+          i = start + 2;
+        } else {
+          for (; start < i; start += 2) {
+            var cur = st[start+1];
+            st[start+1] = (cur ? cur + " " : "") + "cm-overlay " + style;
+          }
+        }
+      }, lineClasses);
+    }
+
+    return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null};
+  }
+
+  function getLineStyles(cm, line, updateFrontier) {
+    if (!line.styles || line.styles[0] != cm.state.modeGen) {
+      var result = highlightLine(cm, line, line.stateAfter = getStateBefore(cm, lineNo(line)));
+      line.styles = result.styles;
+      if (result.classes) line.styleClasses = result.classes;
+      else if (line.styleClasses) line.styleClasses = null;
+      if (updateFrontier === cm.doc.frontier) cm.doc.frontier++;
+    }
+    return line.styles;
+  }
+
+  // Lightweight form of highlight -- proceed over this line and
+  // update state, but don't save a style array. Used for lines that
+  // aren't currently visible.
+  function processLine(cm, text, state, startAt) {
+    var mode = cm.doc.mode;
+    var stream = new StringStream(text, cm.options.tabSize);
+    stream.start = stream.pos = startAt || 0;
+    if (text == "") callBlankLine(mode, state);
+    while (!stream.eol() && stream.pos <= cm.options.maxHighlightLength) {
+      readToken(mode, stream, state);
+      stream.start = stream.pos;
+    }
+  }
+
+  // Convert a style as returned by a mode (either null, or a string
+  // containing one or more styles) to a CSS style. This is cached,
+  // and also looks for line-wide styles.
+  var styleToClassCache = {}, styleToClassCacheWithMode = {};
+  function interpretTokenStyle(style, options) {
+    if (!style || /^\s*$/.test(style)) return null;
+    var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache;
+    return cache[style] ||
+      (cache[style] = style.replace(/\S+/g, "cm-$&"));
+  }
+
+  // Render the DOM representation of the text of a line. Also builds
+  // up a 'line map', which points at the DOM nodes that represent
+  // specific stretches of text, and is used by the measuring code.
+  // The returned object contains the DOM node, this map, and
+  // information about line-wide styles that were set by the mode.
+  function buildLineContent(cm, lineView) {
+    // The padding-right forces the element to have a 'border', which
+    // is needed on Webkit to be able to get line-level bounding
+    // rectangles for it (in measureChar).
+    var content = elt("span", null, null, webkit ? "padding-right: .1px" : null);
+    var builder = {pre: elt("pre", [content]), content: content, col: 0, pos: 0, cm: cm};
+    lineView.measure = {};
+
+    // Iterate over the logical lines that make up this visual line.
+    for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
+      var line = i ? lineView.rest[i - 1] : lineView.line, order;
+      builder.pos = 0;
+      builder.addToken = buildToken;
+      // Optionally wire in some hacks into the token-rendering
+      // algorithm, to deal with browser quirks.
+      if ((ie || webkit) && cm.getOption("lineWrapping"))
+        builder.addToken = buildTokenSplitSpaces(builder.addToken);
+      if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))
+        builder.addToken = buildTokenBadBidi(builder.addToken, order);
+      builder.map = [];
+      var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);
+      insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));
+      if (line.styleClasses) {
+        if (line.styleClasses.bgClass)
+          builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "");
+        if (line.styleClasses.textClass)
+          builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "");
+      }
+
+      // Ensure at least a single node is present, for measuring.
+      if (builder.map.length == 0)
+        builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure)));
+
+      // Store the map and a cache object for the current logical line
+      if (i == 0) {
+        lineView.measure.map = builder.map;
+        lineView.measure.cache = {};
+      } else {
+        (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map);
+        (lineView.measure.caches || (lineView.measure.caches = [])).push({});
+      }
+    }
+
+    // See issue #2901
+    if (webkit && /\bcm-tab\b/.test(builder.content.lastChild.className))
+      builder.content.className = "cm-tab-wrap-hack";
+
+    signal(cm, "renderLine", cm, lineView.line, builder.pre);
+    if (builder.pre.className)
+      builder.textClass = joinClasses(builder.pre.className, builder.textClass || "");
+
+    return builder;
+  }
+
+  function defaultSpecialCharPlaceholder(ch) {
+    var token = elt("span", "\u2022", "cm-invalidchar");
+    token.title = "\\u" + ch.charCodeAt(0).toString(16);
+    token.setAttribute("aria-label", token.title);
+    return token;
+  }
+
+  // Build up the DOM representation for a single token, and add it to
+  // the line map. Takes care to render special characters separately.
+  function buildToken(builder, text, style, startStyle, endStyle, title, css) {
+    if (!text) return;
+    var special = builder.cm.options.specialChars, mustWrap = false;
+    if (!special.test(text)) {
+      builder.col += text.length;
+      var content = document.createTextNode(text);
+      builder.map.push(builder.pos, builder.pos + text.length, content);
+      if (ie && ie_version < 9) mustWrap = true;
+      builder.pos += text.length;
+    } else {
+      var content = document.createDocumentFragment(), pos = 0;
+      while (true) {
+        special.lastIndex = pos;
+        var m = special.exec(text);
+        var skipped = m ? m.index - pos : text.length - pos;
+        if (skipped) {
+          var txt = document.createTextNode(text.slice(pos, pos + skipped));
+          if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
+          else content.appendChild(txt);
+          builder.map.push(builder.pos, builder.pos + skipped, txt);
+          builder.col += skipped;
+          builder.pos += skipped;
+        }
+        if (!m) break;
+        pos += skipped + 1;
+        if (m[0] == "\t") {
+          var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize;
+          var txt = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"));
+          txt.setAttribute("role", "presentation");
+          txt.setAttribute("cm-text", "\t");
+          builder.col += tabWidth;
+        } else {
+          var txt = builder.cm.options.specialCharPlaceholder(m[0]);
+          txt.setAttribute("cm-text", m[0]);
+          if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
+          else content.appendChild(txt);
+          builder.col += 1;
+        }
+        builder.map.push(builder.pos, builder.pos + 1, txt);
+        builder.pos++;
+      }
+    }
+    if (style || startStyle || endStyle || mustWrap || css) {
+      var fullStyle = style || "";
+      if (startStyle) fullStyle += startStyle;
+      if (endStyle) fullStyle += endStyle;
+      var token = elt("span", [content], fullStyle, css);
+      if (title) token.title = title;
+      return builder.content.appendChild(token);
+    }
+    builder.content.appendChild(content);
+  }
+
+  function buildTokenSplitSpaces(inner) {
+    function split(old) {
+      var out = " ";
+      for (var i = 0; i < old.length - 2; ++i) out += i % 2 ? " " : "\u00a0";
+      out += " ";
+      return out;
+    }
+    return function(builder, text, style, startStyle, endStyle, title) {
+      inner(builder, text.replace(/ {3,}/g, split), style, startStyle, endStyle, title);
+    };
+  }
+
+  // Work around nonsense dimensions being reported for stretches of
+  // right-to-left text.
+  function buildTokenBadBidi(inner, order) {
+    return function(builder, text, style, startStyle, endStyle, title) {
+      style = style ? style + " cm-force-border" : "cm-force-border";
+      var start = builder.pos, end = start + text.length;
+      for (;;) {
+        // Find the part that overlaps with the start of this text
+        for (var i = 0; i < order.length; i++) {
+          var part = order[i];
+          if (part.to > start && part.from <= start) break;
+        }
+        if (part.to >= end) return inner(builder, text, style, startStyle, endStyle, title);
+        inner(builder, text.slice(0, part.to - start), style, startStyle, null, title);
+        startStyle = null;
+        text = text.slice(part.to - start);
+        start = part.to;
+      }
+    };
+  }
+
+  function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
+    var widget = !ignoreWidget && marker.widgetNode;
+    if (widget) builder.map.push(builder.pos, builder.pos + size, widget);
+    if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
+      if (!widget)
+        widget = builder.content.appendChild(document.createElement("span"));
+      widget.setAttribute("cm-marker", marker.id);
+    }
+    if (widget) {
+      builder.cm.display.input.setUneditable(widget);
+      builder.content.appendChild(widget);
+    }
+    builder.pos += size;
+  }
+
+  // Outputs a number of spans to make up a line, taking highlighting
+  // and marked text into account.
+  function insertLineContent(line, builder, styles) {
+    var spans = line.markedSpans, allText = line.text, at = 0;
+    if (!spans) {
+      for (var i = 1; i < styles.length; i+=2)
+        builder.addToken(builder, allText.slice(at, at = styles[i]), interpretTokenStyle(styles[i+1], builder.cm.options));
+      return;
+    }
+
+    var len = allText.length, pos = 0, i = 1, text = "", style, css;
+    var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed;
+    for (;;) {
+      if (nextChange == pos) { // Update current marker set
+        spanStyle = spanEndStyle = spanStartStyle = title = css = "";
+        collapsed = null; nextChange = Infinity;
+        var foundBookmarks = [];
+        for (var j = 0; j < spans.length; ++j) {
+          var sp = spans[j], m = sp.marker;
+          if (sp.from <= pos && (sp.to == null || sp.to > pos)) {
+            if (sp.to != null && nextChange > sp.to) { nextChange = sp.to; spanEndStyle = ""; }
+            if (m.className) spanStyle += " " + m.className;
+            if (m.css) css = m.css;
+            if (m.startStyle && sp.from == pos) spanStartStyle += " " + m.startStyle;
+            if (m.endStyle && sp.to == nextChange) spanEndStyle += " " + m.endStyle;
+            if (m.title && !title) title = m.title;
+            if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
+              collapsed = sp;
+          } else if (sp.from > pos && nextChange > sp.from) {
+            nextChange = sp.from;
+          }
+          if (m.type == "bookmark" && sp.from == pos && m.widgetNode) foundBookmarks.push(m);
+        }
+        if (collapsed && (collapsed.from || 0) == pos) {
+          buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
+                             collapsed.marker, collapsed.from == null);
+          if (collapsed.to == null) return;
+        }
+        if (!collapsed && foundBookmarks.length) for (var j = 0; j < foundBookmarks.length; ++j)
+          buildCollapsedSpan(builder, 0, foundBookmarks[j]);
+      }
+      if (pos >= len) break;
+
+      var upto = Math.min(len, nextChange);
+      while (true) {
+        if (text) {
+          var end = pos + text.length;
+          if (!collapsed) {
+            var tokenText = end > upto ? text.slice(0, upto - pos) : text;
+            builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
+                             spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css);
+          }
+          if (end >= upto) {text = text.slice(upto - pos); pos = upto; break;}
+          pos = end;
+          spanStartStyle = "";
+        }
+        text = allText.slice(at, at = styles[i++]);
+        style = interpretTokenStyle(styles[i++], builder.cm.options);
+      }
+    }
+  }
+
+  // DOCUMENT DATA STRUCTURE
+
+  // By default, updates that start and end at the beginning of a line
+  // are treated specially, in order to make the association of line
+  // widgets and marker elements with the text behave more intuitive.
+  function isWholeLineUpdate(doc, change) {
+    return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
+      (!doc.cm || doc.cm.options.wholeLineUpdateBefore);
+  }
+
+  // Perform a change on the document data structure.
+  function updateDoc(doc, change, markedSpans, estimateHeight) {
+    function spansFor(n) {return markedSpans ? markedSpans[n] : null;}
+    function update(line, text, spans) {
+      updateLine(line, text, spans, estimateHeight);
+      signalLater(line, "change", line, change);
+    }
+    function linesFor(start, end) {
+      for (var i = start, result = []; i < end; ++i)
+        result.push(new Line(text[i], spansFor(i), estimateHeight));
+      return result;
+    }
+
+    var from = change.from, to = change.to, text = change.text;
+    var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line);
+    var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line;
+
+    // Adjust the line structure
+    if (change.full) {
+      doc.insert(0, linesFor(0, text.length));
+      doc.remove(text.length, doc.size - text.length);
+    } else if (isWholeLineUpdate(doc, change)) {
+      // This is a whole-line replace. Treated specially to make
+      // sure line objects move the way they are supposed to.
+      var added = linesFor(0, text.length - 1);
+      update(lastLine, lastLine.text, lastSpans);
+      if (nlines) doc.remove(from.line, nlines);
+      if (added.length) doc.insert(from.line, added);
+    } else if (firstLine == lastLine) {
+      if (text.length == 1) {
+        update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans);
+      } else {
+        var added = linesFor(1, text.length - 1);
+        added.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight));
+        update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
+        doc.insert(from.line + 1, added);
+      }
+    } else if (text.length == 1) {
+      update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0));
+      doc.remove(from.line + 1, nlines);
+    } else {
+      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
+      update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans);
+      var added = linesFor(1, text.length - 1);
+      if (nlines > 1) doc.remove(from.line + 1, nlines - 1);
+      doc.insert(from.line + 1, added);
+    }
+
+    signalLater(doc, "change", doc, change);
+  }
+
+  // The document is represented as a BTree consisting of leaves, with
+  // chunk of lines in them, and branches, with up to ten leaves or
+  // other branch nodes below them. The top node is always a branch
+  // node, and is the document object itself (meaning it has
+  // additional methods and properties).
+  //
+  // All nodes have parent links. The tree is used both to go from
+  // line numbers to line objects, and to go from objects to numbers.
+  // It also indexes by height, and is used to convert between height
+  // and line object, and to find the total height of the document.
+  //
+  // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
+
+  function LeafChunk(lines) {
+    this.lines = lines;
+    this.parent = null;
+    for (var i = 0, height = 0; i < lines.length; ++i) {
+      lines[i].parent = this;
+      height += lines[i].height;
+    }
+    this.height = height;
+  }
+
+  LeafChunk.prototype = {
+    chunkSize: function() { return this.lines.length; },
+    // Remove the n lines at offset 'at'.
+    removeInner: function(at, n) {
+      for (var i = at, e = at + n; i < e; ++i) {
+        var line = this.lines[i];
+        this.height -= line.height;
+        cleanUpLine(line);
+        signalLater(line, "delete");
+      }
+      this.lines.splice(at, n);
+    },
+    // Helper used to collapse a small branch into a single leaf.
+    collapse: function(lines) {
+      lines.push.apply(lines, this.lines);
+    },
+    // Insert the given array of lines at offset 'at', count them as
+    // having the given height.
+    insertInner: function(at, lines, height) {
+      this.height += height;
+      this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at));
+      for (var i = 0; i < lines.length; ++i) lines[i].parent = this;
+    },
+    // Used to iterate over a part of the tree.
+    iterN: function(at, n, op) {
+      for (var e = at + n; at < e; ++at)
+        if (op(this.lines[at])) return true;
+    }
+  };
+
+  function BranchChunk(children) {
+    this.children = children;
+    var size = 0, height = 0;
+    for (var i = 0; i < children.length; ++i) {
+      var ch = children[i];
+      size += ch.chunkSize(); height += ch.height;
+      ch.parent = this;
+    }
+    this.size = size;
+    this.height = height;
+    this.parent = null;
+  }
+
+  BranchChunk.prototype = {
+    chunkSize: function() { return this.size; },
+    removeInner: function(at, n) {
+      this.size -= n;
+      for (var i = 0; i < this.children.length; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at < sz) {
+          var rm = Math.min(n, sz - at), oldHeight = child.height;
+          child.removeInner(at, rm);
+          this.height -= oldHeight - child.height;
+          if (sz == rm) { this.children.splice(i--, 1); child.parent = null; }
+          if ((n -= rm) == 0) break;
+          at = 0;
+        } else at -= sz;
+      }
+      // If the result is smaller than 25 lines, ensure that it is a
+      // single leaf node.
+      if (this.size - n < 25 &&
+          (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
+        var lines = [];
+        this.collapse(lines);
+        this.children = [new LeafChunk(lines)];
+        this.children[0].parent = this;
+      }
+    },
+    collapse: function(lines) {
+      for (var i = 0; i < this.children.length; ++i) this.children[i].collapse(lines);
+    },
+    insertInner: function(at, lines, height) {
+      this.size += lines.length;
+      this.height += height;
+      for (var i = 0; i < this.children.length; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at <= sz) {
+          child.insertInner(at, lines, height);
+          if (child.lines && child.lines.length > 50) {
+            while (child.lines.length > 50) {
+              var spilled = child.lines.splice(child.lines.length - 25, 25);
+              var newleaf = new LeafChunk(spilled);
+              child.height -= newleaf.height;
+              this.children.splice(i + 1, 0, newleaf);
+              newleaf.parent = this;
+            }
+            this.maybeSpill();
+          }
+          break;
+        }
+        at -= sz;
+      }
+    },
+    // When a node has grown, check whether it should be split.
+    maybeSpill: function() {
+      if (this.children.length <= 10) return;
+      var me = this;
+      do {
+        var spilled = me.children.splice(me.children.length - 5, 5);
+        var sibling = new BranchChunk(spilled);
+        if (!me.parent) { // Become the parent node
+          var copy = new BranchChunk(me.children);
+          copy.parent = me;
+          me.children = [copy, sibling];
+          me = copy;
+        } else {
+          me.size -= sibling.size;
+          me.height -= sibling.height;
+          var myIndex = indexOf(me.parent.children, me);
+          me.parent.children.splice(myIndex + 1, 0, sibling);
+        }
+        sibling.parent = me.parent;
+      } while (me.children.length > 10);
+      me.parent.maybeSpill();
+    },
+    iterN: function(at, n, op) {
+      for (var i = 0; i < this.children.length; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at < sz) {
+          var used = Math.min(n, sz - at);
+          if (child.iterN(at, used, op)) return true;
+          if ((n -= used) == 0) break;
+          at = 0;
+        } else at -= sz;
+      }
+    }
+  };
+
+  var nextDocId = 0;
+  var Doc = CodeMirror.Doc = function(text, mode, firstLine) {
+    if (!(this instanceof Doc)) return new Doc(text, mode, firstLine);
+    if (firstLine == null) firstLine = 0;
+
+    BranchChunk.call(this, [new LeafChunk([new Line("", null)])]);
+    this.first = firstLine;
+    this.scrollTop = this.scrollLeft = 0;
+    this.cantEdit = false;
+    this.cleanGeneration = 1;
+    this.frontier = firstLine;
+    var start = Pos(firstLine, 0);
+    this.sel = simpleSelection(start);
+    this.history = new History(null);
+    this.id = ++nextDocId;
+    this.modeOption = mode;
+
+    if (typeof text == "string") text = splitLines(text);
+    updateDoc(this, {from: start, to: start, text: text});
+    setSelection(this, simpleSelection(start), sel_dontScroll);
+  };
+
+  Doc.prototype = createObj(BranchChunk.prototype, {
+    constructor: Doc,
+    // Iterate over the document. Supports two forms -- with only one
+    // argument, it calls that for each line in the document. With
+    // three, it iterates over the range given by the first two (with
+    // the second being non-inclusive).
+    iter: function(from, to, op) {
+      if (op) this.iterN(from - this.first, to - from, op);
+      else this.iterN(this.first, this.first + this.size, from);
+    },
+
+    // Non-public interface for adding and removing lines.
+    insert: function(at, lines) {
+      var height = 0;
+      for (var i = 0; i < lines.length; ++i) height += lines[i].height;
+      this.insertInner(at - this.first, lines, height);
+    },
+    remove: function(at, n) { this.removeInner(at - this.first, n); },
+
+    // From here, the methods are part of the public interface. Most
+    // are also available from CodeMirror (editor) instances.
+
+    getValue: function(lineSep) {
+      var lines = getLines(this, this.first, this.first + this.size);
+      if (lineSep === false) return lines;
+      return lines.join(lineSep || "\n");
+    },
+    setValue: docMethodOp(function(code) {
+      var top = Pos(this.first, 0), last = this.first + this.size - 1;
+      makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
+                        text: splitLines(code), origin: "setValue", full: true}, true);
+      setSelection(this, simpleSelection(top));
+    }),
+    replaceRange: function(code, from, to, origin) {
+      from = clipPos(this, from);
+      to = to ? clipPos(this, to) : from;
+      replaceRange(this, code, from, to, origin);
+    },
+    getRange: function(from, to, lineSep) {
+      var lines = getBetween(this, clipPos(this, from), clipPos(this, to));
+      if (lineSep === false) return lines;
+      return lines.join(lineSep || "\n");
+    },
+
+    getLine: function(line) {var l = this.getLineHandle(line); return l && l.text;},
+
+    getLineHandle: function(line) {if (isLine(this, line)) return getLine(this, line);},
+    getLineNumber: function(line) {return lineNo(line);},
+
+    getLineHandleVisualStart: function(line) {
+      if (typeof line == "number") line = getLine(this, line);
+      return visualLine(line);
+    },
+
+    lineCount: function() {return this.size;},
+    firstLine: function() {return this.first;},
+    lastLine: function() {return this.first + this.size - 1;},
+
+    clipPos: function(pos) {return clipPos(this, pos);},
+
+    getCursor: function(start) {
+      var range = this.sel.primary(), pos;
+      if (start == null || start == "head") pos = range.head;
+      else if (start == "anchor") pos = range.anchor;
+      else if (start == "end" || start == "to" || start === false) pos = range.to();
+      else pos = range.from();
+      return pos;
+    },
+    listSelections: function() { return this.sel.ranges; },
+    somethingSelected: function() {return this.sel.somethingSelected();},
+
+    setCursor: docMethodOp(function(line, ch, options) {
+      setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options);
+    }),
+    setSelection: docMethodOp(function(anchor, head, options) {
+      setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options);
+    }),
+    extendSelection: docMethodOp(function(head, other, options) {
+      extendSelection(this, clipPos(this, head), other && clipPos(this, other), options);
+    }),
+    extendSelections: docMethodOp(function(heads, options) {
+      extendSelections(this, clipPosArray(this, heads, options));
+    }),
+    extendSelectionsBy: docMethodOp(function(f, options) {
+      extendSelections(this, map(this.sel.ranges, f), options);
+    }),
+    setSelections: docMethodOp(function(ranges, primary, options) {
+      if (!ranges.length) return;
+      for (var i = 0, out = []; i < ranges.length; i++)
+        out[i] = new Range(clipPos(this, ranges[i].anchor),
+                           clipPos(this, ranges[i].head));
+      if (primary == null) primary = Math.min(ranges.length - 1, this.sel.primIndex);
+      setSelection(this, normalizeSelection(out, primary), options);
+    }),
+    addSelection: docMethodOp(function(anchor, head, options) {
+      var ranges = this.sel.ranges.slice(0);
+      ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)));
+      setSelection(this, normalizeSelection(ranges, ranges.length - 1), options);
+    }),
+
+    getSelection: function(lineSep) {
+      var ranges = this.sel.ranges, lines;
+      for (var i = 0; i < ranges.length; i++) {
+        var sel = getBetween(this, ranges[i].from(), ranges[i].to());
+        lines = lines ? lines.concat(sel) : sel;
+      }
+      if (lineSep === false) return lines;
+      else return lines.join(lineSep || "\n");
+    },
+    getSelections: function(lineSep) {
+      var parts = [], ranges = this.sel.ranges;
+      for (var i = 0; i < ranges.length; i++) {
+        var sel = getBetween(this, ranges[i].from(), ranges[i].to());
+        if (lineSep !== false) sel = sel.join(lineSep || "\n");
+        parts[i] = sel;
+      }
+      return parts;
+    },
+    replaceSelection: function(code, collapse, origin) {
+      var dup = [];
+      for (var i = 0; i < this.sel.ranges.length; i++)
+        dup[i] = code;
+      this.replaceSelections(dup, collapse, origin || "+input");
+    },
+    replaceSelections: docMethodOp(function(code, collapse, origin) {
+      var changes = [], sel = this.sel;
+      for (var i = 0; i < sel.ranges.length; i++) {
+        var range = sel.ranges[i];
+        changes[i] = {from: range.from(), to: range.to(), text: splitLines(code[i]), origin: origin};
+      }
+      var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse);
+      for (var i = changes.length - 1; i >= 0; i--)
+        makeChange(this, changes[i]);
+      if (newSel) setSelectionReplaceHistory(this, newSel);
+      else if (this.cm) ensureCursorVisible(this.cm);
+    }),
+    undo: docMethodOp(function() {makeChangeFromHistory(this, "undo");}),
+    redo: docMethodOp(function() {makeChangeFromHistory(this, "redo");}),
+    undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true);}),
+    redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true);}),
+
+    setExtending: function(val) {this.extend = val;},
+    getExtending: function() {return this.extend;},
+
+    historySize: function() {
+      var hist = this.history, done = 0, undone = 0;
+      for (var i = 0; i < hist.done.length; i++) if (!hist.done[i].ranges) ++done;
+      for (var i = 0; i < hist.undone.length; i++) if (!hist.undone[i].ranges) ++undone;
+      return {undo: done, redo: undone};
+    },
+    clearHistory: function() {this.history = new History(this.history.maxGeneration);},
+
+    markClean: function() {
+      this.cleanGeneration = this.changeGeneration(true);
+    },
+    changeGeneration: function(forceSplit) {
+      if (forceSplit)
+        this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null;
+      return this.history.generation;
+    },
+    isClean: function (gen) {
+      return this.history.generation == (gen || this.cleanGeneration);
+    },
+
+    getHistory: function() {
+      return {done: copyHistoryArray(this.history.done),
+              undone: copyHistoryArray(this.history.undone)};
+    },
+    setHistory: function(histData) {
+      var hist = this.history = new History(this.history.maxGeneration);
+      hist.done = copyHistoryArray(histData.done.slice(0), null, true);
+      hist.undone = copyHistoryArray(histData.undone.slice(0), null, true);
+    },
+
+    addLineClass: docMethodOp(function(handle, where, cls) {
+      return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function(line) {
+        var prop = where == "text" ? "textClass"
+                 : where == "background" ? "bgClass"
+                 : where == "gutter" ? "gutterClass" : "wrapClass";
+        if (!line[prop]) line[prop] = cls;
+        else if (classTest(cls).test(line[prop])) return false;
+        else line[prop] += " " + cls;
+        return true;
+      });
+    }),
+    removeLineClass: docMethodOp(function(handle, where, cls) {
+      return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function(line) {
+        var prop = where == "text" ? "textClass"
+                 : where == "background" ? "bgClass"
+                 : where == "gutter" ? "gutterClass" : "wrapClass";
+        var cur = line[prop];
+        if (!cur) return false;
+        else if (cls == null) line[prop] = null;
+        else {
+          var found = cur.match(classTest(cls));
+          if (!found) return false;
+          var end = found.index + found[0].length;
+          line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null;
+        }
+        return true;
+      });
+    }),
+
+    markText: function(from, to, options) {
+      return markText(this, clipPos(this, from), clipPos(this, to), options, "range");
+    },
+    setBookmark: function(pos, options) {
+      var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
+                      insertLeft: options && options.insertLeft,
+                      clearWhenEmpty: false, shared: options && options.shared};
+      pos = clipPos(this, pos);
+      return markText(this, pos, pos, realOpts, "bookmark");
+    },
+    findMarksAt: function(pos) {
+      pos = clipPos(this, pos);
+      var markers = [], spans = getLine(this, pos.line).markedSpans;
+      if (spans) for (var i = 0; i < spans.length; ++i) {
+        var span = spans[i];
+        if ((span.from == null || span.from <= pos.ch) &&
+            (span.to == null || span.to >= pos.ch))
+          markers.push(span.marker.parent || span.marker);
+      }
+      return markers;
+    },
+    findMarks: function(from, to, filter) {
+      from = clipPos(this, from); to = clipPos(this, to);
+      var found = [], lineNo = from.line;
+      this.iter(from.line, to.line + 1, function(line) {
+        var spans = line.markedSpans;
+        if (spans) for (var i = 0; i < spans.length; i++) {
+          var span = spans[i];
+          if (!(lineNo == from.line && from.ch > span.to ||
+                span.from == null && lineNo != from.line||
+                lineNo == to.line && span.from > to.ch) &&
+              (!filter || filter(span.marker)))
+            found.push(span.marker.parent || span.marker);
+        }
+        ++lineNo;
+      });
+      return found;
+    },
+    getAllMarks: function() {
+      var markers = [];
+      this.iter(function(line) {
+        var sps = line.markedSpans;
+        if (sps) for (var i = 0; i < sps.length; ++i)
+          if (sps[i].from != null) markers.push(sps[i].marker);
+      });
+      return markers;
+    },
+
+    posFromIndex: function(off) {
+      var ch, lineNo = this.first;
+      this.iter(function(line) {
+        var sz = line.text.length + 1;
+        if (sz > off) { ch = off; return true; }
+        off -= sz;
+        ++lineNo;
+      });
+      return clipPos(this, Pos(lineNo, ch));
+    },
+    indexFromPos: function (coords) {
+      coords = clipPos(this, coords);
+      var index = coords.ch;
+      if (coords.line < this.first || coords.ch < 0) return 0;
+      this.iter(this.first, coords.line, function (line) {
+        index += line.text.length + 1;
+      });
+      return index;
+    },
+
+    copy: function(copyHistory) {
+      var doc = new Doc(getLines(this, this.first, this.first + this.size), this.modeOption, this.first);
+      doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft;
+      doc.sel = this.sel;
+      doc.extend = false;
+      if (copyHistory) {
+        doc.history.undoDepth = this.history.undoDepth;
+        doc.setHistory(this.getHistory());
+      }
+      return doc;
+    },
+
+    linkedDoc: function(options) {
+      if (!options) options = {};
+      var from = this.first, to = this.first + this.size;
+      if (options.from != null && options.from > from) from = options.from;
+      if (options.to != null && options.to < to) to = options.to;
+      var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from);
+      if (options.sharedHist) copy.history = this.history;
+      (this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist});
+      copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}];
+      copySharedMarkers(copy, findSharedMarkers(this));
+      return copy;
+    },
+    unlinkDoc: function(other) {
+      if (other instanceof CodeMirror) other = other.doc;
+      if (this.linked) for (var i = 0; i < this.linked.length; ++i) {
+        var link = this.linked[i];
+        if (link.doc != other) continue;
+        this.linked.splice(i, 1);
+        other.unlinkDoc(this);
+        detachSharedMarkers(findSharedMarkers(this));
+        break;
+      }
+      // If the histories were shared, split them again
+      if (other.history == this.history) {
+        var splitIds = [other.id];
+        linkedDocs(other, function(doc) {splitIds.push(doc.id);}, true);
+        other.history = new History(null);
+        other.history.done = copyHistoryArray(this.history.done, splitIds);
+        other.history.undone = copyHistoryArray(this.history.undone, splitIds);
+      }
+    },
+    iterLinkedDocs: function(f) {linkedDocs(this, f);},
+
+    getMode: function() {return this.mode;},
+    getEditor: function() {return this.cm;}
+  });
+
+  // Public alias.
+  Doc.prototype.eachLine = Doc.prototype.iter;
+
+  // Set up methods on CodeMirror's prototype to redirect to the editor's document.
+  var dontDelegate = "iter insert remove copy getEditor".split(" ");
+  for (var prop in Doc.prototype) if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)
+    CodeMirror.prototype[prop] = (function(method) {
+      return function() {return method.apply(this.doc, arguments);};
+    })(Doc.prototype[prop]);
+
+  eventMixin(Doc);
+
+  // Call f for all linked documents.
+  function linkedDocs(doc, f, sharedHistOnly) {
+    function propagate(doc, skip, sharedHist) {
+      if (doc.linked) for (var i = 0; i < doc.linked.length; ++i) {
+        var rel = doc.linked[i];
+        if (rel.doc == skip) continue;
+        var shared = sharedHist && rel.sharedHist;
+        if (sharedHistOnly && !shared) continue;
+        f(rel.doc, shared);
+        propagate(rel.doc, doc, shared);
+      }
+    }
+    propagate(doc, null, true);
+  }
+
+  // Attach a document to an editor.
+  function attachDoc(cm, doc) {
+    if (doc.cm) throw new Error("This document is already in use.");
+    cm.doc = doc;
+    doc.cm = cm;
+    estimateLineHeights(cm);
+    loadMode(cm);
+    if (!cm.options.lineWrapping) findMaxLine(cm);
+    cm.options.mode = doc.modeOption;
+    regChange(cm);
+  }
+
+  // LINE UTILITIES
+
+  // Find the line object corresponding to the given line number.
+  function getLine(doc, n) {
+    n -= doc.first;
+    if (n < 0 || n >= doc.size) throw new Error("There is no line " + (n + doc.first) + " in the document.");
+    for (var chunk = doc; !chunk.lines;) {
+      for (var i = 0;; ++i) {
+        var child = chunk.children[i], sz = child.chunkSize();
+        if (n < sz) { chunk = child; break; }
+        n -= sz;
+      }
+    }
+    return chunk.lines[n];
+  }
+
+  // Get the part of a document between two positions, as an array of
+  // strings.
+  function getBetween(doc, start, end) {
+    var out = [], n = start.line;
+    doc.iter(start.line, end.line + 1, function(line) {
+      var text = line.text;
+      if (n == end.line) text = text.slice(0, end.ch);
+      if (n == start.line) text = text.slice(start.ch);
+      out.push(text);
+      ++n;
+    });
+    return out;
+  }
+  // Get the lines between from and to, as array of strings.
+  function getLines(doc, from, to) {
+    var out = [];
+    doc.iter(from, to, function(line) { out.push(line.text); });
+    return out;
+  }
+
+  // Update the height of a line, propagating the height change
+  // upwards to parent nodes.
+  function updateLineHeight(line, height) {
+    var diff = height - line.height;
+    if (diff) for (var n = line; n; n = n.parent) n.height += diff;
+  }
+
+  // Given a line object, find its line number by walking up through
+  // its parent links.
+  function lineNo(line) {
+    if (line.parent == null) return null;
+    var cur = line.parent, no = indexOf(cur.lines, line);
+    for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
+      for (var i = 0;; ++i) {
+        if (chunk.children[i] == cur) break;
+        no += chunk.children[i].chunkSize();
+      }
+    }
+    return no + cur.first;
+  }
+
+  // Find the line at the given vertical position, using the height
+  // information in the document tree.
+  function lineAtHeight(chunk, h) {
+    var n = chunk.first;
+    outer: do {
+      for (var i = 0; i < chunk.children.length; ++i) {
+        var child = chunk.children[i], ch = child.height;
+        if (h < ch) { chunk = child; continue outer; }
+        h -= ch;
+        n += child.chunkSize();
+      }
+      return n;
+    } while (!chunk.lines);
+    for (var i = 0; i < chunk.lines.length; ++i) {
+      var line = chunk.lines[i], lh = line.height;
+      if (h < lh) break;
+      h -= lh;
+    }
+    return n + i;
+  }
+
+
+  // Find the height above the given line.
+  function heightAtLine(lineObj) {
+    lineObj = visualLine(lineObj);
+
+    var h = 0, chunk = lineObj.parent;
+    for (var i = 0; i < chunk.lines.length; ++i) {
+      var line = chunk.lines[i];
+      if (line == lineObj) break;
+      else h += line.height;
+    }
+    for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {
+      for (var i = 0; i < p.children.length; ++i) {
+        var cur = p.children[i];
+        if (cur == chunk) break;
+        else h += cur.height;
+      }
+    }
+    return h;
+  }
+
+  // Get the bidi ordering for the given line (and cache it). Returns
+  // false for lines that are fully left-to-right, and an array of
+  // BidiSpan objects otherwise.
+  function getOrder(line) {
+    var order = line.order;
+    if (order == null) order = line.order = bidiOrdering(line.text);
+    return order;
+  }
+
+  // HISTORY
+
+  function History(startGen) {
+    // Arrays of change events and selections. Doing something adds an
+    // event to done and clears undo. Undoing moves events from done
+    // to undone, redoing moves them in the other direction.
+    this.done = []; this.undone = [];
+    this.undoDepth = Infinity;
+    // Used to track when changes can be merged into a single undo
+    // event
+    this.lastModTime = this.lastSelTime = 0;
+    this.lastOp = this.lastSelOp = null;
+    this.lastOrigin = this.lastSelOrigin = null;
+    // Used by the isClean() method
+    this.generation = this.maxGeneration = startGen || 1;
+  }
+
+  // Create a history change event from an updateDoc-style change
+  // object.
+  function historyChangeFromChange(doc, change) {
+    var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)};
+    attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);
+    linkedDocs(doc, function(doc) {attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);}, true);
+    return histChange;
+  }
+
+  // Pop all selection events off the end of a history array. Stop at
+  // a change event.
+  function clearSelectionEvents(array) {
+    while (array.length) {
+      var last = lst(array);
+      if (last.ranges) array.pop();
+      else break;
+    }
+  }
+
+  // Find the top change event in the history. Pop off selection
+  // events that are in the way.
+  function lastChangeEvent(hist, force) {
+    if (force) {
+      clearSelectionEvents(hist.done);
+      return lst(hist.done);
+    } else if (hist.done.length && !lst(hist.done).ranges) {
+      return lst(hist.done);
+    } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
+      hist.done.pop();
+      return lst(hist.done);
+    }
+  }
+
+  // Register a change in the history. Merges changes that are within
+  // a single operation, ore are close together with an origin that
+  // allows merging (starting with "+") into a single event.
+  function addChangeToHistory(doc, change, selAfter, opId) {
+    var hist = doc.history;
+    hist.undone.length = 0;
+    var time = +new Date, cur;
+
+    if ((hist.lastOp == opId ||
+         hist.lastOrigin == change.origin && change.origin &&
+         ((change.origin.charAt(0) == "+" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||
+          change.origin.charAt(0) == "*")) &&
+        (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
+      // Merge this change into the last event
+      var last = lst(cur.changes);
+      if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
+        // Optimized case for simple insertion -- don't want to add
+        // new changesets for every character typed
+        last.to = changeEnd(change);
+      } else {
+        // Add new sub-event
+        cur.changes.push(historyChangeFromChange(doc, change));
+      }
+    } else {
+      // Can not be merged, start a new event.
+      var before = lst(hist.done);
+      if (!before || !before.ranges)
+        pushSelectionToHistory(doc.sel, hist.done);
+      cur = {changes: [historyChangeFromChange(doc, change)],
+             generation: hist.generation};
+      hist.done.push(cur);
+      while (hist.done.length > hist.undoDepth) {
+        hist.done.shift();
+        if (!hist.done[0].ranges) hist.done.shift();
+      }
+    }
+    hist.done.push(selAfter);
+    hist.generation = ++hist.maxGeneration;
+    hist.lastModTime = hist.lastSelTime = time;
+    hist.lastOp = hist.lastSelOp = opId;
+    hist.lastOrigin = hist.lastSelOrigin = change.origin;
+
+    if (!last) signal(doc, "historyAdded");
+  }
+
+  function selectionEventCanBeMerged(doc, origin, prev, sel) {
+    var ch = origin.charAt(0);
+    return ch == "*" ||
+      ch == "+" &&
+      prev.ranges.length == sel.ranges.length &&
+      prev.somethingSelected() == sel.somethingSelected() &&
+      new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500);
+  }
+
+  // Called whenever the selection changes, sets the new selection as
+  // the pending selection in the history, and pushes the old pending
+  // selection into the 'done' array when it was significantly
+  // different (in number of selected ranges, emptiness, or time).
+  function addSelectionToHistory(doc, sel, opId, options) {
+    var hist = doc.history, origin = options && options.origin;
+
+    // A new event is started when the previous origin does not match
+    // the current, or the origins don't allow matching. Origins
+    // starting with * are always merged, those starting with + are
+    // merged when similar and close together in time.
+    if (opId == hist.lastSelOp ||
+        (origin && hist.lastSelOrigin == origin &&
+         (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
+          selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
+      hist.done[hist.done.length - 1] = sel;
+    else
+      pushSelectionToHistory(sel, hist.done);
+
+    hist.lastSelTime = +new Date;
+    hist.lastSelOrigin = origin;
+    hist.lastSelOp = opId;
+    if (options && options.clearRedo !== false)
+      clearSelectionEvents(hist.undone);
+  }
+
+  function pushSelectionToHistory(sel, dest) {
+    var top = lst(dest);
+    if (!(top && top.ranges && top.equals(sel)))
+      dest.push(sel);
+  }
+
+  // Used to store marked span information in the history.
+  function attachLocalSpans(doc, change, from, to) {
+    var existing = change["spans_" + doc.id], n = 0;
+    doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function(line) {
+      if (line.markedSpans)
+        (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans;
+      ++n;
+    });
+  }
+
+  // When un/re-doing restores text containing marked spans, those
+  // that have been explicitly cleared should not be restored.
+  function removeClearedSpans(spans) {
+    if (!spans) return null;
+    for (var i = 0, out; i < spans.length; ++i) {
+      if (spans[i].marker.explicitlyCleared) { if (!out) out = spans.slice(0, i); }
+      else if (out) out.push(spans[i]);
+    }
+    return !out ? spans : out.length ? out : null;
+  }
+
+  // Retrieve and filter the old marked spans stored in a change event.
+  function getOldSpans(doc, change) {
+    var found = change["spans_" + doc.id];
+    if (!found) return null;
+    for (var i = 0, nw = []; i < change.text.length; ++i)
+      nw.push(removeClearedSpans(found[i]));
+    return nw;
+  }
+
+  // Used both to provide a JSON-safe object in .getHistory, and, when
+  // detaching a document, to split the history in two
+  function copyHistoryArray(events, newGroup, instantiateSel) {
+    for (var i = 0, copy = []; i < events.length; ++i) {
+      var event = events[i];
+      if (event.ranges) {
+        copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event);
+        continue;
+      }
+      var changes = event.changes, newChanges = [];
+      copy.push({changes: newChanges});
+      for (var j = 0; j < changes.length; ++j) {
+        var change = changes[j], m;
+        newChanges.push({from: change.from, to: change.to, text: change.text});
+        if (newGroup) for (var prop in change) if (m = prop.match(/^spans_(\d+)$/)) {
+          if (indexOf(newGroup, Number(m[1])) > -1) {
+            lst(newChanges)[prop] = change[prop];
+            delete change[prop];
+          }
+        }
+      }
+    }
+    return copy;
+  }
+
+  // Rebasing/resetting history to deal with externally-sourced changes
+
+  function rebaseHistSelSingle(pos, from, to, diff) {
+    if (to < pos.line) {
+      pos.line += diff;
+    } else if (from < pos.line) {
+      pos.line = from;
+      pos.ch = 0;
+    }
+  }
+
+  // Tries to rebase an array of history events given a change in the
+  // document. If the change touches the same lines as the event, the
+  // event, and everything 'behind' it, is discarded. If the change is
+  // before the event, the event's positions are updated. Uses a
+  // copy-on-write scheme for the positions, to avoid having to
+  // reallocate them all on every rebase, but also avoid problems with
+  // shared position objects being unsafely updated.
+  function rebaseHistArray(array, from, to, diff) {
+    for (var i = 0; i < array.length; ++i) {
+      var sub = array[i], ok = true;
+      if (sub.ranges) {
+        if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true; }
+        for (var j = 0; j < sub.ranges.length; j++) {
+          rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff);
+          rebaseHistSelSingle(sub.ranges[j].head, from, to, diff);
+        }
+        continue;
+      }
+      for (var j = 0; j < sub.changes.length; ++j) {
+        var cur = sub.changes[j];
+        if (to < cur.from.line) {
+          cur.from = Pos(cur.from.line + diff, cur.from.ch);
+          cur.to = Pos(cur.to.line + diff, cur.to.ch);
+        } else if (from <= cur.to.line) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok) {
+        array.splice(0, i + 1);
+        i = 0;
+      }
+    }
+  }
+
+  function rebaseHist(hist, change) {
+    var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1;
+    rebaseHistArray(hist.done, from, to, diff);
+    rebaseHistArray(hist.undone, from, to, diff);
+  }
+
+  // EVENT UTILITIES
+
+  // Due to the fact that we still support jurassic IE versions, some
+  // compatibility wrappers are needed.
+
+  var e_preventDefault = CodeMirror.e_preventDefault = function(e) {
+    if (e.preventDefault) e.preventDefault();
+    else e.returnValue = false;
+  };
+  var e_stopPropagation = CodeMirror.e_stopPropagation = function(e) {
+    if (e.stopPropagation) e.stopPropagation();
+    else e.cancelBubble = true;
+  };
+  function e_defaultPrevented(e) {
+    return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false;
+  }
+  var e_stop = CodeMirror.e_stop = function(e) {e_preventDefault(e); e_stopPropagation(e);};
+
+  function e_target(e) {return e.target || e.srcElement;}
+  function e_button(e) {
+    var b = e.which;
+    if (b == null) {
+      if (e.button & 1) b = 1;
+      else if (e.button & 2) b = 3;
+      else if (e.button & 4) b = 2;
+    }
+    if (mac && e.ctrlKey && b == 1) b = 3;
+    return b;
+  }
+
+  // EVENT HANDLING
+
+  // Lightweight event framework. on/off also work on DOM nodes,
+  // registering native DOM handlers.
+
+  var on = CodeMirror.on = function(emitter, type, f) {
+    if (emitter.addEventListener)
+      emitter.addEventListener(type, f, false);
+    else if (emitter.attachEvent)
+      emitter.attachEvent("on" + type, f);
+    else {
+      var map = emitter._handlers || (emitter._handlers = {});
+      var arr = map[type] || (map[type] = []);
+      arr.push(f);
+    }
+  };
+
+  var off = CodeMirror.off = function(emitter, type, f) {
+    if (emitter.removeEventListener)
+      emitter.removeEventListener(type, f, false);
+    else if (emitter.detachEvent)
+      emitter.detachEvent("on" + type, f);
+    else {
+      var arr = emitter._handlers && emitter._handlers[type];
+      if (!arr) return;
+      for (var i = 0; i < arr.length; ++i)
+        if (arr[i] == f) { arr.splice(i, 1); break; }
+    }
+  };
+
+  var signal = CodeMirror.signal = function(emitter, type /*, values...*/) {
+    var arr = emitter._handlers && emitter._handlers[type];
+    if (!arr) return;
+    var args = Array.prototype.slice.call(arguments, 2);
+    for (var i = 0; i < arr.length; ++i) arr[i].apply(null, args);
+  };
+
+  var orphanDelayedCallbacks = null;
+
+  // Often, we want to signal events at a point where we are in the
+  // middle of some work, but don't want the handler to start calling
+  // other methods on the editor, which might be in an inconsistent
+  // state or simply not expect any other events to happen.
+  // signalLater looks whether there are any handlers, and schedules
+  // them to be executed when the last operation ends, or, if no
+  // operation is active, when a timeout fires.
+  function signalLater(emitter, type /*, values...*/) {
+    var arr = emitter._handlers && emitter._handlers[type];
+    if (!arr) return;
+    var args = Array.prototype.slice.call(arguments, 2), list;
+    if (operationGroup) {
+      list = operationGroup.delayedCallbacks;
+    } else if (orphanDelayedCallbacks) {
+      list = orphanDelayedCallbacks;
+    } else {
+      list = orphanDelayedCallbacks = [];
+      setTimeout(fireOrphanDelayed, 0);
+    }
+    function bnd(f) {return function(){f.apply(null, args);};};
+    for (var i = 0; i < arr.length; ++i)
+      list.push(bnd(arr[i]));
+  }
+
+  function fireOrphanDelayed() {
+    var delayed = orphanDelayedCallbacks;
+    orphanDelayedCallbacks = null;
+    for (var i = 0; i < delayed.length; ++i) delayed[i]();
+  }
+
+  // The DOM events that CodeMirror handles can be overridden by
+  // registering a (non-DOM) handler on the editor for the event name,
+  // and preventDefault-ing the event in that handler.
+  function signalDOMEvent(cm, e, override) {
+    if (typeof e == "string")
+      e = {type: e, preventDefault: function() { this.defaultPrevented = true; }};
+    signal(cm, override || e.type, cm, e);
+    return e_defaultPrevented(e) || e.codemirrorIgnore;
+  }
+
+  function signalCursorActivity(cm) {
+    var arr = cm._handlers && cm._handlers.cursorActivity;
+    if (!arr) return;
+    var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []);
+    for (var i = 0; i < arr.length; ++i) if (indexOf(set, arr[i]) == -1)
+      set.push(arr[i]);
+  }
+
+  function hasHandler(emitter, type) {
+    var arr = emitter._handlers && emitter._handlers[type];
+    return arr && arr.length > 0;
+  }
+
+  // Add on and off methods to a constructor's prototype, to make
+  // registering events on such objects more convenient.
+  function eventMixin(ctor) {
+    ctor.prototype.on = function(type, f) {on(this, type, f);};
+    ctor.prototype.off = function(type, f) {off(this, type, f);};
+  }
+
+  // MISC UTILITIES
+
+  // Number of pixels added to scroller and sizer to hide scrollbar
+  var scrollerGap = 30;
+
+  // Returned or thrown by various protocols to signal 'I'm not
+  // handling this'.
+  var Pass = CodeMirror.Pass = {toString: function(){return "CodeMirror.Pass";}};
+
+  // Reused option objects for setSelection & friends
+  var sel_dontScroll = {scroll: false}, sel_mouse = {origin: "*mouse"}, sel_move = {origin: "+move"};
+
+  function Delayed() {this.id = null;}
+  Delayed.prototype.set = function(ms, f) {
+    clearTimeout(this.id);
+    this.id = setTimeout(f, ms);
+  };
+
+  // Counts the column offset in a string, taking tabs into account.
+  // Used mostly to find indentation.
+  var countColumn = CodeMirror.countColumn = function(string, end, tabSize, startIndex, startValue) {
+    if (end == null) {
+      end = string.search(/[^\s\u00a0]/);
+      if (end == -1) end = string.length;
+    }
+    for (var i = startIndex || 0, n = startValue || 0;;) {
+      var nextTab = string.indexOf("\t", i);
+      if (nextTab < 0 || nextTab >= end)
+        return n + (end - i);
+      n += nextTab - i;
+      n += tabSize - (n % tabSize);
+      i = nextTab + 1;
+    }
+  };
+
+  // The inverse of countColumn -- find the offset that corresponds to
+  // a particular column.
+  function findColumn(string, goal, tabSize) {
+    for (var pos = 0, col = 0;;) {
+      var nextTab = string.indexOf("\t", pos);
+      if (nextTab == -1) nextTab = string.length;
+      var skipped = nextTab - pos;
+      if (nextTab == string.length || col + skipped >= goal)
+        return pos + Math.min(skipped, goal - col);
+      col += nextTab - pos;
+      col += tabSize - (col % tabSize);
+      pos = nextTab + 1;
+      if (col >= goal) return pos;
+    }
+  }
+
+  var spaceStrs = [""];
+  function spaceStr(n) {
+    while (spaceStrs.length <= n)
+      spaceStrs.push(lst(spaceStrs) + " ");
+    return spaceStrs[n];
+  }
+
+  function lst(arr) { return arr[arr.length-1]; }
+
+  var selectInput = function(node) { node.select(); };
+  if (ios) // Mobile Safari apparently has a bug where select() is broken.
+    selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; };
+  else if (ie) // Suppress mysterious IE10 errors
+    selectInput = function(node) { try { node.select(); } catch(_e) {} };
+
+  function indexOf(array, elt) {
+    for (var i = 0; i < array.length; ++i)
+      if (array[i] == elt) return i;
+    return -1;
+  }
+  function map(array, f) {
+    var out = [];
+    for (var i = 0; i < array.length; i++) out[i] = f(array[i], i);
+    return out;
+  }
+
+  function nothing() {}
+
+  function createObj(base, props) {
+    var inst;
+    if (Object.create) {
+      inst = Object.create(base);
+    } else {
+      nothing.prototype = base;
+      inst = new nothing();
+    }
+    if (props) copyObj(props, inst);
+    return inst;
+  };
+
+  function copyObj(obj, target, overwrite) {
+    if (!target) target = {};
+    for (var prop in obj)
+      if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
+        target[prop] = obj[prop];
+    return target;
+  }
+
+  function bind(f) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    return function(){return f.apply(null, args);};
+  }
+
+  var nonASCIISingleCaseWordChar = /[\u00df\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
+  var isWordCharBasic = CodeMirror.isWordChar = function(ch) {
+    return /\w/.test(ch) || ch > "\x80" &&
+      (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch));
+  };
+  function isWordChar(ch, helper) {
+    if (!helper) return isWordCharBasic(ch);
+    if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) return true;
+    return helper.test(ch);
+  }
+
+  function isEmpty(obj) {
+    for (var n in obj) if (obj.hasOwnProperty(n) && obj[n]) return false;
+    return true;
+  }
+
+  // Extending unicode characters. A series of a non-extending char +
+  // any number of extending chars is treated as a single unit as far
+  // as editing and measuring is concerned. This is not fully correct,
+  // since some scripts/fonts/browsers also treat other configurations
+  // of code points as a group.
+  var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/;
+  function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch); }
+
+  // DOM UTILITIES
+
+  function elt(tag, content, className, style) {
+    var e = document.createElement(tag);
+    if (className) e.className = className;
+    if (style) e.style.cssText = style;
+    if (typeof content == "string") e.appendChild(document.createTextNode(content));
+    else if (content) for (var i = 0; i < content.length; ++i) e.appendChild(content[i]);
+    return e;
+  }
+
+  var range;
+  if (document.createRange) range = function(node, start, end, endNode) {
+    var r = document.createRange();
+    r.setEnd(endNode || node, end);
+    r.setStart(node, start);
+    return r;
+  };
+  else range = function(node, start, end) {
+    var r = document.body.createTextRange();
+    try { r.moveToElementText(node.parentNode); }
+    catch(e) { return r; }
+    r.collapse(true);
+    r.moveEnd("character", end);
+    r.moveStart("character", start);
+    return r;
+  };
+
+  function removeChildren(e) {
+    for (var count = e.childNodes.length; count > 0; --count)
+      e.removeChild(e.firstChild);
+    return e;
+  }
+
+  function removeChildrenAndAdd(parent, e) {
+    return removeChildren(parent).appendChild(e);
+  }
+
+  var contains = CodeMirror.contains = function(parent, child) {
+    if (child.nodeType == 3) // Android browser always returns false when child is a textnode
+      child = child.parentNode;
+    if (parent.contains)
+      return parent.contains(child);
+    do {
+      if (child.nodeType == 11) child = child.host;
+      if (child == parent) return true;
+    } while (child = child.parentNode);
+  };
+
+  function activeElt() { return document.activeElement; }
+  // Older versions of IE throws unspecified error when touching
+  // document.activeElement in some cases (during loading, in iframe)
+  if (ie && ie_version < 11) activeElt = function() {
+    try { return document.activeElement; }
+    catch(e) { return document.body; }
+  };
+
+  function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*"); }
+  var rmClass = CodeMirror.rmClass = function(node, cls) {
+    var current = node.className;
+    var match = classTest(cls).exec(current);
+    if (match) {
+      var after = current.slice(match.index + match[0].length);
+      node.className = current.slice(0, match.index) + (after ? match[1] + after : "");
+    }
+  };
+  var addClass = CodeMirror.addClass = function(node, cls) {
+    var current = node.className;
+    if (!classTest(cls).test(current)) node.className += (current ? " " : "") + cls;
+  };
+  function joinClasses(a, b) {
+    var as = a.split(" ");
+    for (var i = 0; i < as.length; i++)
+      if (as[i] && !classTest(as[i]).test(b)) b += " " + as[i];
+    return b;
+  }
+
+  // WINDOW-WIDE EVENTS
+
+  // These must be handled carefully, because naively registering a
+  // handler for each editor will cause the editors to never be
+  // garbage collected.
+
+  function forEachCodeMirror(f) {
+    if (!document.body.getElementsByClassName) return;
+    var byClass = document.body.getElementsByClassName("CodeMirror");
+    for (var i = 0; i < byClass.length; i++) {
+      var cm = byClass[i].CodeMirror;
+      if (cm) f(cm);
+    }
+  }
+
+  var globalsRegistered = false;
+  function ensureGlobalHandlers() {
+    if (globalsRegistered) return;
+    registerGlobalHandlers();
+    globalsRegistered = true;
+  }
+  function registerGlobalHandlers() {
+    // When the window resizes, we need to refresh active editors.
+    var resizeTimer;
+    on(window, "resize", function() {
+      if (resizeTimer == null) resizeTimer = setTimeout(function() {
+        resizeTimer = null;
+        forEachCodeMirror(onResize);
+      }, 100);
+    });
+    // When the window loses focus, we want to show the editor as blurred
+    on(window, "blur", function() {
+      forEachCodeMirror(onBlur);
+    });
+  }
+
+  // FEATURE DETECTION
+
+  // Detect drag-and-drop
+  var dragAndDrop = function() {
+    // There is *some* kind of drag-and-drop support in IE6-8, but I
+    // couldn't get it to work yet.
+    if (ie && ie_version < 9) return false;
+    var div = elt('div');
+    return "draggable" in div || "dragDrop" in div;
+  }();
+
+  var zwspSupported;
+  function zeroWidthElement(measure) {
+    if (zwspSupported == null) {
+      var test = elt("span", "\u200b");
+      removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]));
+      if (measure.firstChild.offsetHeight != 0)
+        zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8);
+    }
+    var node = zwspSupported ? elt("span", "\u200b") :
+      elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px");
+    node.setAttribute("cm-text", "");
+    return node;
+  }
+
+  // Feature-detect IE's crummy client rect reporting for bidi text
+  var badBidiRects;
+  function hasBadBidiRects(measure) {
+    if (badBidiRects != null) return badBidiRects;
+    var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"));
+    var r0 = range(txt, 0, 1).getBoundingClientRect();
+    if (!r0 || r0.left == r0.right) return false; // Safari returns null in some cases (#2780)
+    var r1 = range(txt, 1, 2).getBoundingClientRect();
+    return badBidiRects = (r1.right - r0.right < 3);
+  }
+
+  // See if "".split is the broken IE version, if so, provide an
+  // alternative way to split lines.
+  var splitLines = CodeMirror.splitLines = "\n\nb".split(/\n/).length != 3 ? function(string) {
+    var pos = 0, result = [], l = string.length;
+    while (pos <= l) {
+      var nl = string.indexOf("\n", pos);
+      if (nl == -1) nl = string.length;
+      var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl);
+      var rt = line.indexOf("\r");
+      if (rt != -1) {
+        result.push(line.slice(0, rt));
+        pos += rt + 1;
+      } else {
+        result.push(line);
+        pos = nl + 1;
+      }
+    }
+    return result;
+  } : function(string){return string.split(/\r\n?|\n/);};
+
+  var hasSelection = window.getSelection ? function(te) {
+    try { return te.selectionStart != te.selectionEnd; }
+    catch(e) { return false; }
+  } : function(te) {
+    try {var range = te.ownerDocument.selection.createRange();}
+    catch(e) {}
+    if (!range || range.parentElement() != te) return false;
+    return range.compareEndPoints("StartToEnd", range) != 0;
+  };
+
+  var hasCopyEvent = (function() {
+    var e = elt("div");
+    if ("oncopy" in e) return true;
+    e.setAttribute("oncopy", "return;");
+    return typeof e.oncopy == "function";
+  })();
+
+  var badZoomedRects = null;
+  function hasBadZoomedRects(measure) {
+    if (badZoomedRects != null) return badZoomedRects;
+    var node = removeChildrenAndAdd(measure, elt("span", "x"));
+    var normal = node.getBoundingClientRect();
+    var fromRange = range(node, 0, 1).getBoundingClientRect();
+    return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1;
+  }
+
+  // KEY NAMES
+
+  var keyNames = {3: "Enter", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
+                  19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
+                  36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
+                  46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod", 107: "=", 109: "-", 127: "Delete",
+                  173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
+                  221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
+                  63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"};
+  CodeMirror.keyNames = keyNames;
+  (function() {
+    // Number keys
+    for (var i = 0; i < 10; i++) keyNames[i + 48] = keyNames[i + 96] = String(i);
+    // Alphabetic keys
+    for (var i = 65; i <= 90; i++) keyNames[i] = String.fromCharCode(i);
+    // Function keys
+    for (var i = 1; i <= 12; i++) keyNames[i + 111] = keyNames[i + 63235] = "F" + i;
+  })();
+
+  // BIDI HELPERS
+
+  function iterateBidiSections(order, from, to, f) {
+    if (!order) return f(from, to, "ltr");
+    var found = false;
+    for (var i = 0; i < order.length; ++i) {
+      var part = order[i];
+      if (part.from < to && part.to > from || from == to && part.to == from) {
+        f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr");
+        found = true;
+      }
+    }
+    if (!found) f(from, to, "ltr");
+  }
+
+  function bidiLeft(part) { return part.level % 2 ? part.to : part.from; }
+  function bidiRight(part) { return part.level % 2 ? part.from : part.to; }
+
+  function lineLeft(line) { var order = getOrder(line); return order ? bidiLeft(order[0]) : 0; }
+  function lineRight(line) {
+    var order = getOrder(line);
+    if (!order) return line.text.length;
+    return bidiRight(lst(order));
+  }
+
+  function lineStart(cm, lineN) {
+    var line = getLine(cm.doc, lineN);
+    var visual = visualLine(line);
+    if (visual != line) lineN = lineNo(visual);
+    var order = getOrder(visual);
+    var ch = !order ? 0 : order[0].level % 2 ? lineRight(visual) : lineLeft(visual);
+    return Pos(lineN, ch);
+  }
+  function lineEnd(cm, lineN) {
+    var merged, line = getLine(cm.doc, lineN);
+    while (merged = collapsedSpanAtEnd(line)) {
+      line = merged.find(1, true).line;
+      lineN = null;
+    }
+    var order = getOrder(line);
+    var ch = !order ? line.text.length : order[0].level % 2 ? lineLeft(line) : lineRight(line);
+    return Pos(lineN == null ? lineNo(line) : lineN, ch);
+  }
+  function lineStartSmart(cm, pos) {
+    var start = lineStart(cm, pos.line);
+    var line = getLine(cm.doc, start.line);
+    var order = getOrder(line);
+    if (!order || order[0].level == 0) {
+      var firstNonWS = Math.max(0, line.text.search(/\S/));
+      var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch;
+      return Pos(start.line, inWS ? 0 : firstNonWS);
+    }
+    return start;
+  }
+
+  function compareBidiLevel(order, a, b) {
+    var linedir = order[0].level;
+    if (a == linedir) return true;
+    if (b == linedir) return false;
+    return a < b;
+  }
+  var bidiOther;
+  function getBidiPartAt(order, pos) {
+    bidiOther = null;
+    for (var i = 0, found; i < order.length; ++i) {
+      var cur = order[i];
+      if (cur.from < pos && cur.to > pos) return i;
+      if ((cur.from == pos || cur.to == pos)) {
+        if (found == null) {
+          found = i;
+        } else if (compareBidiLevel(order, cur.level, order[found].level)) {
+          if (cur.from != cur.to) bidiOther = found;
+          return i;
+        } else {
+          if (cur.from != cur.to) bidiOther = i;
+          return found;
+        }
+      }
+    }
+    return found;
+  }
+
+  function moveInLine(line, pos, dir, byUnit) {
+    if (!byUnit) return pos + dir;
+    do pos += dir;
+    while (pos > 0 && isExtendingChar(line.text.charAt(pos)));
+    return pos;
+  }
+
+  // This is needed in order to move 'visually' through bi-directional
+  // text -- i.e., pressing left should make the cursor go left, even
+  // when in RTL text. The tricky part is the 'jumps', where RTL and
+  // LTR text touch each other. This often requires the cursor offset
+  // to move more than one unit, in order to visually move one unit.
+  function moveVisually(line, start, dir, byUnit) {
+    var bidi = getOrder(line);
+    if (!bidi) return moveLogically(line, start, dir, byUnit);
+    var pos = getBidiPartAt(bidi, start), part = bidi[pos];
+    var target = moveInLine(line, start, part.level % 2 ? -dir : dir, byUnit);
+
+    for (;;) {
+      if (target > part.from && target < part.to) return target;
+      if (target == part.from || target == part.to) {
+        if (getBidiPartAt(bidi, target) == pos) return target;
+        part = bidi[pos += dir];
+        return (dir > 0) == part.level % 2 ? part.to : part.from;
+      } else {
+        part = bidi[pos += dir];
+        if (!part) return null;
+        if ((dir > 0) == part.level % 2)
+          target = moveInLine(line, part.to, -1, byUnit);
+        else
+          target = moveInLine(line, part.from, 1, byUnit);
+      }
+    }
+  }
+
+  function moveLogically(line, start, dir, byUnit) {
+    var target = start + dir;
+    if (byUnit) while (target > 0 && isExtendingChar(line.text.charAt(target))) target += dir;
+    return target < 0 || target > line.text.length ? null : target;
+  }
+
+  // Bidirectional ordering algorithm
+  // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
+  // that this (partially) implements.
+
+  // One-char codes used for character types:
+  // L (L):   Left-to-Right
+  // R (R):   Right-to-Left
+  // r (AL):  Right-to-Left Arabic
+  // 1 (EN):  European Number
+  // + (ES):  European Number Separator
+  // % (ET):  European Number Terminator
+  // n (AN):  Arabic Number
+  // , (CS):  Common Number Separator
+  // m (NSM): Non-Spacing Mark
+  // b (BN):  Boundary Neutral
+  // s (B):   Paragraph Separator
+  // t (S):   Segment Separator
+  // w (WS):  Whitespace
+  // N (ON):  Other Neutrals
+
+  // Returns null if characters are ordered as they appear
+  // (left-to-right), or an array of sections ({from, to, level}
+  // objects) in the order in which they occur visually.
+  var bidiOrdering = (function() {
+    // Character types for codepoints 0 to 0xff
+    var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";
+    // Character types for codepoints 0x600 to 0x6ff
+    var arabicTypes = "rrrrrrrrrrrr,rNNmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmrrrrrrrnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmNmmmm";
+    function charType(code) {
+      if (code <= 0xf7) return lowTypes.charAt(code);
+      else if (0x590 <= code && code <= 0x5f4) return "R";
+      else if (0x600 <= code && code <= 0x6ed) return arabicTypes.charAt(code - 0x600);
+      else if (0x6ee <= code && code <= 0x8ac) return "r";
+      else if (0x2000 <= code && code <= 0x200b) return "w";
+      else if (code == 0x200c) return "b";
+      else return "L";
+    }
+
+    var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
+    var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;
+    // Browsers seem to always treat the boundaries of block elements as being L.
+    var outerType = "L";
+
+    function BidiSpan(level, from, to) {
+      this.level = level;
+      this.from = from; this.to = to;
+    }
+
+    return function(str) {
+      if (!bidiRE.test(str)) return false;
+      var len = str.length, types = [];
+      for (var i = 0, type; i < len; ++i)
+        types.push(type = charType(str.charCodeAt(i)));
+
+      // W1. Examine each non-spacing mark (NSM) in the level run, and
+      // change the type of the NSM to the type of the previous
+      // character. If the NSM is at the start of the level run, it will
+      // get the type of sor.
+      for (var i = 0, prev = outerType; i < len; ++i) {
+        var type = types[i];
+        if (type == "m") types[i] = prev;
+        else prev = type;
+      }
+
+      // W2. Search backwards from each instance of a European number
+      // until the first strong type (R, L, AL, or sor) is found. If an
+      // AL is found, change the type of the European number to Arabic
+      // number.
+      // W3. Change all ALs to R.
+      for (var i = 0, cur = outerType; i < len; ++i) {
+        var type = types[i];
+        if (type == "1" && cur == "r") types[i] = "n";
+        else if (isStrong.test(type)) { cur = type; if (type == "r") types[i] = "R"; }
+      }
+
+      // W4. A single European separator between two European numbers
+      // changes to a European number. A single common separator between
+      // two numbers of the same type changes to that type.
+      for (var i = 1, prev = types[0]; i < len - 1; ++i) {
+        var type = types[i];
+        if (type == "+" && prev == "1" && types[i+1] == "1") types[i] = "1";
+        else if (type == "," && prev == types[i+1] &&
+                 (prev == "1" || prev == "n")) types[i] = prev;
+        prev = type;
+      }
+
+      // W5. A sequence of European terminators adjacent to European
+      // numbers changes to all European numbers.
+      // W6. Otherwise, separators and terminators change to Other
+      // Neutral.
+      for (var i = 0; i < len; ++i) {
+        var type = types[i];
+        if (type == ",") types[i] = "N";
+        else if (type == "%") {
+          for (var end = i + 1; end < len && types[end] == "%"; ++end) {}
+          var replace = (i && types[i-1] == "!") || (end < len && types[end] == "1") ? "1" : "N";
+          for (var j = i; j < end; ++j) types[j] = replace;
+          i = end - 1;
+        }
+      }
+
+      // W7. Search backwards from each instance of a European number
+      // until the first strong type (R, L, or sor) is found. If an L is
+      // found, then change the type of the European number to L.
+      for (var i = 0, cur = outerType; i < len; ++i) {
+        var type = types[i];
+        if (cur == "L" && type == "1") types[i] = "L";
+        else if (isStrong.test(type)) cur = type;
+      }
+
+      // N1. A sequence of neutrals takes the direction of the
+      // surrounding strong text if the text on both sides has the same
+      // direction. European and Arabic numbers act as if they were R in
+      // terms of their influence on neutrals. Start-of-level-run (sor)
+      // and end-of-level-run (eor) are used at level run boundaries.
+      // N2. Any remaining neutrals take the embedding direction.
+      for (var i = 0; i < len; ++i) {
+        if (isNeutral.test(types[i])) {
+          for (var end = i + 1; end < len && isNeutral.test(types[end]); ++end) {}
+          var before = (i ? types[i-1] : outerType) == "L";
+          var after = (end < len ? types[end] : outerType) == "L";
+          var replace = before || after ? "L" : "R";
+          for (var j = i; j < end; ++j) types[j] = replace;
+          i = end - 1;
+        }
+      }
+
+      // Here we depart from the documented algorithm, in order to avoid
+      // building up an actual levels array. Since there are only three
+      // levels (0, 1, 2) in an implementation that doesn't take
+      // explicit embedding into account, we can build up the order on
+      // the fly, without following the level-based algorithm.
+      var order = [], m;
+      for (var i = 0; i < len;) {
+        if (countsAsLeft.test(types[i])) {
+          var start = i;
+          for (++i; i < len && countsAsLeft.test(types[i]); ++i) {}
+          order.push(new BidiSpan(0, start, i));
+        } else {
+          var pos = i, at = order.length;
+          for (++i; i < len && types[i] != "L"; ++i) {}
+          for (var j = pos; j < i;) {
+            if (countsAsNum.test(types[j])) {
+              if (pos < j) order.splice(at, 0, new BidiSpan(1, pos, j));
+              var nstart = j;
+              for (++j; j < i && countsAsNum.test(types[j]); ++j) {}
+              order.splice(at, 0, new BidiSpan(2, nstart, j));
+              pos = j;
+            } else ++j;
+          }
+          if (pos < i) order.splice(at, 0, new BidiSpan(1, pos, i));
+        }
+      }
+      if (order[0].level == 1 && (m = str.match(/^\s+/))) {
+        order[0].from = m[0].length;
+        order.unshift(new BidiSpan(0, 0, m[0].length));
+      }
+      if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
+        lst(order).to -= m[0].length;
+        order.push(new BidiSpan(0, len - m[0].length, len));
+      }
+      if (order[0].level != lst(order).level)
+        order.push(new BidiSpan(order[0].level, len, len));
+
+      return order;
+    };
+  })();
+
+  // THE END
+
+  CodeMirror.version = "5.0.0";
+
+  return CodeMirror;
+});
diff --git a/example/ext/jquery-2.1.4.min.js b/example/ext/jquery-2.1.4.min.js
new file mode 100644
index 0000000..49990d6
--- /dev/null
+++ b/example/ext/jquery-2.1.4.min.js
@@ -0,0 +1,4 @@
+/*! jQuery v2.1.4 | (c) 2005, 2015 jQuery Foundation, Inc. | jquery.org/license */
+!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=c.slice,e=c.concat,f=c.push,g=c.indexOf,h={},i=h.toString,j=h.hasOwnProperty,k={},l=a.document,m="2.1.4",n=function(a,b){return new n.fn.init(a,b)},o=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,p=/^-ms-/,q=/-([\da-z])/gi,r=function(a,b){return b.toUpperCase()};n.fn=n.prototype={jquery:m,constructor:n,selector:"",length:0,toArray:function(){return d.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=n.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return n.each(this,a,b)},map:function(a){return this.pushStack(n.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},n.extend=n.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||n.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(n.isPlainObject(d)||(e=n.isArray(d)))?(e?(e=!1,f=c&&n.isArray(c)?c:[]):f=c&&n.isPlainObject(c)?c:{},g[b]=n.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},n.extend({expando:"jQuery"+(m+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===n.type(a)},isArray:Array.isArray,isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){return!n.isArray(a)&&a-parseFloat(a)+1>=0},isPlainObject:function(a){return"object"!==n.type(a)||a.nodeType||n.isWindow(a)?!1:a.constructor&&!j.call(a.constructor.prototype,"isPrototypeOf")?!1:!0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(a){var b,c=eval;a=n.trim(a),a&&(1===a.indexOf("use strict")?(b=l.createElement("script"),b.text=a,l.head.appendChild(b).parentNode.removeChild(b)):c(a))},camelCase:function(a){return a.replace(p,"ms-").replace(q,r)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=s(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(o,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(s(Object(a))?n.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:g.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;c>d;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=s(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(c=a[b],b=a,a=c),n.isFunction(a)?(e=d.call(arguments,2),f=function(){return a.apply(b||this,e.concat(d.call(arguments)))},f.guid=a.guid=a.guid||n.guid++,f):void 0},now:Date.now,support:k}),n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function s(a){var b="length"in a&&a.length,c=n.type(a);return"function"===c||n.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var t=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C=1<<31,D={}.hasOwnProperty,E=[],F=E.pop,G=E.push,H=E.push,I=E.slice,J=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1},K="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",L="[\\x20\\t\\r\\n\\f]",M="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",N=M.replace("w","w#"),O="\\["+L+"*("+M+")(?:"+L+"*([*^$|!~]?=)"+L+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+N+"))|)"+L+"*\\]",P=":("+M+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+O+")*)|.*)\\)|)",Q=new RegExp(L+"+","g"),R=new RegExp("^"+L+"+|((?:^|[^\\\\])(?:\\\\.)*)"+L+"+$","g"),S=new RegExp("^"+L+"*,"+L+"*"),T=new RegExp("^"+L+"*([>+~]|"+L+")"+L+"*"),U=new RegExp("="+L+"*([^\\]'\"]*?)"+L+"*\\]","g"),V=new RegExp(P),W=new RegExp("^"+N+"$"),X={ID:new RegExp("^#("+M+")"),CLASS:new RegExp("^\\.("+M+")"),TAG:new RegExp("^("+M.replace("w","w*")+")"),ATTR:new RegExp("^"+O),PSEUDO:new RegExp("^"+P),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+L+"*(even|odd|(([+-]|)(\\d*)n|)"+L+"*(?:([+-]|)"+L+"*(\\d+)|))"+L+"*\\)|)","i"),bool:new RegExp("^(?:"+K+")$","i"),needsContext:new RegExp("^"+L+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+L+"*((?:-\\d)?\\d*)"+L+"*\\)|)(?=[^-]|$)","i")},Y=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,$=/^[^{]+\{\s*\[native \w/,_=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,aa=/[+~]/,ba=/'|\\/g,ca=new RegExp("\\\\([\\da-f]{1,6}"+L+"?|("+L+")|.)","ig"),da=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ea=function(){m()};try{H.apply(E=I.call(v.childNodes),v.childNodes),E[v.childNodes.length].nodeType}catch(fa){H={apply:E.length?function(a,b){G.apply(a,I.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s,w,x;if((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,d=d||[],k=b.nodeType,"string"!=typeof a||!a||1!==k&&9!==k&&11!==k)return d;if(!e&&p){if(11!==k&&(f=_.exec(a)))if(j=f[1]){if(9===k){if(h=b.getElementById(j),!h||!h.parentNode)return d;if(h.id===j)return d.push(h),d}else if(b.ownerDocument&&(h=b.ownerDocument.getElementById(j))&&t(b,h)&&h.id===j)return d.push(h),d}else{if(f[2])return H.apply(d,b.getElementsByTagName(a)),d;if((j=f[3])&&c.getElementsByClassName)return H.apply(d,b.getElementsByClassName(j)),d}if(c.qsa&&(!q||!q.test(a))){if(s=r=u,w=b,x=1!==k&&a,1===k&&"object"!==b.nodeName.toLowerCase()){o=g(a),(r=b.getAttribute("id"))?s=r.replace(ba,"\\$&"):b.setAttribute("id",s),s="[id='"+s+"'] ",l=o.length;while(l--)o[l]=s+ra(o[l]);w=aa.test(a)&&pa(b.parentNode)||b,x=o.join(",")}if(x)try{return H.apply(d,w.querySelectorAll(x)),d}catch(y){}finally{r||b.removeAttribute("id")}}}return i(a.replace(R,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||C)-(~a.sourceIndex||C);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function pa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=g.documentElement,e=g.defaultView,e&&e!==e.top&&(e.addEventListener?e.addEventListener("unload",ea,!1):e.attachEvent&&e.attachEvent("onunload",ea)),p=!f(g),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(g.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=$.test(g.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!g.getElementsByName||!g.getElementsByName(u).length}),c.getById?(d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return p?b.getElementsByClassName(a):void 0},r=[],q=[],(c.qsa=$.test(g.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="<a id='"+u+"'></a><select id='"+u+"-\f]' msallowcapture=''><option selected=''></option></select>",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+L+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+L+"*(?:value|"+K+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ja(function(a){var b=g.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+L+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=$.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ja(function(a){c.disconnectedMatch=s.call(a,"div"),s.call(a,"[s!='']:x"),r.push("!=",P)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=$.test(o.compareDocumentPosition),t=b||$.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===g||a.ownerDocument===v&&t(v,a)?-1:b===g||b.ownerDocument===v&&t(v,b)?1:k?J(k,a)-J(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,h=[a],i=[b];if(!e||!f)return a===g?-1:b===g?1:e?-1:f?1:k?J(k,a)-J(k,b):0;if(e===f)return la(a,b);c=a;while(c=c.parentNode)h.unshift(c);c=b;while(c=c.parentNode)i.unshift(c);while(h[d]===i[d])d++;return d?la(h[d],i[d]):h[d]===v?-1:i[d]===v?1:0},g):n},ga.matches=function(a,b){return ga(a,null,null,b)},ga.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(U,"='$1']"),!(!c.matchesSelector||!p||r&&r.test(b)||q&&q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return ga(b,n,null,[a]).length>0},ga.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},ga.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&D.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},ga.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},ga.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=ga.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=ga.selectors={cacheLength:50,createPseudo:ia,match:X,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ca,da),a[3]=(a[3]||a[4]||a[5]||"").replace(ca,da),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||ga.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&ga.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return X.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&V.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ca,da).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+L+")"+a+"("+L+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=ga.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(Q," ")+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h;if(q){if(f){while(p){l=b;while(l=l[p])if(h?l.nodeName.toLowerCase()===r:1===l.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){k=q[u]||(q[u]={}),j=k[a]||[],n=j[0]===w&&j[1],m=j[0]===w&&j[2],l=n&&q.childNodes[n];while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if(1===l.nodeType&&++m&&l===b){k[a]=[w,n,m];break}}else if(s&&(j=(b[u]||(b[u]={}))[a])&&j[0]===w)m=j[1];else while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if((h?l.nodeName.toLowerCase()===r:1===l.nodeType)&&++m&&(s&&((l[u]||(l[u]={}))[a]=[w,m]),l===b))break;return m-=e,m===d||m%d===0&&m/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||ga.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ia(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=J(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ia(function(a){var b=[],c=[],d=h(a.replace(R,"$1"));return d[u]?ia(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ia(function(a){return function(b){return ga(a,b).length>0}}),contains:ia(function(a){return a=a.replace(ca,da),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ia(function(a){return W.test(a||"")||ga.error("unsupported lang: "+a),a=a.replace(ca,da).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return Z.test(a.nodeName)},input:function(a){return Y.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:oa(function(){return[0]}),last:oa(function(a,b){return[b-1]}),eq:oa(function(a,b,c){return[0>c?c+b:c]}),even:oa(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:oa(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:oa(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:oa(function(a,b,c){for(var d=0>c?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=ma(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=na(b);function qa(){}qa.prototype=d.filters=d.pseudos,d.setFilters=new qa,g=ga.tokenize=function(a,b){var c,e,f,g,h,i,j,k=z[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){(!c||(e=S.exec(h)))&&(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=T.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(R," ")}),h=h.slice(c.length));for(g in d.filter)!(e=X[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?ga.error(a):z(a,i).slice(0)};function ra(a){for(var b=0,c=a.length,d="";c>b;b++)d+=a[b].value;return d}function sa(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=x++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[w,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[u]||(b[u]={}),(h=i[d])&&h[0]===w&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function ta(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function ua(a,b,c){for(var d=0,e=b.length;e>d;d++)ga(a,b[d],c);return c}function va(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function wa(a,b,c,d,e,f){return d&&!d[u]&&(d=wa(d)),e&&!e[u]&&(e=wa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||ua(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:va(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=va(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?J(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=va(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):H.apply(g,r)})}function xa(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=sa(function(a){return a===b},h,!0),l=sa(function(a){return J(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];f>i;i++)if(c=d.relative[a[i].type])m=[sa(ta(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;f>e;e++)if(d.relative[a[e].type])break;return wa(i>1&&ta(m),i>1&&ra(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(R,"$1"),c,e>i&&xa(a.slice(i,e)),f>e&&xa(a=a.slice(e)),f>e&&ra(a))}m.push(c)}return ta(m)}function ya(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,m,o,p=0,q="0",r=f&&[],s=[],t=j,u=f||e&&d.find.TAG("*",k),v=w+=null==t?1:Math.random()||.1,x=u.length;for(k&&(j=g!==n&&g);q!==x&&null!=(l=u[q]);q++){if(e&&l){m=0;while(o=a[m++])if(o(l,g,h)){i.push(l);break}k&&(w=v)}c&&((l=!o&&l)&&p--,f&&r.push(l))}if(p+=q,c&&q!==p){m=0;while(o=b[m++])o(r,s,g,h);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=F.call(i));s=va(s)}H.apply(i,s),k&&!f&&s.length>0&&p+b.length>1&&ga.uniqueSort(i)}return k&&(w=v,j=t),r};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=xa(b[c]),f[u]?d.push(f):e.push(f);f=A(a,ya(e,d)),f.selector=a}return f},i=ga.select=function(a,b,e,f){var i,j,k,l,m,n="function"==typeof a&&a,o=!f&&g(a=n.selector||a);if(e=e||[],1===o.length){if(j=o[0]=o[0].slice(0),j.length>2&&"ID"===(k=j[0]).type&&c.getById&&9===b.nodeType&&p&&d.relative[j[1].type]){if(b=(d.find.ID(k.matches[0].replace(ca,da),b)||[])[0],!b)return e;n&&(b=b.parentNode),a=a.slice(j.shift().value.length)}i=X.needsContext.test(a)?0:j.length;while(i--){if(k=j[i],d.relative[l=k.type])break;if((m=d.find[l])&&(f=m(k.matches[0].replace(ca,da),aa.test(j[0].type)&&pa(b.parentNode)||b))){if(j.splice(i,1),a=f.length&&ra(j),!a)return H.apply(e,f),e;break}}}return(n||h(a,o))(f,b,!p,e,aa.test(a)&&pa(b.parentNode)||b),e},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("div"))}),ja(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||ka("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ja(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ka("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),ja(function(a){return null==a.getAttribute("disabled")})||ka(K,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),ga}(a);n.find=t,n.expr=t.selectors,n.expr[":"]=n.expr.pseudos,n.unique=t.uniqueSort,n.text=t.getText,n.isXMLDoc=t.isXML,n.contains=t.contains;var u=n.expr.match.needsContext,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^.[^:#\[\.,]*$/;function x(a,b,c){if(n.isFunction(b))return n.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return n.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(w.test(b))return n.filter(b,a,c);b=n.filter(b,a)}return n.grep(a,function(a){return g.call(b,a)>=0!==c})}n.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?n.find.matchesSelector(d,a)?[d]:[]:n.find.matches(a,n.grep(b,function(a){return 1===a.nodeType}))},n.fn.extend({find:function(a){var b,c=this.length,d=[],e=this;if("string"!=typeof a)return this.pushStack(n(a).filter(function(){for(b=0;c>b;b++)if(n.contains(e[b],this))return!0}));for(b=0;c>b;b++)n.find(a,e[b],d);return d=this.pushStack(c>1?n.unique(d):d),d.selector=this.selector?this.selector+" "+a:a,d},filter:function(a){return this.pushStack(x(this,a||[],!1))},not:function(a){return this.pushStack(x(this,a||[],!0))},is:function(a){return!!x(this,"string"==typeof a&&u.test(a)?n(a):a||[],!1).length}});var y,z=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,A=n.fn.init=function(a,b){var c,d;if(!a)return this;if("string"==typeof a){if(c="<"===a[0]&&">"===a[a.length-1]&&a.length>=3?[null,a,null]:z.exec(a),!c||!c[1]&&b)return!b||b.jquery?(b||y).find(a):this.constructor(b).find(a);if(c[1]){if(b=b instanceof n?b[0]:b,n.merge(this,n.parseHTML(c[1],b&&b.nodeType?b.ownerDocument||b:l,!0)),v.test(c[1])&&n.isPlainObject(b))for(c in b)n.isFunction(this[c])?this[c](b[c]):this.attr(c,b[c]);return this}return d=l.getElementById(c[2]),d&&d.parentNode&&(this.length=1,this[0]=d),this.context=l,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):n.isFunction(a)?"undefined"!=typeof y.ready?y.ready(a):a(n):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),n.makeArray(a,this))};A.prototype=n.fn,y=n(l);var B=/^(?:parents|prev(?:Until|All))/,C={children:!0,contents:!0,next:!0,prev:!0};n.extend({dir:function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&n(a).is(c))break;d.push(a)}return d},sibling:function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c}}),n.fn.extend({has:function(a){var b=n(a,this),c=b.length;return this.filter(function(){for(var a=0;c>a;a++)if(n.contains(this,b[a]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=u.test(a)||"string"!=typeof a?n(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&n.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?n.unique(f):f)},index:function(a){return a?"string"==typeof a?g.call(n(a),this[0]):g.call(this,a.jquery?a[0]:a):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(n.unique(n.merge(this.get(),n(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function D(a,b){while((a=a[b])&&1!==a.nodeType);return a}n.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return n.dir(a,"parentNode")},parentsUntil:function(a,b,c){return n.dir(a,"parentNode",c)},next:function(a){return D(a,"nextSibling")},prev:function(a){return D(a,"previousSibling")},nextAll:function(a){return n.dir(a,"nextSibling")},prevAll:function(a){return n.dir(a,"previousSibling")},nextUntil:function(a,b,c){return n.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return n.dir(a,"previousSibling",c)},siblings:function(a){return n.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return n.sibling(a.firstChild)},contents:function(a){return a.contentDocument||n.merge([],a.childNodes)}},function(a,b){n.fn[a]=function(c,d){var e=n.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=n.filter(d,e)),this.length>1&&(C[a]||n.unique(e),B.test(a)&&e.reverse()),this.pushStack(e)}});var E=/\S+/g,F={};function G(a){var b=F[a]={};return n.each(a.match(E)||[],function(a,c){b[c]=!0}),b}n.Callbacks=function(a){a="string"==typeof a?F[a]||G(a):n.extend({},a);var b,c,d,e,f,g,h=[],i=!a.once&&[],j=function(l){for(b=a.memory&&l,c=!0,g=e||0,e=0,f=h.length,d=!0;h&&f>g;g++)if(h[g].apply(l[0],l[1])===!1&&a.stopOnFalse){b=!1;break}d=!1,h&&(i?i.length&&j(i.shift()):b?h=[]:k.disable())},k={add:function(){if(h){var c=h.length;!function g(b){n.each(b,function(b,c){var d=n.type(c);"function"===d?a.unique&&k.has(c)||h.push(c):c&&c.length&&"string"!==d&&g(c)})}(arguments),d?f=h.length:b&&(e=c,j(b))}return this},remove:function(){return h&&n.each(arguments,function(a,b){var c;while((c=n.inArray(b,h,c))>-1)h.splice(c,1),d&&(f>=c&&f--,g>=c&&g--)}),this},has:function(a){return a?n.inArray(a,h)>-1:!(!h||!h.length)},empty:function(){return h=[],f=0,this},disable:function(){return h=i=b=void 0,this},disabled:function(){return!h},lock:function(){return i=void 0,b||k.disable(),this},locked:function(){return!i},fireWith:function(a,b){return!h||c&&!i||(b=b||[],b=[a,b.slice?b.slice():b],d?i.push(b):j(b)),this},fire:function(){return k.fireWith(this,arguments),this},fired:function(){return!!c}};return k},n.extend({Deferred:function(a){var b=[["resolve","done",n.Callbacks("once memory"),"resolved"],["reject","fail",n.Callbacks("once memory"),"rejected"],["notify","progress",n.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return n.Deferred(function(c){n.each(b,function(b,f){var g=n.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&n.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?n.extend(a,d):d}},e={};return d.pipe=d.then,n.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=d.call(arguments),e=c.length,f=1!==e||a&&n.isFunction(a.promise)?e:0,g=1===f?a:n.Deferred(),h=function(a,b,c){return function(e){b[a]=this,c[a]=arguments.length>1?d.call(arguments):e,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(e>1)for(i=new Array(e),j=new Array(e),k=new Array(e);e>b;b++)c[b]&&n.isFunction(c[b].promise)?c[b].promise().done(h(b,k,c)).fail(g.reject).progress(h(b,j,i)):--f;return f||g.resolveWith(k,c),g.promise()}});var H;n.fn.ready=function(a){return n.ready.promise().done(a),this},n.extend({isReady:!1,readyWait:1,holdReady:function(a){a?n.readyWait++:n.ready(!0)},ready:function(a){(a===!0?--n.readyWait:n.isReady)||(n.isReady=!0,a!==!0&&--n.readyWait>0||(H.resolveWith(l,[n]),n.fn.triggerHandler&&(n(l).triggerHandler("ready"),n(l).off("ready"))))}});function I(){l.removeEventListener("DOMContentLoaded",I,!1),a.removeEventListener("load",I,!1),n.ready()}n.ready.promise=function(b){return H||(H=n.Deferred(),"complete"===l.readyState?setTimeout(n.ready):(l.addEventListener("DOMContentLoaded",I,!1),a.addEventListener("load",I,!1))),H.promise(b)},n.ready.promise();var J=n.access=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===n.type(c)){e=!0;for(h in c)n.access(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,n.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(n(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f};n.acceptData=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function K(){Object.defineProperty(this.cache={},0,{get:function(){return{}}}),this.expando=n.expando+K.uid++}K.uid=1,K.accepts=n.acceptData,K.prototype={key:function(a){if(!K.accepts(a))return 0;var b={},c=a[this.expando];if(!c){c=K.uid++;try{b[this.expando]={value:c},Object.defineProperties(a,b)}catch(d){b[this.expando]=c,n.extend(a,b)}}return this.cache[c]||(this.cache[c]={}),c},set:function(a,b,c){var d,e=this.key(a),f=this.cache[e];if("string"==typeof b)f[b]=c;else if(n.isEmptyObject(f))n.extend(this.cache[e],b);else for(d in b)f[d]=b[d];return f},get:function(a,b){var c=this.cache[this.key(a)];return void 0===b?c:c[b]},access:function(a,b,c){var d;return void 0===b||b&&"string"==typeof b&&void 0===c?(d=this.get(a,b),void 0!==d?d:this.get(a,n.camelCase(b))):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d,e,f=this.key(a),g=this.cache[f];if(void 0===b)this.cache[f]={};else{n.isArray(b)?d=b.concat(b.map(n.camelCase)):(e=n.camelCase(b),b in g?d=[b,e]:(d=e,d=d in g?[d]:d.match(E)||[])),c=d.length;while(c--)delete g[d[c]]}},hasData:function(a){return!n.isEmptyObject(this.cache[a[this.expando]]||{})},discard:function(a){a[this.expando]&&delete this.cache[a[this.expando]]}};var L=new K,M=new K,N=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,O=/([A-Z])/g;function P(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(O,"-$1").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:N.test(c)?n.parseJSON(c):c}catch(e){}M.set(a,b,c)}else c=void 0;return c}n.extend({hasData:function(a){return M.hasData(a)||L.hasData(a)},data:function(a,b,c){
+return M.access(a,b,c)},removeData:function(a,b){M.remove(a,b)},_data:function(a,b,c){return L.access(a,b,c)},_removeData:function(a,b){L.remove(a,b)}}),n.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=M.get(f),1===f.nodeType&&!L.get(f,"hasDataAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=n.camelCase(d.slice(5)),P(f,d,e[d])));L.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){M.set(this,a)}):J(this,function(b){var c,d=n.camelCase(a);if(f&&void 0===b){if(c=M.get(f,a),void 0!==c)return c;if(c=M.get(f,d),void 0!==c)return c;if(c=P(f,d,void 0),void 0!==c)return c}else this.each(function(){var c=M.get(this,d);M.set(this,d,b),-1!==a.indexOf("-")&&void 0!==c&&M.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){M.remove(this,a)})}}),n.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=L.get(a,b),c&&(!d||n.isArray(c)?d=L.access(a,b,n.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=n.queue(a,b),d=c.length,e=c.shift(),f=n._queueHooks(a,b),g=function(){n.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return L.get(a,c)||L.access(a,c,{empty:n.Callbacks("once memory").add(function(){L.remove(a,[b+"queue",c])})})}}),n.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?n.queue(this[0],a):void 0===b?this:this.each(function(){var c=n.queue(this,a,b);n._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&n.dequeue(this,a)})},dequeue:function(a){return this.each(function(){n.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=n.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=L.get(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var Q=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,R=["Top","Right","Bottom","Left"],S=function(a,b){return a=b||a,"none"===n.css(a,"display")||!n.contains(a.ownerDocument,a)},T=/^(?:checkbox|radio)$/i;!function(){var a=l.createDocumentFragment(),b=a.appendChild(l.createElement("div")),c=l.createElement("input");c.setAttribute("type","radio"),c.setAttribute("checked","checked"),c.setAttribute("name","t"),b.appendChild(c),k.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,b.innerHTML="<textarea>x</textarea>",k.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var U="undefined";k.focusinBubbles="onfocusin"in a;var V=/^key/,W=/^(?:mouse|pointer|contextmenu)|click/,X=/^(?:focusinfocus|focusoutblur)$/,Y=/^([^.]*)(?:\.(.+)|)$/;function Z(){return!0}function $(){return!1}function _(){try{return l.activeElement}catch(a){}}n.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=L.get(a);if(r){c.handler&&(f=c,c=f.handler,e=f.selector),c.guid||(c.guid=n.guid++),(i=r.events)||(i=r.events={}),(g=r.handle)||(g=r.handle=function(b){return typeof n!==U&&n.event.triggered!==b.type?n.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(E)||[""],j=b.length;while(j--)h=Y.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o&&(l=n.event.special[o]||{},o=(e?l.delegateType:l.bindType)||o,l=n.event.special[o]||{},k=n.extend({type:o,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&n.expr.match.needsContext.test(e),namespace:p.join(".")},f),(m=i[o])||(m=i[o]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,p,g)!==!1||a.addEventListener&&a.addEventListener(o,g,!1)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),n.event.global[o]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=L.hasData(a)&&L.get(a);if(r&&(i=r.events)){b=(b||"").match(E)||[""],j=b.length;while(j--)if(h=Y.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o){l=n.event.special[o]||{},o=(d?l.delegateType:l.bindType)||o,m=i[o]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&q!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||n.removeEvent(a,o,r.handle),delete i[o])}else for(o in i)n.event.remove(a,o+b[j],c,d,!0);n.isEmptyObject(i)&&(delete r.handle,L.remove(a,"events"))}},trigger:function(b,c,d,e){var f,g,h,i,k,m,o,p=[d||l],q=j.call(b,"type")?b.type:b,r=j.call(b,"namespace")?b.namespace.split("."):[];if(g=h=d=d||l,3!==d.nodeType&&8!==d.nodeType&&!X.test(q+n.event.triggered)&&(q.indexOf(".")>=0&&(r=q.split("."),q=r.shift(),r.sort()),k=q.indexOf(":")<0&&"on"+q,b=b[n.expando]?b:new n.Event(q,"object"==typeof b&&b),b.isTrigger=e?2:3,b.namespace=r.join("."),b.namespace_re=b.namespace?new RegExp("(^|\\.)"+r.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=d),c=null==c?[b]:n.makeArray(c,[b]),o=n.event.special[q]||{},e||!o.trigger||o.trigger.apply(d,c)!==!1)){if(!e&&!o.noBubble&&!n.isWindow(d)){for(i=o.delegateType||q,X.test(i+q)||(g=g.parentNode);g;g=g.parentNode)p.push(g),h=g;h===(d.ownerDocument||l)&&p.push(h.defaultView||h.parentWindow||a)}f=0;while((g=p[f++])&&!b.isPropagationStopped())b.type=f>1?i:o.bindType||q,m=(L.get(g,"events")||{})[b.type]&&L.get(g,"handle"),m&&m.apply(g,c),m=k&&g[k],m&&m.apply&&n.acceptData(g)&&(b.result=m.apply(g,c),b.result===!1&&b.preventDefault());return b.type=q,e||b.isDefaultPrevented()||o._default&&o._default.apply(p.pop(),c)!==!1||!n.acceptData(d)||k&&n.isFunction(d[q])&&!n.isWindow(d)&&(h=d[k],h&&(d[k]=null),n.event.triggered=q,d[q](),n.event.triggered=void 0,h&&(d[k]=h)),b.result}},dispatch:function(a){a=n.event.fix(a);var b,c,e,f,g,h=[],i=d.call(arguments),j=(L.get(this,"events")||{})[a.type]||[],k=n.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=n.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,c=0;while((g=f.handlers[c++])&&!a.isImmediatePropagationStopped())(!a.namespace_re||a.namespace_re.test(g.namespace))&&(a.handleObj=g,a.data=g.data,e=((n.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==e&&(a.result=e)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&(!a.button||"click"!==a.type))for(;i!==this;i=i.parentNode||this)if(i.disabled!==!0||"click"!==a.type){for(d=[],c=0;h>c;c++)f=b[c],e=f.selector+" ",void 0===d[e]&&(d[e]=f.needsContext?n(e,this).index(i)>=0:n.find(e,this,null,[i]).length),d[e]&&d.push(f);d.length&&g.push({elem:i,handlers:d})}return h<b.length&&g.push({elem:this,handlers:b.slice(h)}),g},props:"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return null==a.which&&(a.which=null!=b.charCode?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,b){var c,d,e,f=b.button;return null==a.pageX&&null!=b.clientX&&(c=a.target.ownerDocument||l,d=c.documentElement,e=c.body,a.pageX=b.clientX+(d&&d.scrollLeft||e&&e.scrollLeft||0)-(d&&d.clientLeft||e&&e.clientLeft||0),a.pageY=b.clientY+(d&&d.scrollTop||e&&e.scrollTop||0)-(d&&d.clientTop||e&&e.clientTop||0)),a.which||void 0===f||(a.which=1&f?1:2&f?3:4&f?2:0),a}},fix:function(a){if(a[n.expando])return a;var b,c,d,e=a.type,f=a,g=this.fixHooks[e];g||(this.fixHooks[e]=g=W.test(e)?this.mouseHooks:V.test(e)?this.keyHooks:{}),d=g.props?this.props.concat(g.props):this.props,a=new n.Event(f),b=d.length;while(b--)c=d[b],a[c]=f[c];return a.target||(a.target=l),3===a.target.nodeType&&(a.target=a.target.parentNode),g.filter?g.filter(a,f):a},special:{load:{noBubble:!0},focus:{trigger:function(){return this!==_()&&this.focus?(this.focus(),!1):void 0},delegateType:"focusin"},blur:{trigger:function(){return this===_()&&this.blur?(this.blur(),!1):void 0},delegateType:"focusout"},click:{trigger:function(){return"checkbox"===this.type&&this.click&&n.nodeName(this,"input")?(this.click(),!1):void 0},_default:function(a){return n.nodeName(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&a.originalEvent&&(a.originalEvent.returnValue=a.result)}}},simulate:function(a,b,c,d){var e=n.extend(new n.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?n.event.trigger(e,null,b):n.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},n.removeEvent=function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)},n.Event=function(a,b){return this instanceof n.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&a.returnValue===!1?Z:$):this.type=a,b&&n.extend(this,b),this.timeStamp=a&&a.timeStamp||n.now(),void(this[n.expando]=!0)):new n.Event(a,b)},n.Event.prototype={isDefaultPrevented:$,isPropagationStopped:$,isImmediatePropagationStopped:$,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=Z,a&&a.preventDefault&&a.preventDefault()},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=Z,a&&a.stopPropagation&&a.stopPropagation()},stopImmediatePropagation:function(){var a=this.originalEvent;this.isImmediatePropagationStopped=Z,a&&a.stopImmediatePropagation&&a.stopImmediatePropagation(),this.stopPropagation()}},n.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(a,b){n.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return(!e||e!==d&&!n.contains(d,e))&&(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),k.focusinBubbles||n.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){n.event.simulate(b,a.target,n.event.fix(a),!0)};n.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=L.access(d,b);e||d.addEventListener(a,c,!0),L.access(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=L.access(d,b)-1;e?L.access(d,b,e):(d.removeEventListener(a,c,!0),L.remove(d,b))}}}),n.fn.extend({on:function(a,b,c,d,e){var f,g;if("object"==typeof a){"string"!=typeof b&&(c=c||b,b=void 0);for(g in a)this.on(g,b,c,a[g],e);return this}if(null==c&&null==d?(d=b,c=b=void 0):null==d&&("string"==typeof b?(d=c,c=void 0):(d=c,c=b,b=void 0)),d===!1)d=$;else if(!d)return this;return 1===e&&(f=d,d=function(a){return n().off(a),f.apply(this,arguments)},d.guid=f.guid||(f.guid=n.guid++)),this.each(function(){n.event.add(this,a,d,c,b)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,n(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return(b===!1||"function"==typeof b)&&(c=b,b=void 0),c===!1&&(c=$),this.each(function(){n.event.remove(this,a,c,b)})},trigger:function(a,b){return this.each(function(){n.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];return c?n.event.trigger(a,b,c,!0):void 0}});var aa=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,ba=/<([\w:]+)/,ca=/<|&#?\w+;/,da=/<(?:script|style|link)/i,ea=/checked\s*(?:[^=]|=\s*.checked.)/i,fa=/^$|\/(?:java|ecma)script/i,ga=/^true\/(.*)/,ha=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,ia={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};ia.optgroup=ia.option,ia.tbody=ia.tfoot=ia.colgroup=ia.caption=ia.thead,ia.th=ia.td;function ja(a,b){return n.nodeName(a,"table")&&n.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function ka(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function la(a){var b=ga.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function ma(a,b){for(var c=0,d=a.length;d>c;c++)L.set(a[c],"globalEval",!b||L.get(b[c],"globalEval"))}function na(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(L.hasData(a)&&(f=L.access(a),g=L.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;d>c;c++)n.event.add(b,e,j[e][c])}M.hasData(a)&&(h=M.access(a),i=n.extend({},h),M.set(b,i))}}function oa(a,b){var c=a.getElementsByTagName?a.getElementsByTagName(b||"*"):a.querySelectorAll?a.querySelectorAll(b||"*"):[];return void 0===b||b&&n.nodeName(a,b)?n.merge([a],c):c}function pa(a,b){var c=b.nodeName.toLowerCase();"input"===c&&T.test(a.type)?b.checked=a.checked:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}n.extend({clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=n.contains(a.ownerDocument,a);if(!(k.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||n.isXMLDoc(a)))for(g=oa(h),f=oa(a),d=0,e=f.length;e>d;d++)pa(f[d],g[d]);if(b)if(c)for(f=f||oa(a),g=g||oa(h),d=0,e=f.length;e>d;d++)na(f[d],g[d]);else na(a,h);return g=oa(h,"script"),g.length>0&&ma(g,!i&&oa(a,"script")),h},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,k=b.createDocumentFragment(),l=[],m=0,o=a.length;o>m;m++)if(e=a[m],e||0===e)if("object"===n.type(e))n.merge(l,e.nodeType?[e]:e);else if(ca.test(e)){f=f||k.appendChild(b.createElement("div")),g=(ba.exec(e)||["",""])[1].toLowerCase(),h=ia[g]||ia._default,f.innerHTML=h[1]+e.replace(aa,"<$1></$2>")+h[2],j=h[0];while(j--)f=f.lastChild;n.merge(l,f.childNodes),f=k.firstChild,f.textContent=""}else l.push(b.createTextNode(e));k.textContent="",m=0;while(e=l[m++])if((!d||-1===n.inArray(e,d))&&(i=n.contains(e.ownerDocument,e),f=oa(k.appendChild(e),"script"),i&&ma(f),c)){j=0;while(e=f[j++])fa.test(e.type||"")&&c.push(e)}return k},cleanData:function(a){for(var b,c,d,e,f=n.event.special,g=0;void 0!==(c=a[g]);g++){if(n.acceptData(c)&&(e=c[L.expando],e&&(b=L.cache[e]))){if(b.events)for(d in b.events)f[d]?n.event.remove(c,d):n.removeEvent(c,d,b.handle);L.cache[e]&&delete L.cache[e]}delete M.cache[c[M.expando]]}}}),n.fn.extend({text:function(a){return J(this,function(a){return void 0===a?n.text(this):this.empty().each(function(){(1===this.nodeType||11===this.nodeType||9===this.nodeType)&&(this.textContent=a)})},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=ja(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=ja(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?n.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||n.cleanData(oa(c)),c.parentNode&&(b&&n.contains(c.ownerDocument,c)&&ma(oa(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(n.cleanData(oa(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return n.clone(this,a,b)})},html:function(a){return J(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!da.test(a)&&!ia[(ba.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(aa,"<$1></$2>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(n.cleanData(oa(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,n.cleanData(oa(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,l=this.length,m=this,o=l-1,p=a[0],q=n.isFunction(p);if(q||l>1&&"string"==typeof p&&!k.checkClone&&ea.test(p))return this.each(function(c){var d=m.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(l&&(c=n.buildFragment(a,this[0].ownerDocument,!1,this),d=c.firstChild,1===c.childNodes.length&&(c=d),d)){for(f=n.map(oa(c,"script"),ka),g=f.length;l>j;j++)h=c,j!==o&&(h=n.clone(h,!0,!0),g&&n.merge(f,oa(h,"script"))),b.call(this[j],h,j);if(g)for(i=f[f.length-1].ownerDocument,n.map(f,la),j=0;g>j;j++)h=f[j],fa.test(h.type||"")&&!L.access(h,"globalEval")&&n.contains(i,h)&&(h.src?n._evalUrl&&n._evalUrl(h.src):n.globalEval(h.textContent.replace(ha,"")))}return this}}),n.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){n.fn[a]=function(a){for(var c,d=[],e=n(a),g=e.length-1,h=0;g>=h;h++)c=h===g?this:this.clone(!0),n(e[h])[b](c),f.apply(d,c.get());return this.pushStack(d)}});var qa,ra={};function sa(b,c){var d,e=n(c.createElement(b)).appendTo(c.body),f=a.getDefaultComputedStyle&&(d=a.getDefaultComputedStyle(e[0]))?d.display:n.css(e[0],"display");return e.detach(),f}function ta(a){var b=l,c=ra[a];return c||(c=sa(a,b),"none"!==c&&c||(qa=(qa||n("<iframe frameborder='0' width='0' height='0'/>")).appendTo(b.documentElement),b=qa[0].contentDocument,b.write(),b.close(),c=sa(a,b),qa.detach()),ra[a]=c),c}var ua=/^margin/,va=new RegExp("^("+Q+")(?!px)[a-z%]+$","i"),wa=function(b){return b.ownerDocument.defaultView.opener?b.ownerDocument.defaultView.getComputedStyle(b,null):a.getComputedStyle(b,null)};function xa(a,b,c){var d,e,f,g,h=a.style;return c=c||wa(a),c&&(g=c.getPropertyValue(b)||c[b]),c&&(""!==g||n.contains(a.ownerDocument,a)||(g=n.style(a,b)),va.test(g)&&ua.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0!==g?g+"":g}function ya(a,b){return{get:function(){return a()?void delete this.get:(this.get=b).apply(this,arguments)}}}!function(){var b,c,d=l.documentElement,e=l.createElement("div"),f=l.createElement("div");if(f.style){f.style.backgroundClip="content-box",f.cloneNode(!0).style.backgroundClip="",k.clearCloneStyle="content-box"===f.style.backgroundClip,e.style.cssText="border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;position:absolute",e.appendChild(f);function g(){f.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;margin-top:1%;top:1%;border:1px;padding:1px;width:4px;position:absolute",f.innerHTML="",d.appendChild(e);var g=a.getComputedStyle(f,null);b="1%"!==g.top,c="4px"===g.width,d.removeChild(e)}a.getComputedStyle&&n.extend(k,{pixelPosition:function(){return g(),b},boxSizingReliable:function(){return null==c&&g(),c},reliableMarginRight:function(){var b,c=f.appendChild(l.createElement("div"));return c.style.cssText=f.style.cssText="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:0",c.style.marginRight=c.style.width="0",f.style.width="1px",d.appendChild(e),b=!parseFloat(a.getComputedStyle(c,null).marginRight),d.removeChild(e),f.removeChild(c),b}})}}(),n.swap=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};var za=/^(none|table(?!-c[ea]).+)/,Aa=new RegExp("^("+Q+")(.*)$","i"),Ba=new RegExp("^([+-])=("+Q+")","i"),Ca={position:"absolute",visibility:"hidden",display:"block"},Da={letterSpacing:"0",fontWeight:"400"},Ea=["Webkit","O","Moz","ms"];function Fa(a,b){if(b in a)return b;var c=b[0].toUpperCase()+b.slice(1),d=b,e=Ea.length;while(e--)if(b=Ea[e]+c,b in a)return b;return d}function Ga(a,b,c){var d=Aa.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function Ha(a,b,c,d,e){for(var f=c===(d?"border":"content")?4:"width"===b?1:0,g=0;4>f;f+=2)"margin"===c&&(g+=n.css(a,c+R[f],!0,e)),d?("content"===c&&(g-=n.css(a,"padding"+R[f],!0,e)),"margin"!==c&&(g-=n.css(a,"border"+R[f]+"Width",!0,e))):(g+=n.css(a,"padding"+R[f],!0,e),"padding"!==c&&(g+=n.css(a,"border"+R[f]+"Width",!0,e)));return g}function Ia(a,b,c){var d=!0,e="width"===b?a.offsetWidth:a.offsetHeight,f=wa(a),g="border-box"===n.css(a,"boxSizing",!1,f);if(0>=e||null==e){if(e=xa(a,b,f),(0>e||null==e)&&(e=a.style[b]),va.test(e))return e;d=g&&(k.boxSizingReliable()||e===a.style[b]),e=parseFloat(e)||0}return e+Ha(a,b,c||(g?"border":"content"),d,f)+"px"}function Ja(a,b){for(var c,d,e,f=[],g=0,h=a.length;h>g;g++)d=a[g],d.style&&(f[g]=L.get(d,"olddisplay"),c=d.style.display,b?(f[g]||"none"!==c||(d.style.display=""),""===d.style.display&&S(d)&&(f[g]=L.access(d,"olddisplay",ta(d.nodeName)))):(e=S(d),"none"===c&&e||L.set(d,"olddisplay",e?c:n.css(d,"display"))));for(g=0;h>g;g++)d=a[g],d.style&&(b&&"none"!==d.style.display&&""!==d.style.display||(d.style.display=b?f[g]||"":"none"));return a}n.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=xa(a,"opacity");return""===c?"1":c}}}},cssNumber:{columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":"cssFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=n.camelCase(b),i=a.style;return b=n.cssProps[h]||(n.cssProps[h]=Fa(i,h)),g=n.cssHooks[b]||n.cssHooks[h],void 0===c?g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:i[b]:(f=typeof c,"string"===f&&(e=Ba.exec(c))&&(c=(e[1]+1)*e[2]+parseFloat(n.css(a,b)),f="number"),null!=c&&c===c&&("number"!==f||n.cssNumber[h]||(c+="px"),k.clearCloneStyle||""!==c||0!==b.indexOf("background")||(i[b]="inherit"),g&&"set"in g&&void 0===(c=g.set(a,c,d))||(i[b]=c)),void 0)}},css:function(a,b,c,d){var e,f,g,h=n.camelCase(b);return b=n.cssProps[h]||(n.cssProps[h]=Fa(a.style,h)),g=n.cssHooks[b]||n.cssHooks[h],g&&"get"in g&&(e=g.get(a,!0,c)),void 0===e&&(e=xa(a,b,d)),"normal"===e&&b in Da&&(e=Da[b]),""===c||c?(f=parseFloat(e),c===!0||n.isNumeric(f)?f||0:e):e}}),n.each(["height","width"],function(a,b){n.cssHooks[b]={get:function(a,c,d){return c?za.test(n.css(a,"display"))&&0===a.offsetWidth?n.swap(a,Ca,function(){return Ia(a,b,d)}):Ia(a,b,d):void 0},set:function(a,c,d){var e=d&&wa(a);return Ga(a,c,d?Ha(a,b,d,"border-box"===n.css(a,"boxSizing",!1,e),e):0)}}}),n.cssHooks.marginRight=ya(k.reliableMarginRight,function(a,b){return b?n.swap(a,{display:"inline-block"},xa,[a,"marginRight"]):void 0}),n.each({margin:"",padding:"",border:"Width"},function(a,b){n.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];4>d;d++)e[a+R[d]+b]=f[d]||f[d-2]||f[0];return e}},ua.test(a)||(n.cssHooks[a+b].set=Ga)}),n.fn.extend({css:function(a,b){return J(this,function(a,b,c){var d,e,f={},g=0;if(n.isArray(b)){for(d=wa(a),e=b.length;e>g;g++)f[b[g]]=n.css(a,b[g],!1,d);return f}return void 0!==c?n.style(a,b,c):n.css(a,b)},a,b,arguments.length>1)},show:function(){return Ja(this,!0)},hide:function(){return Ja(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){S(this)?n(this).show():n(this).hide()})}});function Ka(a,b,c,d,e){return new Ka.prototype.init(a,b,c,d,e)}n.Tween=Ka,Ka.prototype={constructor:Ka,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(n.cssNumber[c]?"":"px")},cur:function(){var a=Ka.propHooks[this.prop];return a&&a.get?a.get(this):Ka.propHooks._default.get(this)},run:function(a){var b,c=Ka.propHooks[this.prop];return this.options.duration?this.pos=b=n.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):Ka.propHooks._default.set(this),this}},Ka.prototype.init.prototype=Ka.prototype,Ka.propHooks={_default:{get:function(a){var b;return null==a.elem[a.prop]||a.elem.style&&null!=a.elem.style[a.prop]?(b=n.css(a.elem,a.prop,""),b&&"auto"!==b?b:0):a.elem[a.prop]},set:function(a){n.fx.step[a.prop]?n.fx.step[a.prop](a):a.elem.style&&(null!=a.elem.style[n.cssProps[a.prop]]||n.cssHooks[a.prop])?n.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},Ka.propHooks.scrollTop=Ka.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},n.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},n.fx=Ka.prototype.init,n.fx.step={};var La,Ma,Na=/^(?:toggle|show|hide)$/,Oa=new RegExp("^(?:([+-])=|)("+Q+")([a-z%]*)$","i"),Pa=/queueHooks$/,Qa=[Va],Ra={"*":[function(a,b){var c=this.createTween(a,b),d=c.cur(),e=Oa.exec(b),f=e&&e[3]||(n.cssNumber[a]?"":"px"),g=(n.cssNumber[a]||"px"!==f&&+d)&&Oa.exec(n.css(c.elem,a)),h=1,i=20;if(g&&g[3]!==f){f=f||g[3],e=e||[],g=+d||1;do h=h||".5",g/=h,n.style(c.elem,a,g+f);while(h!==(h=c.cur()/d)&&1!==h&&--i)}return e&&(g=c.start=+g||+d||0,c.unit=f,c.end=e[1]?g+(e[1]+1)*e[2]:+e[2]),c}]};function Sa(){return setTimeout(function(){La=void 0}),La=n.now()}function Ta(a,b){var c,d=0,e={height:a};for(b=b?1:0;4>d;d+=2-b)c=R[d],e["margin"+c]=e["padding"+c]=a;return b&&(e.opacity=e.width=a),e}function Ua(a,b,c){for(var d,e=(Ra[b]||[]).concat(Ra["*"]),f=0,g=e.length;g>f;f++)if(d=e[f].call(c,b,a))return d}function Va(a,b,c){var d,e,f,g,h,i,j,k,l=this,m={},o=a.style,p=a.nodeType&&S(a),q=L.get(a,"fxshow");c.queue||(h=n._queueHooks(a,"fx"),null==h.unqueued&&(h.unqueued=0,i=h.empty.fire,h.empty.fire=function(){h.unqueued||i()}),h.unqueued++,l.always(function(){l.always(function(){h.unqueued--,n.queue(a,"fx").length||h.empty.fire()})})),1===a.nodeType&&("height"in b||"width"in b)&&(c.overflow=[o.overflow,o.overflowX,o.overflowY],j=n.css(a,"display"),k="none"===j?L.get(a,"olddisplay")||ta(a.nodeName):j,"inline"===k&&"none"===n.css(a,"float")&&(o.display="inline-block")),c.overflow&&(o.overflow="hidden",l.always(function(){o.overflow=c.overflow[0],o.overflowX=c.overflow[1],o.overflowY=c.overflow[2]}));for(d in b)if(e=b[d],Na.exec(e)){if(delete b[d],f=f||"toggle"===e,e===(p?"hide":"show")){if("show"!==e||!q||void 0===q[d])continue;p=!0}m[d]=q&&q[d]||n.style(a,d)}else j=void 0;if(n.isEmptyObject(m))"inline"===("none"===j?ta(a.nodeName):j)&&(o.display=j);else{q?"hidden"in q&&(p=q.hidden):q=L.access(a,"fxshow",{}),f&&(q.hidden=!p),p?n(a).show():l.done(function(){n(a).hide()}),l.done(function(){var b;L.remove(a,"fxshow");for(b in m)n.style(a,b,m[b])});for(d in m)g=Ua(p?q[d]:0,d,l),d in q||(q[d]=g.start,p&&(g.end=g.start,g.start="width"===d||"height"===d?1:0))}}function Wa(a,b){var c,d,e,f,g;for(c in a)if(d=n.camelCase(c),e=b[d],f=a[c],n.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=n.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function Xa(a,b,c){var d,e,f=0,g=Qa.length,h=n.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=La||Sa(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;i>g;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),1>f&&i?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:n.extend({},b),opts:n.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:La||Sa(),duration:c.duration,tweens:[],createTween:function(b,c){var d=n.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;d>c;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;for(Wa(k,j.opts.specialEasing);g>f;f++)if(d=Qa[f].call(j,a,k,j.opts))return d;return n.map(k,Ua,j),n.isFunction(j.opts.start)&&j.opts.start.call(a,j),n.fx.timer(n.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}n.Animation=n.extend(Xa,{tweener:function(a,b){n.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");for(var c,d=0,e=a.length;e>d;d++)c=a[d],Ra[c]=Ra[c]||[],Ra[c].unshift(b)},prefilter:function(a,b){b?Qa.unshift(a):Qa.push(a)}}),n.speed=function(a,b,c){var d=a&&"object"==typeof a?n.extend({},a):{complete:c||!c&&b||n.isFunction(a)&&a,duration:a,easing:c&&b||b&&!n.isFunction(b)&&b};return d.duration=n.fx.off?0:"number"==typeof d.duration?d.duration:d.duration in n.fx.speeds?n.fx.speeds[d.duration]:n.fx.speeds._default,(null==d.queue||d.queue===!0)&&(d.queue="fx"),d.old=d.complete,d.complete=function(){n.isFunction(d.old)&&d.old.call(this),d.queue&&n.dequeue(this,d.queue)},d},n.fn.extend({fadeTo:function(a,b,c,d){return this.filter(S).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=n.isEmptyObject(a),f=n.speed(b,c,d),g=function(){var b=Xa(this,n.extend({},a),f);(e||L.get(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=n.timers,g=L.get(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&Pa.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));(b||!c)&&n.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=L.get(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=n.timers,g=d?d.length:0;for(c.finish=!0,n.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;g>b;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),n.each(["toggle","show","hide"],function(a,b){var c=n.fn[b];n.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(Ta(b,!0),a,d,e)}}),n.each({slideDown:Ta("show"),slideUp:Ta("hide"),slideToggle:Ta("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){n.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),n.timers=[],n.fx.tick=function(){var a,b=0,c=n.timers;for(La=n.now();b<c.length;b++)a=c[b],a()||c[b]!==a||c.splice(b--,1);c.length||n.fx.stop(),La=void 0},n.fx.timer=function(a){n.timers.push(a),a()?n.fx.start():n.timers.pop()},n.fx.interval=13,n.fx.start=function(){Ma||(Ma=setInterval(n.fx.tick,n.fx.interval))},n.fx.stop=function(){clearInterval(Ma),Ma=null},n.fx.speeds={slow:600,fast:200,_default:400},n.fn.delay=function(a,b){return a=n.fx?n.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},function(){var a=l.createElement("input"),b=l.createElement("select"),c=b.appendChild(l.createElement("option"));a.type="checkbox",k.checkOn=""!==a.value,k.optSelected=c.selected,b.disabled=!0,k.optDisabled=!c.disabled,a=l.createElement("input"),a.value="t",a.type="radio",k.radioValue="t"===a.value}();var Ya,Za,$a=n.expr.attrHandle;n.fn.extend({attr:function(a,b){return J(this,n.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){n.removeAttr(this,a)})}}),n.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(a&&3!==f&&8!==f&&2!==f)return typeof a.getAttribute===U?n.prop(a,b,c):(1===f&&n.isXMLDoc(a)||(b=b.toLowerCase(),d=n.attrHooks[b]||(n.expr.match.bool.test(b)?Za:Ya)),
+void 0===c?d&&"get"in d&&null!==(e=d.get(a,b))?e:(e=n.find.attr(a,b),null==e?void 0:e):null!==c?d&&"set"in d&&void 0!==(e=d.set(a,c,b))?e:(a.setAttribute(b,c+""),c):void n.removeAttr(a,b))},removeAttr:function(a,b){var c,d,e=0,f=b&&b.match(E);if(f&&1===a.nodeType)while(c=f[e++])d=n.propFix[c]||c,n.expr.match.bool.test(c)&&(a[d]=!1),a.removeAttribute(c)},attrHooks:{type:{set:function(a,b){if(!k.radioValue&&"radio"===b&&n.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}}}),Za={set:function(a,b,c){return b===!1?n.removeAttr(a,c):a.setAttribute(c,c),c}},n.each(n.expr.match.bool.source.match(/\w+/g),function(a,b){var c=$a[b]||n.find.attr;$a[b]=function(a,b,d){var e,f;return d||(f=$a[b],$a[b]=e,e=null!=c(a,b,d)?b.toLowerCase():null,$a[b]=f),e}});var _a=/^(?:input|select|textarea|button)$/i;n.fn.extend({prop:function(a,b){return J(this,n.prop,a,b,arguments.length>1)},removeProp:function(a){return this.each(function(){delete this[n.propFix[a]||a]})}}),n.extend({propFix:{"for":"htmlFor","class":"className"},prop:function(a,b,c){var d,e,f,g=a.nodeType;if(a&&3!==g&&8!==g&&2!==g)return f=1!==g||!n.isXMLDoc(a),f&&(b=n.propFix[b]||b,e=n.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){return a.hasAttribute("tabindex")||_a.test(a.nodeName)||a.href?a.tabIndex:-1}}}}),k.optSelected||(n.propHooks.selected={get:function(a){var b=a.parentNode;return b&&b.parentNode&&b.parentNode.selectedIndex,null}}),n.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){n.propFix[this.toLowerCase()]=this});var ab=/[\t\r\n\f]/g;n.fn.extend({addClass:function(a){var b,c,d,e,f,g,h="string"==typeof a&&a,i=0,j=this.length;if(n.isFunction(a))return this.each(function(b){n(this).addClass(a.call(this,b,this.className))});if(h)for(b=(a||"").match(E)||[];j>i;i++)if(c=this[i],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(ab," "):" ")){f=0;while(e=b[f++])d.indexOf(" "+e+" ")<0&&(d+=e+" ");g=n.trim(d),c.className!==g&&(c.className=g)}return this},removeClass:function(a){var b,c,d,e,f,g,h=0===arguments.length||"string"==typeof a&&a,i=0,j=this.length;if(n.isFunction(a))return this.each(function(b){n(this).removeClass(a.call(this,b,this.className))});if(h)for(b=(a||"").match(E)||[];j>i;i++)if(c=this[i],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(ab," "):"")){f=0;while(e=b[f++])while(d.indexOf(" "+e+" ")>=0)d=d.replace(" "+e+" "," ");g=a?n.trim(d):"",c.className!==g&&(c.className=g)}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):this.each(n.isFunction(a)?function(c){n(this).toggleClass(a.call(this,c,this.className,b),b)}:function(){if("string"===c){var b,d=0,e=n(this),f=a.match(E)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else(c===U||"boolean"===c)&&(this.className&&L.set(this,"__className__",this.className),this.className=this.className||a===!1?"":L.get(this,"__className__")||"")})},hasClass:function(a){for(var b=" "+a+" ",c=0,d=this.length;d>c;c++)if(1===this[c].nodeType&&(" "+this[c].className+" ").replace(ab," ").indexOf(b)>=0)return!0;return!1}});var bb=/\r/g;n.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=n.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,n(this).val()):a,null==e?e="":"number"==typeof e?e+="":n.isArray(e)&&(e=n.map(e,function(a){return null==a?"":a+""})),b=n.valHooks[this.type]||n.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=n.valHooks[e.type]||n.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(bb,""):null==c?"":c)}}}),n.extend({valHooks:{option:{get:function(a){var b=n.find.attr(a,"value");return null!=b?b:n.trim(n.text(a))}},select:{get:function(a){for(var b,c,d=a.options,e=a.selectedIndex,f="select-one"===a.type||0>e,g=f?null:[],h=f?e+1:d.length,i=0>e?h:f?e:0;h>i;i++)if(c=d[i],!(!c.selected&&i!==e||(k.optDisabled?c.disabled:null!==c.getAttribute("disabled"))||c.parentNode.disabled&&n.nodeName(c.parentNode,"optgroup"))){if(b=n(c).val(),f)return b;g.push(b)}return g},set:function(a,b){var c,d,e=a.options,f=n.makeArray(b),g=e.length;while(g--)d=e[g],(d.selected=n.inArray(d.value,f)>=0)&&(c=!0);return c||(a.selectedIndex=-1),f}}}}),n.each(["radio","checkbox"],function(){n.valHooks[this]={set:function(a,b){return n.isArray(b)?a.checked=n.inArray(n(a).val(),b)>=0:void 0}},k.checkOn||(n.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})}),n.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){n.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),n.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}});var cb=n.now(),db=/\?/;n.parseJSON=function(a){return JSON.parse(a+"")},n.parseXML=function(a){var b,c;if(!a||"string"!=typeof a)return null;try{c=new DOMParser,b=c.parseFromString(a,"text/xml")}catch(d){b=void 0}return(!b||b.getElementsByTagName("parsererror").length)&&n.error("Invalid XML: "+a),b};var eb=/#.*$/,fb=/([?&])_=[^&]*/,gb=/^(.*?):[ \t]*([^\r\n]*)$/gm,hb=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,ib=/^(?:GET|HEAD)$/,jb=/^\/\//,kb=/^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,lb={},mb={},nb="*/".concat("*"),ob=a.location.href,pb=kb.exec(ob.toLowerCase())||[];function qb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(E)||[];if(n.isFunction(c))while(d=f[e++])"+"===d[0]?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function rb(a,b,c,d){var e={},f=a===mb;function g(h){var i;return e[h]=!0,n.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function sb(a,b){var c,d,e=n.ajaxSettings.flatOptions||{};for(c in b)void 0!==b[c]&&((e[c]?a:d||(d={}))[c]=b[c]);return d&&n.extend(!0,a,d),a}function tb(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===d&&(d=a.mimeType||b.getResponseHeader("Content-Type"));if(d)for(e in h)if(h[e]&&h[e].test(d)){i.unshift(e);break}if(i[0]in c)f=i[0];else{for(e in c){if(!i[0]||a.converters[e+" "+i[0]]){f=e;break}g||(g=e)}f=f||g}return f?(f!==i[0]&&i.unshift(f),c[f]):void 0}function ub(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}n.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:ob,type:"GET",isLocal:hb.test(pb[1]),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":nb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":n.parseJSON,"text xml":n.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?sb(sb(a,n.ajaxSettings),b):sb(n.ajaxSettings,a)},ajaxPrefilter:qb(lb),ajaxTransport:qb(mb),ajax:function(a,b){"object"==typeof a&&(b=a,a=void 0),b=b||{};var c,d,e,f,g,h,i,j,k=n.ajaxSetup({},b),l=k.context||k,m=k.context&&(l.nodeType||l.jquery)?n(l):n.event,o=n.Deferred(),p=n.Callbacks("once memory"),q=k.statusCode||{},r={},s={},t=0,u="canceled",v={readyState:0,getResponseHeader:function(a){var b;if(2===t){if(!f){f={};while(b=gb.exec(e))f[b[1].toLowerCase()]=b[2]}b=f[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return 2===t?e:null},setRequestHeader:function(a,b){var c=a.toLowerCase();return t||(a=s[c]=s[c]||a,r[a]=b),this},overrideMimeType:function(a){return t||(k.mimeType=a),this},statusCode:function(a){var b;if(a)if(2>t)for(b in a)q[b]=[q[b],a[b]];else v.always(a[v.status]);return this},abort:function(a){var b=a||u;return c&&c.abort(b),x(0,b),this}};if(o.promise(v).complete=p.add,v.success=v.done,v.error=v.fail,k.url=((a||k.url||ob)+"").replace(eb,"").replace(jb,pb[1]+"//"),k.type=b.method||b.type||k.method||k.type,k.dataTypes=n.trim(k.dataType||"*").toLowerCase().match(E)||[""],null==k.crossDomain&&(h=kb.exec(k.url.toLowerCase()),k.crossDomain=!(!h||h[1]===pb[1]&&h[2]===pb[2]&&(h[3]||("http:"===h[1]?"80":"443"))===(pb[3]||("http:"===pb[1]?"80":"443")))),k.data&&k.processData&&"string"!=typeof k.data&&(k.data=n.param(k.data,k.traditional)),rb(lb,k,b,v),2===t)return v;i=n.event&&k.global,i&&0===n.active++&&n.event.trigger("ajaxStart"),k.type=k.type.toUpperCase(),k.hasContent=!ib.test(k.type),d=k.url,k.hasContent||(k.data&&(d=k.url+=(db.test(d)?"&":"?")+k.data,delete k.data),k.cache===!1&&(k.url=fb.test(d)?d.replace(fb,"$1_="+cb++):d+(db.test(d)?"&":"?")+"_="+cb++)),k.ifModified&&(n.lastModified[d]&&v.setRequestHeader("If-Modified-Since",n.lastModified[d]),n.etag[d]&&v.setRequestHeader("If-None-Match",n.etag[d])),(k.data&&k.hasContent&&k.contentType!==!1||b.contentType)&&v.setRequestHeader("Content-Type",k.contentType),v.setRequestHeader("Accept",k.dataTypes[0]&&k.accepts[k.dataTypes[0]]?k.accepts[k.dataTypes[0]]+("*"!==k.dataTypes[0]?", "+nb+"; q=0.01":""):k.accepts["*"]);for(j in k.headers)v.setRequestHeader(j,k.headers[j]);if(k.beforeSend&&(k.beforeSend.call(l,v,k)===!1||2===t))return v.abort();u="abort";for(j in{success:1,error:1,complete:1})v[j](k[j]);if(c=rb(mb,k,b,v)){v.readyState=1,i&&m.trigger("ajaxSend",[v,k]),k.async&&k.timeout>0&&(g=setTimeout(function(){v.abort("timeout")},k.timeout));try{t=1,c.send(r,x)}catch(w){if(!(2>t))throw w;x(-1,w)}}else x(-1,"No Transport");function x(a,b,f,h){var j,r,s,u,w,x=b;2!==t&&(t=2,g&&clearTimeout(g),c=void 0,e=h||"",v.readyState=a>0?4:0,j=a>=200&&300>a||304===a,f&&(u=tb(k,v,f)),u=ub(k,u,v,j),j?(k.ifModified&&(w=v.getResponseHeader("Last-Modified"),w&&(n.lastModified[d]=w),w=v.getResponseHeader("etag"),w&&(n.etag[d]=w)),204===a||"HEAD"===k.type?x="nocontent":304===a?x="notmodified":(x=u.state,r=u.data,s=u.error,j=!s)):(s=x,(a||!x)&&(x="error",0>a&&(a=0))),v.status=a,v.statusText=(b||x)+"",j?o.resolveWith(l,[r,x,v]):o.rejectWith(l,[v,x,s]),v.statusCode(q),q=void 0,i&&m.trigger(j?"ajaxSuccess":"ajaxError",[v,k,j?r:s]),p.fireWith(l,[v,x]),i&&(m.trigger("ajaxComplete",[v,k]),--n.active||n.event.trigger("ajaxStop")))}return v},getJSON:function(a,b,c){return n.get(a,b,c,"json")},getScript:function(a,b){return n.get(a,void 0,b,"script")}}),n.each(["get","post"],function(a,b){n[b]=function(a,c,d,e){return n.isFunction(c)&&(e=e||d,d=c,c=void 0),n.ajax({url:a,type:b,dataType:e,data:c,success:d})}}),n._evalUrl=function(a){return n.ajax({url:a,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0})},n.fn.extend({wrapAll:function(a){var b;return n.isFunction(a)?this.each(function(b){n(this).wrapAll(a.call(this,b))}):(this[0]&&(b=n(a,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstElementChild)a=a.firstElementChild;return a}).append(this)),this)},wrapInner:function(a){return this.each(n.isFunction(a)?function(b){n(this).wrapInner(a.call(this,b))}:function(){var b=n(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=n.isFunction(a);return this.each(function(c){n(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){n.nodeName(this,"body")||n(this).replaceWith(this.childNodes)}).end()}}),n.expr.filters.hidden=function(a){return a.offsetWidth<=0&&a.offsetHeight<=0},n.expr.filters.visible=function(a){return!n.expr.filters.hidden(a)};var vb=/%20/g,wb=/\[\]$/,xb=/\r?\n/g,yb=/^(?:submit|button|image|reset|file)$/i,zb=/^(?:input|select|textarea|keygen)/i;function Ab(a,b,c,d){var e;if(n.isArray(b))n.each(b,function(b,e){c||wb.test(a)?d(a,e):Ab(a+"["+("object"==typeof e?b:"")+"]",e,c,d)});else if(c||"object"!==n.type(b))d(a,b);else for(e in b)Ab(a+"["+e+"]",b[e],c,d)}n.param=function(a,b){var c,d=[],e=function(a,b){b=n.isFunction(b)?b():null==b?"":b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};if(void 0===b&&(b=n.ajaxSettings&&n.ajaxSettings.traditional),n.isArray(a)||a.jquery&&!n.isPlainObject(a))n.each(a,function(){e(this.name,this.value)});else for(c in a)Ab(c,a[c],b,e);return d.join("&").replace(vb,"+")},n.fn.extend({serialize:function(){return n.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=n.prop(this,"elements");return a?n.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!n(this).is(":disabled")&&zb.test(this.nodeName)&&!yb.test(a)&&(this.checked||!T.test(a))}).map(function(a,b){var c=n(this).val();return null==c?null:n.isArray(c)?n.map(c,function(a){return{name:b.name,value:a.replace(xb,"\r\n")}}):{name:b.name,value:c.replace(xb,"\r\n")}}).get()}}),n.ajaxSettings.xhr=function(){try{return new XMLHttpRequest}catch(a){}};var Bb=0,Cb={},Db={0:200,1223:204},Eb=n.ajaxSettings.xhr();a.attachEvent&&a.attachEvent("onunload",function(){for(var a in Cb)Cb[a]()}),k.cors=!!Eb&&"withCredentials"in Eb,k.ajax=Eb=!!Eb,n.ajaxTransport(function(a){var b;return k.cors||Eb&&!a.crossDomain?{send:function(c,d){var e,f=a.xhr(),g=++Bb;if(f.open(a.type,a.url,a.async,a.username,a.password),a.xhrFields)for(e in a.xhrFields)f[e]=a.xhrFields[e];a.mimeType&&f.overrideMimeType&&f.overrideMimeType(a.mimeType),a.crossDomain||c["X-Requested-With"]||(c["X-Requested-With"]="XMLHttpRequest");for(e in c)f.setRequestHeader(e,c[e]);b=function(a){return function(){b&&(delete Cb[g],b=f.onload=f.onerror=null,"abort"===a?f.abort():"error"===a?d(f.status,f.statusText):d(Db[f.status]||f.status,f.statusText,"string"==typeof f.responseText?{text:f.responseText}:void 0,f.getAllResponseHeaders()))}},f.onload=b(),f.onerror=b("error"),b=Cb[g]=b("abort");try{f.send(a.hasContent&&a.data||null)}catch(h){if(b)throw h}},abort:function(){b&&b()}}:void 0}),n.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/(?:java|ecma)script/},converters:{"text script":function(a){return n.globalEval(a),a}}}),n.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET")}),n.ajaxTransport("script",function(a){if(a.crossDomain){var b,c;return{send:function(d,e){b=n("<script>").prop({async:!0,charset:a.scriptCharset,src:a.url}).on("load error",c=function(a){b.remove(),c=null,a&&e("error"===a.type?404:200,a.type)}),l.head.appendChild(b[0])},abort:function(){c&&c()}}}});var Fb=[],Gb=/(=)\?(?=&|$)|\?\?/;n.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=Fb.pop()||n.expando+"_"+cb++;return this[a]=!0,a}}),n.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(Gb.test(b.url)?"url":"string"==typeof b.data&&!(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&Gb.test(b.data)&&"data");return h||"jsonp"===b.dataTypes[0]?(e=b.jsonpCallback=n.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(Gb,"$1"+e):b.jsonp!==!1&&(b.url+=(db.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||n.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,Fb.push(e)),g&&n.isFunction(f)&&f(g[0]),g=f=void 0}),"script"):void 0}),n.parseHTML=function(a,b,c){if(!a||"string"!=typeof a)return null;"boolean"==typeof b&&(c=b,b=!1),b=b||l;var d=v.exec(a),e=!c&&[];return d?[b.createElement(d[1])]:(d=n.buildFragment([a],b,e),e&&e.length&&n(e).remove(),n.merge([],d.childNodes))};var Hb=n.fn.load;n.fn.load=function(a,b,c){if("string"!=typeof a&&Hb)return Hb.apply(this,arguments);var d,e,f,g=this,h=a.indexOf(" ");return h>=0&&(d=n.trim(a.slice(h)),a=a.slice(0,h)),n.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(e="POST"),g.length>0&&n.ajax({url:a,type:e,dataType:"html",data:b}).done(function(a){f=arguments,g.html(d?n("<div>").append(n.parseHTML(a)).find(d):a)}).complete(c&&function(a,b){g.each(c,f||[a.responseText,b,a])}),this},n.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){n.fn[b]=function(a){return this.on(b,a)}}),n.expr.filters.animated=function(a){return n.grep(n.timers,function(b){return a===b.elem}).length};var Ib=a.document.documentElement;function Jb(a){return n.isWindow(a)?a:9===a.nodeType&&a.defaultView}n.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=n.css(a,"position"),l=n(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=n.css(a,"top"),i=n.css(a,"left"),j=("absolute"===k||"fixed"===k)&&(f+i).indexOf("auto")>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),n.isFunction(b)&&(b=b.call(a,c,h)),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},n.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){n.offset.setOffset(this,a,b)});var b,c,d=this[0],e={top:0,left:0},f=d&&d.ownerDocument;if(f)return b=f.documentElement,n.contains(b,d)?(typeof d.getBoundingClientRect!==U&&(e=d.getBoundingClientRect()),c=Jb(f),{top:e.top+c.pageYOffset-b.clientTop,left:e.left+c.pageXOffset-b.clientLeft}):e},position:function(){if(this[0]){var a,b,c=this[0],d={top:0,left:0};return"fixed"===n.css(c,"position")?b=c.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),n.nodeName(a[0],"html")||(d=a.offset()),d.top+=n.css(a[0],"borderTopWidth",!0),d.left+=n.css(a[0],"borderLeftWidth",!0)),{top:b.top-d.top-n.css(c,"marginTop",!0),left:b.left-d.left-n.css(c,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||Ib;while(a&&!n.nodeName(a,"html")&&"static"===n.css(a,"position"))a=a.offsetParent;return a||Ib})}}),n.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(b,c){var d="pageYOffset"===c;n.fn[b]=function(e){return J(this,function(b,e,f){var g=Jb(b);return void 0===f?g?g[c]:b[e]:void(g?g.scrollTo(d?a.pageXOffset:f,d?f:a.pageYOffset):b[e]=f)},b,e,arguments.length,null)}}),n.each(["top","left"],function(a,b){n.cssHooks[b]=ya(k.pixelPosition,function(a,c){return c?(c=xa(a,b),va.test(c)?n(a).position()[b]+"px":c):void 0})}),n.each({Height:"height",Width:"width"},function(a,b){n.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){n.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return J(this,function(b,c,d){var e;return n.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?n.css(b,c,g):n.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),n.fn.size=function(){return this.length},n.fn.andSelf=n.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return n});var Kb=a.jQuery,Lb=a.$;return n.noConflict=function(b){return a.$===n&&(a.$=Lb),b&&a.jQuery===n&&(a.jQuery=Kb),n},typeof b===U&&(a.jQuery=a.$=n),n});
diff --git a/example/ext/pythonmode.js b/example/ext/pythonmode.js
new file mode 100644
index 0000000..98c0409
--- /dev/null
+++ b/example/ext/pythonmode.js
@@ -0,0 +1,359 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  function wordRegexp(words) {
+    return new RegExp("^((" + words.join(")|(") + "))\\b");
+  }
+
+  var wordOperators = wordRegexp(["and", "or", "not", "is"]);
+  var commonKeywords = ["as", "assert", "break", "class", "continue",
+                        "def", "del", "elif", "else", "except", "finally",
+                        "for", "from", "global", "if", "import",
+                        "lambda", "pass", "raise", "return",
+                        "try", "while", "with", "yield", "in"];
+  var commonBuiltins = ["abs", "all", "any", "bin", "bool", "bytearray", "callable", "chr",
+                        "classmethod", "compile", "complex", "delattr", "dict", "dir", "divmod",
+                        "enumerate", "eval", "filter", "float", "format", "frozenset",
+                        "getattr", "globals", "hasattr", "hash", "help", "hex", "id",
+                        "input", "int", "isinstance", "issubclass", "iter", "len",
+                        "list", "locals", "map", "max", "memoryview", "min", "next",
+                        "object", "oct", "open", "ord", "pow", "property", "range",
+                        "repr", "reversed", "round", "set", "setattr", "slice",
+                        "sorted", "staticmethod", "str", "sum", "super", "tuple",
+                        "type", "vars", "zip", "__import__", "NotImplemented",
+                        "Ellipsis", "__debug__"];
+  var py2 = {builtins: ["apply", "basestring", "buffer", "cmp", "coerce", "execfile",
+                        "file", "intern", "long", "raw_input", "reduce", "reload",
+                        "unichr", "unicode", "xrange", "False", "True", "None"],
+             keywords: ["exec", "print"]};
+  var py3 = {builtins: ["ascii", "bytes", "exec", "print"],
+             keywords: ["nonlocal", "False", "True", "None"]};
+
+  CodeMirror.registerHelper("hintWords", "python", commonKeywords.concat(commonBuiltins));
+
+  function top(state) {
+    return state.scopes[state.scopes.length - 1];
+  }
+
+  CodeMirror.defineMode("python", function(conf, parserConf) {
+    var ERRORCLASS = "error";
+
+    var singleDelimiters = parserConf.singleDelimiters || new RegExp("^[\\(\\)\\[\\]\\{\\}@,:`=;\\.]");
+    var doubleOperators = parserConf.doubleOperators || new RegExp("^((==)|(!=)|(<=)|(>=)|(<>)|(<<)|(>>)|(//)|(\\*\\*))");
+    var doubleDelimiters = parserConf.doubleDelimiters || new RegExp("^((\\+=)|(\\-=)|(\\*=)|(%=)|(/=)|(&=)|(\\|=)|(\\^=))");
+    var tripleDelimiters = parserConf.tripleDelimiters || new RegExp("^((//=)|(>>=)|(<<=)|(\\*\\*=))");
+
+    if (parserConf.version && parseInt(parserConf.version, 10) == 3){
+        // since http://legacy.python.org/dev/peps/pep-0465/ @ is also an operator
+        var singleOperators = parserConf.singleOperators || new RegExp("^[\\+\\-\\*/%&|\\^~<>!@]");
+        var identifiers = parserConf.identifiers|| new RegExp("^[_A-Za-z\u00A1-\uFFFF][_A-Za-z0-9\u00A1-\uFFFF]*");
+    } else {
+        var singleOperators = parserConf.singleOperators || new RegExp("^[\\+\\-\\*/%&|\\^~<>!]");
+        var identifiers = parserConf.identifiers|| new RegExp("^[_A-Za-z][_A-Za-z0-9]*");
+    }
+
+    var hangingIndent = parserConf.hangingIndent || conf.indentUnit;
+
+    var myKeywords = commonKeywords, myBuiltins = commonBuiltins;
+    if(parserConf.extra_keywords != undefined){
+      myKeywords = myKeywords.concat(parserConf.extra_keywords);
+    }
+    if(parserConf.extra_builtins != undefined){
+      myBuiltins = myBuiltins.concat(parserConf.extra_builtins);
+    }
+    if (parserConf.version && parseInt(parserConf.version, 10) == 3) {
+      myKeywords = myKeywords.concat(py3.keywords);
+      myBuiltins = myBuiltins.concat(py3.builtins);
+      var stringPrefixes = new RegExp("^(([rb]|(br))?('{3}|\"{3}|['\"]))", "i");
+    } else {
+      myKeywords = myKeywords.concat(py2.keywords);
+      myBuiltins = myBuiltins.concat(py2.builtins);
+      var stringPrefixes = new RegExp("^(([rub]|(ur)|(br))?('{3}|\"{3}|['\"]))", "i");
+    }
+    var keywords = wordRegexp(myKeywords);
+    var builtins = wordRegexp(myBuiltins);
+
+    // tokenizers
+    function tokenBase(stream, state) {
+      // Handle scope changes
+      if (stream.sol() && top(state).type == "py") {
+        var scopeOffset = top(state).offset;
+        if (stream.eatSpace()) {
+          var lineOffset = stream.indentation();
+          if (lineOffset > scopeOffset)
+            pushScope(stream, state, "py");
+          else if (lineOffset < scopeOffset && dedent(stream, state))
+            state.errorToken = true;
+          return null;
+        } else {
+          var style = tokenBaseInner(stream, state);
+          if (scopeOffset > 0 && dedent(stream, state))
+            style += " " + ERRORCLASS;
+          return style;
+        }
+      }
+      return tokenBaseInner(stream, state);
+    }
+
+    function tokenBaseInner(stream, state) {
+      if (stream.eatSpace()) return null;
+
+      var ch = stream.peek();
+
+      // Handle Comments
+      if (ch == "#") {
+        stream.skipToEnd();
+        return "comment";
+      }
+
+      // Handle Number Literals
+      if (stream.match(/^[0-9\.]/, false)) {
+        var floatLiteral = false;
+        // Floats
+        if (stream.match(/^\d*\.\d+(e[\+\-]?\d+)?/i)) { floatLiteral = true; }
+        if (stream.match(/^\d+\.\d*/)) { floatLiteral = true; }
+        if (stream.match(/^\.\d+/)) { floatLiteral = true; }
+        if (floatLiteral) {
+          // Float literals may be "imaginary"
+          stream.eat(/J/i);
+          return "number";
+        }
+        // Integers
+        var intLiteral = false;
+        // Hex
+        if (stream.match(/^0x[0-9a-f]+/i)) intLiteral = true;
+        // Binary
+        if (stream.match(/^0b[01]+/i)) intLiteral = true;
+        // Octal
+        if (stream.match(/^0o[0-7]+/i)) intLiteral = true;
+        // Decimal
+        if (stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)) {
+          // Decimal literals may be "imaginary"
+          stream.eat(/J/i);
+          // TODO - Can you have imaginary longs?
+          intLiteral = true;
+        }
+        // Zero by itself with no other piece of number.
+        if (stream.match(/^0(?![\dx])/i)) intLiteral = true;
+        if (intLiteral) {
+          // Integer literals may be "long"
+          stream.eat(/L/i);
+          return "number";
+        }
+      }
+
+      // Handle Strings
+      if (stream.match(stringPrefixes)) {
+        state.tokenize = tokenStringFactory(stream.current());
+        return state.tokenize(stream, state);
+      }
+
+      // Handle operators and Delimiters
+      if (stream.match(tripleDelimiters) || stream.match(doubleDelimiters))
+        return null;
+
+      if (stream.match(doubleOperators)
+          || stream.match(singleOperators)
+          || stream.match(wordOperators))
+        return "operator";
+
+      if (stream.match(singleDelimiters))
+        return null;
+
+      if (stream.match(keywords))
+        return "keyword";
+
+      if (stream.match(builtins))
+        return "builtin";
+
+      if (stream.match(/^(self|cls)\b/))
+        return "variable-2";
+
+      if (stream.match(identifiers)) {
+        if (state.lastToken == "def" || state.lastToken == "class")
+          return "def";
+        return "variable";
+      }
+
+      // Handle non-detected items
+      stream.next();
+      return ERRORCLASS;
+    }
+
+    function tokenStringFactory(delimiter) {
+      while ("rub".indexOf(delimiter.charAt(0).toLowerCase()) >= 0)
+        delimiter = delimiter.substr(1);
+
+      var singleline = delimiter.length == 1;
+      var OUTCLASS = "string";
+
+      function tokenString(stream, state) {
+        while (!stream.eol()) {
+          stream.eatWhile(/[^'"\\]/);
+          if (stream.eat("\\")) {
+            stream.next();
+            if (singleline && stream.eol())
+              return OUTCLASS;
+          } else if (stream.match(delimiter)) {
+            state.tokenize = tokenBase;
+            return OUTCLASS;
+          } else {
+            stream.eat(/['"]/);
+          }
+        }
+        if (singleline) {
+          if (parserConf.singleLineStringErrors)
+            return ERRORCLASS;
+          else
+            state.tokenize = tokenBase;
+        }
+        return OUTCLASS;
+      }
+      tokenString.isString = true;
+      return tokenString;
+    }
+
+    function pushScope(stream, state, type) {
+      var offset = 0, align = null;
+      if (type == "py") {
+        while (top(state).type != "py")
+          state.scopes.pop();
+      }
+      offset = top(state).offset + (type == "py" ? conf.indentUnit : hangingIndent);
+      if (type != "py" && !stream.match(/^(\s|#.*)*$/, false))
+        align = stream.column() + 1;
+      state.scopes.push({offset: offset, type: type, align: align});
+    }
+
+    function dedent(stream, state) {
+      var indented = stream.indentation();
+      while (top(state).offset > indented) {
+        if (top(state).type != "py") return true;
+        state.scopes.pop();
+      }
+      return top(state).offset != indented;
+    }
+
+    function tokenLexer(stream, state) {
+      var style = state.tokenize(stream, state);
+      var current = stream.current();
+
+      // Handle '.' connected identifiers
+      if (current == ".") {
+        style = stream.match(identifiers, false) ? null : ERRORCLASS;
+        if (style == null && state.lastStyle == "meta") {
+          // Apply 'meta' style to '.' connected identifiers when
+          // appropriate.
+          style = "meta";
+        }
+        return style;
+      }
+
+      // Handle decorators
+      if (current == "@"){
+        if(parserConf.version && parseInt(parserConf.version, 10) == 3){
+            return stream.match(identifiers, false) ? "meta" : "operator";
+        } else {
+            return stream.match(identifiers, false) ? "meta" : ERRORCLASS;
+        }
+      }
+
+      if ((style == "variable" || style == "builtin")
+          && state.lastStyle == "meta")
+        style = "meta";
+
+      // Handle scope changes.
+      if (current == "pass" || current == "return")
+        state.dedent += 1;
+
+      if (current == "lambda") state.lambda = true;
+      if (current == ":" && !state.lambda && top(state).type == "py")
+        pushScope(stream, state, "py");
+
+      var delimiter_index = current.length == 1 ? "[({".indexOf(current) : -1;
+      if (delimiter_index != -1)
+        pushScope(stream, state, "])}".slice(delimiter_index, delimiter_index+1));
+
+      delimiter_index = "])}".indexOf(current);
+      if (delimiter_index != -1) {
+        if (top(state).type == current) state.scopes.pop();
+        else return ERRORCLASS;
+      }
+      if (state.dedent > 0 && stream.eol() && top(state).type == "py") {
+        if (state.scopes.length > 1) state.scopes.pop();
+        state.dedent -= 1;
+      }
+
+      return style;
+    }
+
+    var external = {
+      startState: function(basecolumn) {
+        return {
+          tokenize: tokenBase,
+          scopes: [{offset: basecolumn || 0, type: "py", align: null}],
+          lastStyle: null,
+          lastToken: null,
+          lambda: false,
+          dedent: 0
+        };
+      },
+
+      token: function(stream, state) {
+        var addErr = state.errorToken;
+        if (addErr) state.errorToken = false;
+        var style = tokenLexer(stream, state);
+
+        state.lastStyle = style;
+
+        var current = stream.current();
+        if (current && style)
+          state.lastToken = current;
+
+        if (stream.eol() && state.lambda)
+          state.lambda = false;
+        return addErr ? style + " " + ERRORCLASS : style;
+      },
+
+      indent: function(state, textAfter) {
+        if (state.tokenize != tokenBase)
+          return state.tokenize.isString ? CodeMirror.Pass : 0;
+
+        var scope = top(state);
+        var closing = textAfter && textAfter.charAt(0) == scope.type;
+        if (scope.align != null)
+          return scope.align - (closing ? 1 : 0);
+        else if (closing && state.scopes.length > 1)
+          return state.scopes[state.scopes.length - 2].offset;
+        else
+          return scope.offset;
+      },
+
+      lineComment: "#",
+      fold: "indent"
+    };
+    return external;
+  });
+
+  CodeMirror.defineMIME("text/x-python", "python");
+
+  var words = function(str) { return str.split(" "); };
+
+  CodeMirror.defineMIME("text/x-cython", {
+    name: "python",
+    extra_keywords: words("by cdef cimport cpdef ctypedef enum except"+
+                          "extern gil include nogil property public"+
+                          "readonly struct union DEF IF ELIF ELSE")
+  });
+
+});
diff --git a/example/index.css b/example/index.css
new file mode 100644
index 0000000..b7f98bc
--- /dev/null
+++ b/example/index.css
@@ -0,0 +1,10 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+.EditorWidget {
+  min-width: 50px;
+  min-height: 50px;
+  border: 1px solid #C0C0C0;
+  z-index: 0;
+}
diff --git a/example/index.html b/example/index.html
new file mode 100644
index 0000000..91fe318
--- /dev/null
+++ b/example/index.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <link href="ext/codemirror.css" rel="stylesheet" type="text/css">
+  <script src="ext/codemirror.js"></script>
+  <script src="ext/pythonmode.js"></script>
+  <script src="ext/jquery-2.1.4.min.js"></script>
+  <link href="index.css" rel="stylesheet" type="text/css">
+  <script type="text/javascript" src="bundle.js"></script>
+</head>
+<body>
+  <div id="main"></div>
+</body>
+</html>
diff --git a/example/src/index.ts b/example/src/index.ts
new file mode 100644
index 0000000..effedc6
--- /dev/null
+++ b/example/src/index.ts
@@ -0,0 +1,29 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use-strict';
+
+import {
+  Widget
+} from 'phosphor-widget';
+
+import {
+  EditorWidget, EditorModel, EditorViewModel
+} from '../../lib/index';
+
+function main(): void {
+  var model = new EditorModel();
+  var viewmodel = new EditorViewModel(model);
+  var view = new EditorWidget(viewmodel);
+
+  Widget.attach(view, document.getElementById('main'));
+  view.update();
+
+  window.onresize = () => view.update();
+}
+
+window.onload = main;
diff --git a/example/tsconfig.json b/example/tsconfig.json
new file mode 100644
index 0000000..91a3c5d
--- /dev/null
+++ b/example/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "declaration": true,
+    "noImplicitAny": true,
+    "noEmitOnError": true,
+    "sourceMap": true,
+    "module": "commonjs",
+    "target": "ES5",
+    "outDir": "./build"
+  },
+  "files": [
+    "src/index.ts"
+  ]
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..24bb3b4
--- /dev/null
+++ b/package.json
@@ -0,0 +1,64 @@
+{
+  "name": "jupyter-js-editor",
+  "version": "0.1.0",
+  "description": "Code/text editor widget for Jupyter",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "dependencies": {
+    "phosphor-disposable": "^1.0.4",
+    "phosphor-messaging": "^1.0.5",
+    "phosphor-signaling": "^1.1.2",
+    "phosphor-widget": "^0.9.13"
+  },
+  "devDependencies": {
+    "browserify": "^11.0.1",
+    "browserify-css": "^0.6.1",
+    "browserify-istanbul": "^0.2.1",
+    "expect.js": "^0.3.1",
+    "glob-copy": "^0.1.0",
+    "istanbul": "^0.3.18",
+    "karma": "^0.13.9",
+    "karma-browserify": "^4.3.0",
+    "karma-chrome-launcher": "^0.2.0",
+    "karma-firefox-launcher": "^0.1.6",
+    "karma-ie-launcher": "^0.2.0",
+    "karma-mocha": "^0.2.0",
+    "karma-mocha-reporter": "^1.1.1",
+    "mocha": "^2.2.5",
+    "rimraf": "^2.4.2",
+    "typedoc": "^0.3.11",
+    "typescript": "^1.6.2"
+  },
+  "scripts": {
+    "clean": "rimraf docs && rimraf lib && rimraf test/build",
+    "build:src": "tsc --project src && node scripts/copycss.js",
+    "build:test": "tsc --project test",
+    "build:example": "tsc --project example && browserify -t browserify-css example/build/index.js -o example/bundle.js",
+    "build": "npm run build:src && npm run build:example",
+    "docs": "typedoc --options scripts/tdoptions.json",
+    "postinstall": "npm dedupe",
+    "prepublish": "npm run build",
+    "test": "mocha test/build/index.js",
+    "test:debug": "pkill node; node-debug _mocha test/build/index.js",
+    "test:coverage": "istanbul cover _mocha -- test/build/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jupyter/jupyter-js-editor"
+  },
+  "keywords": [
+    "jupyter",
+    "editor"
+  ],
+  "files": [
+    "lib/index.js",
+    "lib/index.css",
+    "lib/index.d.ts"
+  ],
+  "author": "Project Jupyter",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/jupyter/jupyter-js-editor/issues"
+  },
+  "homepage": "https://github.com/jupyter/jupyter-js-editor"
+}
diff --git a/scripts/copycss.js b/scripts/copycss.js
new file mode 100644
index 0000000..e74e877
--- /dev/null
+++ b/scripts/copycss.js
@@ -0,0 +1,3 @@
+var cp = require('glob-copy');
+cp.sync('src/*.css', 'lib');
+cp.sync('test/src/*.css', 'test/build');
diff --git a/scripts/travis_after_success.sh b/scripts/travis_after_success.sh
new file mode 100644
index 0000000..603b0a1
--- /dev/null
+++ b/scripts/travis_after_success.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+if [[ $TRAVIS_PULL_REQUEST == false && $TRAVIS_BRANCH == "master" ]]
+then
+    echo "-- pushing docs --"
+
+    ( cd docs
+    git init
+    git config user.email "travis@travis-ci.com"
+    git config user.name "Travis Bot"
+
+    git add .
+    git commit -m "Deployed to GitHub Pages"
+    git push --force --quiet "https://${GHTOKEN}@${GH_REF}" master:gh-pages > /dev/null 2>&1
+    )
+else
+    echo "-- will only push docs from master --"
+fi
diff --git a/scripts/travis_install.sh b/scripts/travis_install.sh
new file mode 100644
index 0000000..b1b6dd2
--- /dev/null
+++ b/scripts/travis_install.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+npm install
+wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh;
+bash miniconda.sh -b -p $HOME/miniconda
+export PATH="$HOME/miniconda/bin:$PATH"
+hash -r
+conda config --set always_yes yes --set changeps1 no
+conda update -q conda
+conda info -a
+
+# install development version of notebook
+# https://github.com/jupyter/notebook/blob/master/.travis.yml
+git clone https://github.com/jupyter/notebook notebook-dev
+cd notebook-dev
+git clone --quiet --depth 1 https://github.com/minrk/travis-wheels travis-wheels
+pip install -f travis-wheels/wheelhouse .
+
+# create jupyter base dir (needed for config retreival)
+mkdir ~/.jupyter
diff --git a/scripts/travis_script.sh b/scripts/travis_script.sh
new file mode 100644
index 0000000..0709cf2
--- /dev/null
+++ b/scripts/travis_script.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+export DISPLAY=:99.0
+sh -e /etc/init.d/xvfb start
+
+npm run clean
+npm run build
+npm test
+npm run test:coverage
+export PATH="$HOME/miniconda/bin:$PATH"
+npm run test:integration
+npm run docs
diff --git a/src/codemirror-ipython.js b/src/codemirror-ipython.js
new file mode 100644
index 0000000..b58229a
--- /dev/null
+++ b/src/codemirror-ipython.js
@@ -0,0 +1,38 @@
+// IPython mode is just a slightly altered Python Mode with `?` beeing a extra
+// single operator. Here we define `ipython` mode in the require `python`
+// callback to auto-load python mode, which is more likely not the best things
+// to do, but at least the simple one for now.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object"){ // CommonJS
+    mod(require("codemirror/lib/codemirror"),
+        require("codemirror/mode/python/python")
+        );
+  } else if (typeof define == "function" && define.amd){ // AMD
+    define(["codemirror/lib/codemirror",
+            "codemirror/mode/python/python"], mod);
+  } else {// Plain browser env
+    mod(CodeMirror);
+  }
+})(function(CodeMirror) {
+    "use strict";
+
+    CodeMirror.defineMode("ipython", function(conf, parserConf) {
+        var pythonConf = {};
+        for (var prop in parserConf) {
+            if (parserConf.hasOwnProperty(prop)) {
+                pythonConf[prop] = parserConf[prop];
+            }
+        }
+        pythonConf.name = 'python';
+        pythonConf.singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!\\?]");
+        if (pythonConf.version === 3) {
+            pythonConf.identifiers = new RegExp("^[_A-Za-z\u00A1-\uFFFF][_A-Za-z0-9\u00A1-\uFFFF]*");
+        } else if (pythonConf.version === 2) {
+            pythonConf.identifiers = new RegExp("^[_A-Za-z][_A-Za-z0-9]*");
+        }
+        return CodeMirror.getMode(conf, pythonConf);
+    }, 'python');
+
+    CodeMirror.defineMIME("text/x-ipython", "ipython");
+})
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 0000000..6ab08f7
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,296 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+
+import {
+  IDisposable
+} from 'phosphor-disposable';
+
+import {
+  Message
+} from 'phosphor-messaging';
+
+import {
+  Signal, ISignal, clearSignalData
+} from 'phosphor-signaling';
+
+import {
+  Widget, ResizeMessage
+} from 'phosphor-widget';
+
+
+/**
+ * The interface required for an editor model.
+ */
+export
+interface IEditorModel {
+  /**
+   * Saves the current data in the existing file.
+   *
+   * @param data - A string containing the entire data to be saved.
+   */
+  save(data: string): void;
+  /**
+   * Renames the current file.
+   *
+   * @param name - A string denoting the new filename.
+   *
+   * #### Notes
+   * This does *not* remove the existing file, it simply saves a
+   * new file with the same data.
+   */
+  rename(name: string): void;
+}
+
+
+/**
+ * An implementation of IEditorModel.
+ */
+export
+class EditorModel implements IEditorModel {
+
+  save(data: string) {
+    console.log('MODEL SAVE');
+  }
+
+  rename(name: string) {
+    console.log("MODEL RENAME");
+  }
+
+  private _filename: string;
+  private _mode: string;
+  private _lineNumbers = true;
+  private _tabSize = 2;
+}
+
+
+/**
+ * An interface required for implementing the view-model
+ * for an editor.
+ */
+export
+interface IEditorViewModel {
+  /**
+   * Save the current text buffer to the file.
+   */
+  save(data: string): void;
+  /**
+   * Rename this file.
+   */
+  rename(name: string): void;
+  /**
+   * The mode of the editor, eg. for code this would be
+   * the language, like 'python' or 'javascript'.
+   */
+  mode(): string;
+  /**
+   * Sets the view class on on the view model.
+   */
+  setView(view: IEditorWidget): void;
+  /**
+   * A flag to determine whether to show line numbers.
+   */
+  showLineNumbers: boolean;
+  /**
+   * A flag to determine whether to allow editing.
+   */
+  readOnly: boolean;
+  /**
+   * The number of spaces to insert for each tab.
+   */
+  tabSize: number;
+}
+
+export
+class EditorViewModel implements IDisposable, IEditorViewModel {
+
+  /**
+   * Construct an editor view model.
+   */
+  constructor(model: IEditorModel) {
+    this._model = model;
+  }
+
+  /**
+   * Set the view object for this view model.
+   */
+  setView(view: IEditorWidget): void {
+    this._view = view;
+    EditorWidget
+      .getContentsChanged(this._view)
+      .connect(this._startBufferTimer, this);
+  }
+
+  /**
+   * Save the current buffer in the existing file.
+   */
+  save(): void {
+    this._updateBuffer();
+    this._model.save(this._buffer);
+  }
+
+  /**
+   * Rename the current file.
+   */
+  rename(name: string): void {
+    this._model.rename(name);
+  }
+
+  /**
+   * The mode of the current editor.
+   */
+  mode(): string {
+    return this._mode;
+  }
+
+  /**
+   * Dispose of this object.
+   */
+  dispose(): void {
+    this._disposed = true;
+    clearSignalData(this);
+    this._model = null;
+    this._view = null;
+  }
+
+  /**
+   * Get the disposed status of this object.
+   */
+  get isDisposed(): boolean {
+    return this._disposed;
+  }
+
+  private _updateBuffer(): void {
+    if (!this.isDisposed) {
+      var data = this._view.getContents();
+      this._buffer = data;
+    }
+  }
+
+  private _startBufferTimer(): void {
+    clearTimeout(this._bufferTimeoutId);
+    //console.log("setting timeout...");
+    this._bufferTimeoutId = setTimeout(() => {
+      //console.log("TIMED OUT");
+      this._updateBuffer();
+    }, this._bufferDelay);
+  }
+
+  showLineNumbers = true;
+  readOnly = true;
+  tabSize = 2; // TODO
+
+  private _mode = '';
+  private _disposed = false;
+  private _view: IEditorWidget = null;
+  private _model: IEditorModel;
+  private _buffer = '';
+  /**
+   * The delay in milliseconds between view buffer-fetches.
+   */
+  private _bufferDelay = 1000;
+  /**
+   * The id returned by setTimeout.
+   */
+  private _bufferTimeoutId = 0;
+}
+
+/**
+ * The interface to fulfil in order to implement
+ * an EditorWidget.
+ */
+export
+interface IEditorWidget {
+  /**
+   * Get the entire contents of the current editor.
+   */
+  getContents(): string;
+}
+
+/**
+ * A widget used for entering text/code.
+ *
+ * #### Notes
+ * This class happens to use Codemirror as the hosted widget for
+ * text entry, but Codemirror is entirely encapsulated
+ * within this class. As long as the IEditorWidget interface is
+ * adhered to, any other text editor widget can be easily
+ * swapped in.
+ */
+export
+class EditorWidget extends Widget implements IEditorWidget {
+
+  /**
+   * A signal which is emitted when the view contents change.
+   *
+   * #### Notes
+   * This is designed for the view-model. The data is *not* passed
+   * as the signal argument in order that the view-model can decide
+   * when to pull the potentially large data string from the view.
+   */
+  static contentsChangedSignal = new Signal<IEditorWidget, boolean>();
+
+  /**
+   * A delegate for [[contentsChangedSignal]].
+   */
+  static getContentsChanged(item: IEditorWidget): ISignal<IEditorWidget, boolean> {
+    return EditorWidget.contentsChangedSignal.bind(item);
+  }
+
+  /**
+   * Construct an EditorWidget.
+   */
+  constructor(vm: IEditorViewModel) {
+    super();
+    this.addClass('EditorWidget');
+
+    var config = {
+      mode: vm.mode(),
+      lineNumbers: vm.showLineNumbers,
+      tabSize: vm.tabSize
+    };
+    this._editor = CodeMirror(this.node, config);
+    this._editor.on("change", () => {
+      EditorWidget.getContentsChanged(this).emit(true);
+    });
+
+    this._viewmodel = vm;
+    this._viewmodel.setView(this);
+  }
+
+  /**
+   * Get the contents of the current view as a string.
+   */
+  getContents(): string {
+    var doc = this._editor.getDoc();
+    return doc.getValue();
+  }
+
+  /**
+   * Set the font size in the editor.
+   */
+  set fontSize(size: string) {
+    (<any>(this._editor.getWrapperElement())).style["font-size"] = size;
+    this._editor.refresh();
+  }
+
+  protected onAfterAttach(msg: Message): void {
+    this._editor.refresh();
+  }
+
+  protected onResize(msg: ResizeMessage): void {
+    if (msg.width < 0 || msg.height < 0) {
+      this._editor.refresh();
+    } else {
+      this._editor.setSize(msg.width, msg.height);
+    }
+  }
+
+  private _viewmodel: IEditorViewModel;
+  private _editor: CodeMirror.Editor;
+}
diff --git a/src/settings.ts b/src/settings.ts
new file mode 100644
index 0000000..b0349a6
--- /dev/null
+++ b/src/settings.ts
@@ -0,0 +1,48 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+
+/**
+ * The interface for providing custom language settings.
+ */
+export
+interface LanguageSettings {
+  /**
+   * The human readable name for this language.
+   */
+  name: string;
+  /**
+   * The default number of spaces to be used for a tab.
+   */
+  tabSize: number;
+  /**
+   * The file extension to associate with this language.
+   */
+  fileExtension: string;
+}
+
+export
+const PYTHON = {
+  name: 'Python',
+  tabSize: 4,
+  fileExtension: '.py'
+};
+
+export
+const JAVASCRIPT = {
+  name: 'Javascript',
+  tabSize: 2,
+  fileExtension: '.js'
+};
+
+export
+const TYPESCRIPT = {
+  name: 'TypeScript',
+  tabSize: 2,
+  fileExtension: '.ts'
+};
diff --git a/src/tsconfig.json b/src/tsconfig.json
new file mode 100644
index 0000000..ef8f694
--- /dev/null
+++ b/src/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "noImplicitAny": true,
+    "noEmitOnError": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "target": "ES5",
+    "outDir": "../lib"
+  },
+  "files": [
+    "../typings/es6-promise.d.ts",
+    "../typings/codemirror/codemirror.d.ts",
+    "index.ts"
+  ]
+}
diff --git a/typings/codemirror/codemirror.d.ts b/typings/codemirror/codemirror.d.ts
new file mode 100644
index 0000000..2d63f5f
--- /dev/null
+++ b/typings/codemirror/codemirror.d.ts
@@ -0,0 +1,919 @@
+// Type definitions for CodeMirror
+// Project: https://github.com/marijnh/CodeMirror
+// Definitions by: mihailik <https://github.com/mihailik>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare function CodeMirror(host: HTMLElement, options?: CodeMirror.EditorConfiguration): CodeMirror.Editor;
+declare function CodeMirror(callback: (host: HTMLElement) => void , options?: CodeMirror.EditorConfiguration): CodeMirror.Editor;
+
+declare module CodeMirror {
+    export var Pass: any;
+
+    function fromTextArea(host: HTMLTextAreaElement, options?: EditorConfiguration): CodeMirror.EditorFromTextArea;
+
+    var version: string;
+
+    /** If you want to define extra methods in terms of the CodeMirror API, it is possible to use defineExtension.
+    This will cause the given value(usually a method) to be added to all CodeMirror instances created from then on. */
+    function defineExtension(name: string, value: any): void;
+
+    /** Like defineExtension, but the method will be added to the interface for Doc objects instead. */
+    function defineDocExtension(name: string, value: any): void;
+
+    /** Similarly, defineOption can be used to define new options for CodeMirror.
+    The updateFunc will be called with the editor instance and the new value when an editor is initialized,
+    and whenever the option is modified through setOption. */
+    function defineOption(name: string, default_: any, updateFunc: Function): void;
+
+    /** If your extention just needs to run some code whenever a CodeMirror instance is initialized, use CodeMirror.defineInitHook.
+    Give it a function as its only argument, and from then on, that function will be called (with the instance as argument)
+    whenever a new CodeMirror instance is initialized. */
+    function defineInitHook(func: Function): void;
+
+
+
+    function on(element: any, eventName: string, handler: Function): void;
+    function off(element: any, eventName: string, handler: Function): void;
+
+    /** Fired whenever a change occurs to the document. changeObj has a similar type as the object passed to the editor's "change" event,
+    but it never has a next property, because document change events are not batched (whereas editor change events are). */
+    function on(doc: Doc, eventName: 'change', handler: (instance: Doc, change: EditorChange) => void ): void;
+    function off(doc: Doc, eventName: 'change', handler: (instance: Doc, change: EditorChange) => void ): void;
+
+    /** See the description of the same event on editor instances. */
+    function on(doc: Doc, eventName: 'beforeChange', handler: (instance: Doc, change: EditorChangeCancellable) => void ): void;
+    function off(doc: Doc, eventName: 'beforeChange', handler: (instance: Doc, change: EditorChangeCancellable) => void ): void;
+
+    /** Fired whenever the cursor or selection in this document changes. */
+    function on(doc: Doc, eventName: 'cursorActivity', handler: (instance: CodeMirror.Editor) => void ): void;
+    function off(doc: Doc, eventName: 'cursorActivity', handler: (instance: CodeMirror.Editor) => void ): void;
+
+    /** Equivalent to the event by the same name as fired on editor instances. */
+    function on(doc: Doc, eventName: 'beforeSelectionChange', handler: (instance: CodeMirror.Editor, selection: { head: Position; anchor: Position; }) => void ): void;
+    function off(doc: Doc, eventName: 'beforeSelectionChange', handler: (instance: CodeMirror.Editor, selection: { head: Position; anchor: Position; }) => void ): void;
+
+    /** Will be fired when the line object is deleted. A line object is associated with the start of the line.
+    Mostly useful when you need to find out when your gutter markers on a given line are removed. */
+    function on(line: LineHandle, eventName: 'delete', handler: () => void ): void;
+    function off(line: LineHandle, eventName: 'delete', handler: () => void ): void;
+
+    /** Fires when the line's text content is changed in any way (but the line is not deleted outright).
+    The change object is similar to the one passed to change event on the editor object. */
+    function on(line: LineHandle, eventName: 'change', handler: (line: LineHandle, change: EditorChange) => void ): void;
+    function off(line: LineHandle, eventName: 'change', handler: (line: LineHandle, change: EditorChange) => void ): void;
+
+    /** Fired when the cursor enters the marked range. From this event handler, the editor state may be inspected but not modified,
+    with the exception that the range on which the event fires may be cleared. */
+    function on(marker: TextMarker, eventName: 'beforeCursorEnter', handler: () => void ): void;
+    function off(marker: TextMarker, eventName: 'beforeCursorEnter', handler: () => void ): void;
+
+    /** Fired when the range is cleared, either through cursor movement in combination with clearOnEnter or through a call to its clear() method.
+    Will only be fired once per handle. Note that deleting the range through text editing does not fire this event,
+    because an undo action might bring the range back into existence. */
+    function on(marker: TextMarker, eventName: 'clear', handler: () => void ): void;
+    function off(marker: TextMarker, eventName: 'clear', handler: () => void ): void;
+
+    /** Fired when the last part of the marker is removed from the document by editing operations. */
+    function on(marker: TextMarker, eventName: 'hide', handler: () => void ): void;
+    function off(marker: TextMarker, eventName: 'hide', handler: () => void ): void;
+
+    /** Fired when, after the marker was removed by editing, a undo operation brought the marker back. */
+    function on(marker: TextMarker, eventName: 'unhide', handler: () => void ): void;
+    function off(marker: TextMarker, eventName: 'unhide', handler: () => void ): void;
+
+    /** Fired whenever the editor re-adds the widget to the DOM. This will happen once right after the widget is added (if it is scrolled into view),
+    and then again whenever it is scrolled out of view and back in again, or when changes to the editor options
+    or the line the widget is on require the widget to be redrawn. */
+    function on(line: LineWidget, eventName: 'redraw', handler: () => void ): void;
+    function off(line: LineWidget, eventName: 'redraw', handler: () => void ): void;
+
+    /** Various CodeMirror-related objects emit events, which allow client code to react to various situations.
+    Handlers for such events can be registered with the on and off methods on the objects that the event fires on.
+    To fire your own events, use CodeMirror.signal(target, name, args...), where target is a non-DOM-node object. */
+    function signal(target: any, name: string, ...args: any[]): void;
+
+    interface Editor {
+
+        /** Tells you whether the editor currently has focus. */
+        hasFocus(): boolean;
+
+        /** Used to find the target position for horizontal cursor motion.start is a { line , ch } object,
+        amount an integer(may be negative), and unit one of the string "char", "column", or "word".
+        Will return a position that is produced by moving amount times the distance specified by unit.
+        When visually is true , motion in right - to - left text will be visual rather than logical.
+        When the motion was clipped by hitting the end or start of the document, the returned value will have a hitSide property set to true. */
+        findPosH(start: CodeMirror.Position, amount: number, unit: string, visually: boolean): { line: number; ch: number; hitSide?: boolean; };
+
+        /** Similar to findPosH , but used for vertical motion.unit may be "line" or "page".
+        The other arguments and the returned value have the same interpretation as they have in findPosH. */
+        findPosV(start: CodeMirror.Position, amount: number, unit: string): { line: number; ch: number; hitSide?: boolean; };
+
+
+        /** Change the configuration of the editor. option should the name of an option, and value should be a valid value for that option. */
+        setOption(option: string, value: any): void;
+
+        /** Retrieves the current value of the given option for this editor instance. */
+        getOption(option: string): any;
+
+        /** Attach an additional keymap to the editor.
+        This is mostly useful for add - ons that need to register some key handlers without trampling on the extraKeys option.
+        Maps added in this way have a higher precedence than the extraKeys and keyMap options, and between them,
+        the maps added earlier have a lower precedence than those added later, unless the bottom argument was passed,
+        in which case they end up below other keymaps added with this method. */
+        addKeyMap(map: any, bottom?: boolean): void;
+
+        /** Disable a keymap added with addKeyMap.Either pass in the keymap object itself , or a string,
+        which will be compared against the name property of the active keymaps. */
+        removeKeyMap(map: any): void;
+
+        /** Enable a highlighting overlay.This is a stateless mini - mode that can be used to add extra highlighting.
+        For example, the search add - on uses it to highlight the term that's currently being searched.
+        mode can be a mode spec or a mode object (an object with a token method). The options parameter is optional. If given, it should be an object.
+        Currently, only the opaque option is recognized. This defaults to off, but can be given to allow the overlay styling, when not null,
+        to override the styling of the base mode entirely, instead of the two being applied together. */
+        addOverlay(mode: any, options?: any): void;
+
+        /** Pass this the exact argument passed for the mode parameter to addOverlay to remove an overlay again. */
+        removeOverlay(mode: any): void;
+
+
+        /** Retrieve the currently active document from an editor. */
+        getDoc(): CodeMirror.Doc;
+
+        /** Attach a new document to the editor. Returns the old document, which is now no longer associated with an editor. */
+        swapDoc(doc: CodeMirror.Doc): CodeMirror.Doc;
+
+
+
+        /** Sets the gutter marker for the given gutter (identified by its CSS class, see the gutters option) to the given value.
+        Value can be either null, to clear the marker, or a DOM element, to set it. The DOM element will be shown in the specified gutter next to the specified line. */
+        setGutterMarker(line: any, gutterID: string, value: HTMLElement): CodeMirror.LineHandle;
+
+        /** Remove all gutter markers in the gutter with the given ID. */
+        clearGutter(gutterID: string): void;
+
+        /** Set a CSS class name for the given line.line can be a number or a line handle.
+        where determines to which element this class should be applied, can can be one of "text" (the text element, which lies in front of the selection),
+        "background"(a background element that will be behind the selection),
+        or "wrap" (the wrapper node that wraps all of the line's elements, including gutter elements).
+        class should be the name of the class to apply. */
+        addLineClass(line: any, where: string, _class_: string): CodeMirror.LineHandle;
+
+        /** Remove a CSS class from a line.line can be a line handle or number.
+        where should be one of "text", "background", or "wrap"(see addLineClass).
+        class can be left off to remove all classes for the specified node, or be a string to remove only a specific class. */
+        removeLineClass(line: any, where: string, class_: string): CodeMirror.LineHandle;
+
+        /** Returns the line number, text content, and marker status of the given line, which can be either a number or a line handle. */
+        lineInfo(line: any): {
+            line: any;
+            handle: any;
+            text: string;
+            /** Object mapping gutter IDs to marker elements. */
+            gutterMarks: any;
+            textClass: string;
+            bgClass: string;
+            wrapClass: string;
+            /** Array of line widgets attached to this line. */
+            widgets: any;
+        };
+
+        /** Puts node, which should be an absolutely positioned DOM node, into the editor, positioned right below the given { line , ch } position.
+        When scrollIntoView is true, the editor will ensure that the entire node is visible (if possible).
+        To remove the widget again, simply use DOM methods (move it somewhere else, or call removeChild on its parent). */
+        addWidget(pos: CodeMirror.Position, node: HTMLElement, scrollIntoView: boolean): void;
+
+        /** Adds a line widget, an element shown below a line, spanning the whole of the editor's width, and moving the lines below it downwards.
+        line should be either an integer or a line handle, and node should be a DOM node, which will be displayed below the given line.
+        options, when given, should be an object that configures the behavior of the widget.
+        Note that the widget node will become a descendant of nodes with CodeMirror-specific CSS classes, and those classes might in some cases affect it. */
+        addLineWidget(line: any, node: HTMLElement, options?: {
+            /** Whether the widget should cover the gutter. */
+            coverGutter: boolean;
+            /** Whether the widget should stay fixed in the face of horizontal scrolling. */
+            noHScroll: boolean;
+            /** Causes the widget to be placed above instead of below the text of the line. */
+            above: boolean;
+            /** When true, will cause the widget to be rendered even if the line it is associated with is hidden. */
+            showIfHidden: boolean;
+        }): CodeMirror.LineWidget;
+
+
+        /** Programatically set the size of the editor (overriding the applicable CSS rules).
+        width and height height can be either numbers(interpreted as pixels) or CSS units ("100%", for example).
+        You can pass null for either of them to indicate that that dimension should not be changed. */
+        setSize(width: any, height: any): void;
+
+        /** Scroll the editor to a given(pixel) position.Both arguments may be left as null or undefined to have no effect. */
+        scrollTo(x: number, y: number): void;
+
+        /** Get an { left , top , width , height , clientWidth , clientHeight } object that represents the current scroll position, the size of the scrollable area,
+        and the size of the visible area(minus scrollbars). */
+        getScrollInfo(): {
+            left: any;
+            top: any;
+            width: any;
+            height: any;
+            clientWidth: any;
+            clientHeight: any;
+        }
+
+        /** Scrolls the given element into view. pos is a { line , ch } position, referring to a given character, null, to refer to the cursor.
+        The margin parameter is optional. When given, it indicates the amount of pixels around the given area that should be made visible as well. */
+        scrollIntoView(pos: CodeMirror.Position, margin?: number): void;
+
+        /** Scrolls the given element into view. pos is a { left , top , right , bottom } object, in editor-local coordinates.
+        The margin parameter is optional. When given, it indicates the amount of pixels around the given area that should be made visible as well. */
+        scrollIntoView(pos: { left: number; top: number; right: number; bottom: number; }, margin: number): void;
+
+        /** Returns an { left , top , bottom } object containing the coordinates of the cursor position.
+        If mode is "local" , they will be relative to the top-left corner of the editable document.
+        If it is "page" or not given, they are relative to the top-left corner of the page.
+        where is a boolean indicating whether you want the start(true) or the end(false) of the selection. */
+        cursorCoords(where: boolean, mode: string): { left: number; top: number; bottom: number; };
+
+        /** Returns an { left , top , bottom } object containing the coordinates of the cursor position.
+        If mode is "local" , they will be relative to the top-left corner of the editable document.
+        If it is "page" or not given, they are relative to the top-left corner of the page.
+        where specifies the precise position at which you want to measure. */
+        cursorCoords(where: CodeMirror.Position, mode: string): { left: number; top: number; bottom: number; };
+
+        /** Returns the position and dimensions of an arbitrary character.pos should be a { line , ch } object.
+        This differs from cursorCoords in that it'll give the size of the whole character,
+        rather than just the position that the cursor would have when it would sit at that position. */
+        charCoords(pos: CodeMirror.Position, mode: string): { left: number; right: number; top: number; bottom: number; };
+
+        /** Given an { left , top } object , returns the { line , ch } position that corresponds to it.
+        The optional mode parameter determines relative to what the coordinates are interpreted. It may be "window" , "page"(the default) , or "local". */
+        coordsChar(object: { left: number; top: number; }, mode?: string): CodeMirror.Position;
+
+        /** Returns the line height of the default font for the editor. */
+        defaultTextHeight(): number;
+
+        /** Returns the pixel width of an 'x' in the default font for the editor.
+        (Note that for non - monospace fonts , this is mostly useless, and even for monospace fonts, non - ascii characters might have a different width). */
+        defaultCharWidth(): number;
+
+        /** Returns a { from , to } object indicating the start (inclusive) and end (exclusive) of the currently rendered part of the document.
+        In big documents, when most content is scrolled out of view, CodeMirror will only render the visible part, and a margin around it.
+        See also the viewportChange event. */
+        getViewport(): { from: number; to: number };
+
+        /** If your code does something to change the size of the editor element (window resizes are already listened for), or unhides it,
+        you should probably follow up by calling this method to ensure CodeMirror is still looking as intended. */
+        refresh(): void;
+
+
+        /** Retrieves information about the token the current mode found before the given position (a {line, ch} object). */
+        getTokenAt(pos: CodeMirror.Position): {
+            /** The character(on the given line) at which the token starts. */
+            start: number;
+            /** The character at which the token ends. */
+            end: number;
+            /** The token's string. */
+            string: string;
+            /** The token type the mode assigned to the token, such as "keyword" or "comment" (may also be null). */
+            type: string;
+            /** The mode's state at the end of this token. */
+            state: any;
+        };
+
+        /** Returns the mode's parser state, if any, at the end of the given line number.
+        If no line number is given, the state at the end of the document is returned.
+        This can be useful for storing parsing errors in the state, or getting other kinds of contextual information for a line. */
+        getStateAfter(line?: number): any;
+
+        /** CodeMirror internally buffers changes and only updates its DOM structure after it has finished performing some operation.
+        If you need to perform a lot of operations on a CodeMirror instance, you can call this method with a function argument.
+        It will call the function, buffering up all changes, and only doing the expensive update after the function returns.
+        This can be a lot faster. The return value from this method will be the return value of your function. */
+        operation<T>(fn: ()=> T): T;
+
+        /** Adjust the indentation of the given line.
+        The second argument (which defaults to "smart") may be one of:
+        "prev" Base indentation on the indentation of the previous line.
+        "smart" Use the mode's smart indentation if available, behave like "prev" otherwise.
+        "add" Increase the indentation of the line by one indent unit.
+        "subtract" Reduce the indentation of the line. */
+        indentLine(line: number, dir?: string): void;
+
+
+        /** Give the editor focus. */
+        focus(): void;
+
+        /** Returns the hidden textarea used to read input. */
+        getInputField(): HTMLTextAreaElement;
+
+        /** Returns the DOM node that represents the editor, and controls its size. Remove this from your tree to delete an editor instance. */
+        getWrapperElement(): HTMLElement;
+
+        /** Returns the DOM node that is responsible for the scrolling of the editor. */
+        getScrollerElement(): HTMLElement;
+
+        /** Fetches the DOM node that contains the editor gutters. */
+        getGutterElement(): HTMLElement;
+
+
+
+        /** Events are registered with the on method (and removed with the off method).
+        These are the events that fire on the instance object. The name of the event is followed by the arguments that will be passed to the handler.
+        The instance argument always refers to the editor instance. */
+        on(eventName: string, handler: (instance: CodeMirror.Editor) => void ): void;
+        off(eventName: string, handler: (instance: CodeMirror.Editor) => void ): void;
+
+        /** Fires every time the content of the editor is changed. */
+        on(eventName: 'change', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeLinkedList) => void ): void;
+        off(eventName: 'change', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeLinkedList) => void ): void;
+
+        /** This event is fired before a change is applied, and its handler may choose to modify or cancel the change.
+        The changeObj never has a next property, since this is fired for each individual change, and not batched per operation.
+        Note: you may not do anything from a "beforeChange" handler that would cause changes to the document or its visualization.
+        Doing so will, since this handler is called directly from the bowels of the CodeMirror implementation,
+        probably cause the editor to become corrupted. */
+        on(eventName: 'beforeChange', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeCancellable) => void ): void;
+        off(eventName: 'beforeChange', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeCancellable) => void ): void;
+
+        /** Will be fired when the cursor or selection moves, or any change is made to the editor content. */
+        on(eventName: 'cursorActivity', handler: (instance: CodeMirror.Editor) => void ): void;
+        off(eventName: 'cursorActivity', handler: (instance: CodeMirror.Editor) => void ): void;
+
+        /** This event is fired before the selection is moved. Its handler may modify the resulting selection head and anchor.
+        Handlers for this event have the same restriction as "beforeChange" handlers � they should not do anything to directly update the state of the editor. */
+        on(eventName: 'beforeSelectionChange', handler: (instance: CodeMirror.Editor, selection: { head: CodeMirror.Position; anchor: CodeMirror.Position; }) => void ): void;
+        off(eventName: 'beforeSelectionChange', handler: (instance: CodeMirror.Editor, selection: { head: CodeMirror.Position; anchor: CodeMirror.Position; }) => void ): void;
+
+        /** Fires whenever the view port of the editor changes (due to scrolling, editing, or any other factor).
+        The from and to arguments give the new start and end of the viewport. */
+        on(eventName: 'viewportChange', handler: (instance: CodeMirror.Editor, from: number, to: number) => void ): void;
+        off(eventName: 'viewportChange', handler: (instance: CodeMirror.Editor, from: number, to: number) => void ): void;
+
+        /** Fires when the editor gutter (the line-number area) is clicked. Will pass the editor instance as first argument,
+        the (zero-based) number of the line that was clicked as second argument, the CSS class of the gutter that was clicked as third argument,
+        and the raw mousedown event object as fourth argument. */
+        on(eventName: 'gutterClick', handler: (instance: CodeMirror.Editor, line: number, gutter: string, clickEvent: Event) => void ): void;
+        off(eventName: 'gutterClick', handler: (instance: CodeMirror.Editor, line: number, gutter: string, clickEvent: Event) => void ): void;
+
+        /** Fires whenever the editor is focused. */
+        on(eventName: 'focus', handler: (instance: CodeMirror.Editor) => void ): void;
+        off(eventName: 'focus', handler: (instance: CodeMirror.Editor) => void ): void;
+
+        /** Fires whenever the editor is unfocused. */
+        on(eventName: 'blur', handler: (instance: CodeMirror.Editor) => void ): void;
+        off(eventName: 'blur', handler: (instance: CodeMirror.Editor) => void ): void;
+
+        /** Fires when the editor is scrolled. */
+        on(eventName: 'scroll', handler: (instance: CodeMirror.Editor) => void ): void;
+        off(eventName: 'scroll', handler: (instance: CodeMirror.Editor) => void ): void;
+
+        /** Will be fired whenever CodeMirror updates its DOM display. */
+        on(eventName: 'update', handler: (instance: CodeMirror.Editor) => void ): void;
+        off(eventName: 'update', handler: (instance: CodeMirror.Editor) => void ): void;
+
+        /** Fired whenever a line is (re-)rendered to the DOM. Fired right after the DOM element is built, before it is added to the document.
+        The handler may mess with the style of the resulting element, or add event handlers, but should not try to change the state of the editor. */
+        on(eventName: 'renderLine', handler: (instance: CodeMirror.Editor, line: number, element: HTMLElement) => void ): void;
+        off(eventName: 'renderLine', handler: (instance: CodeMirror.Editor, line: number, element: HTMLElement) => void ): void;
+    }
+
+    interface EditorFromTextArea extends Editor {
+
+        /** Copy the content of the editor into the textarea. */
+        save(): void;
+
+        /** Remove the editor, and restore the original textarea (with the editor's current content). */
+        toTextArea(): void;
+
+        /** Returns the textarea that the instance was based on. */
+        getTextArea(): HTMLTextAreaElement;
+    }
+
+    class Doc {
+        constructor (text: string, mode?: any, firstLineNumber?: number);
+
+        /** Get the current editor content. You can pass it an optional argument to specify the string to be used to separate lines (defaults to "\n"). */
+        getValue(seperator?: string): string;
+
+        /** Set the editor content. */
+        setValue(content: string): void;
+
+        /** Get the text between the given points in the editor, which should be {line, ch} objects.
+        An optional third argument can be given to indicate the line separator string to use (defaults to "\n"). */
+        getRange(from: Position, to: CodeMirror.Position, seperator?: string): string;
+
+        /** Replace the part of the document between from and to with the given string.
+        from and to must be {line, ch} objects. to can be left off to simply insert the string at position from. */
+        replaceRange(replacement: string, from: CodeMirror.Position, to: CodeMirror.Position): void;
+
+        /** Get the content of line n. */
+        getLine(n: number): string;
+
+        /** Set the content of line n. */
+        setLine(n: number, text: string): void;
+
+        /** Remove the given line from the document. */
+        removeLine(n: number): void;
+
+        /** Get the number of lines in the editor. */
+        lineCount(): number;
+
+        /** Get the first line of the editor. This will usually be zero but for linked sub-views,
+        or documents instantiated with a non-zero first line, it might return other values. */
+        firstLine(): number;
+
+        /** Get the last line of the editor. This will usually be lineCount() - 1, but for linked sub-views, it might return other values. */
+        lastLine(): number;
+
+        /** Fetches the line handle for the given line number. */
+        getLineHandle(num: number): CodeMirror.LineHandle;
+
+        /** Given a line handle, returns the current position of that line (or null when it is no longer in the document). */
+        getLineNumber(handle: CodeMirror.LineHandle): number;
+
+        /** Iterate over the whole document, and call f for each line, passing the line handle.
+        This is a faster way to visit a range of line handlers than calling getLineHandle for each of them.
+        Note that line handles have a text property containing the line's content (as a string). */
+        eachLine(f: (line: CodeMirror.LineHandle) => void ): void;
+
+        /** Iterate over the range from start up to (not including) end, and call f for each line, passing the line handle.
+        This is a faster way to visit a range of line handlers than calling getLineHandle for each of them.
+        Note that line handles have a text property containing the line's content (as a string). */
+        eachLine(start: number, end: number, f: (line: CodeMirror.LineHandle) => void ): void;
+
+        /** Set the editor content as 'clean', a flag that it will retain until it is edited, and which will be set again when such an edit is undone again.
+        Useful to track whether the content needs to be saved. */
+        markClean(): void;
+
+        /** Returns whether the document is currently clean (not modified since initialization or the last call to markClean). */
+        isClean(): boolean;
+
+
+
+        /** Get the currently selected code. */
+        getSelection(): string;
+
+        /** Replace the selection with the given string. By default, the new selection will span the inserted text.
+        The optional collapse argument can be used to change this � passing "start" or "end" will collapse the selection to the start or end of the inserted text. */
+        replaceSelection(replacement: string, collapse?: string): void;
+
+        /** start is a an optional string indicating which end of the selection to return.
+        It may be "start" , "end" , "head"(the side of the selection that moves when you press shift + arrow),
+        or "anchor"(the fixed side of the selection).Omitting the argument is the same as passing "head".A { line , ch } object will be returned. */
+        getCursor(start?: string): CodeMirror.Position;
+
+        /** Return true if any text is selected. */
+        somethingSelected(): boolean;
+
+        /** Set the cursor position.You can either pass a single { line , ch } object , or the line and the character as two separate parameters. */
+        setCursor(pos: CodeMirror.Position): void;
+
+        /** Set the selection range.anchor and head should be { line , ch } objects.head defaults to anchor when not given. */
+        setSelection(anchor: CodeMirror.Position, head: CodeMirror.Position): void;
+
+        /** Similar to setSelection , but will, if shift is held or the extending flag is set,
+        move the head of the selection while leaving the anchor at its current place.
+        pos2 is optional , and can be passed to ensure a region (for example a word or paragraph) will end up selected
+        (in addition to whatever lies between that region and the current anchor). */
+        extendSelection(from: CodeMirror.Position, to?: CodeMirror.Position): void;
+
+        /** Sets or clears the 'extending' flag , which acts similar to the shift key,
+        in that it will cause cursor movement and calls to extendSelection to leave the selection anchor in place. */
+        setExtending(value: boolean): void;
+
+
+        /** Retrieve the editor associated with a document. May return null. */
+        getEditor(): CodeMirror.Editor;
+
+
+        /** Create an identical copy of the given doc. When copyHistory is true , the history will also be copied.Can not be called directly on an editor. */
+        copy(copyHistory: boolean): CodeMirror.Doc;
+
+        /** Create a new document that's linked to the target document. Linked documents will stay in sync (changes to one are also applied to the other) until unlinked. */
+        linkedDoc(options: {
+            /** When turned on, the linked copy will share an undo history with the original.
+            Thus, something done in one of the two can be undone in the other, and vice versa. */
+            sharedHist?: boolean;
+            from?: number;
+            /** Can be given to make the new document a subview of the original. Subviews only show a given range of lines.
+            Note that line coordinates inside the subview will be consistent with those of the parent,
+            so that for example a subview starting at line 10 will refer to its first line as line 10, not 0. */
+            to?: number;
+            /** By default, the new document inherits the mode of the parent. This option can be set to a mode spec to give it a different mode. */
+            mode: any;
+        }): CodeMirror.Doc;
+
+        /** Break the link between two documents. After calling this , changes will no longer propagate between the documents,
+        and, if they had a shared history, the history will become separate. */
+        unlinkDoc(doc: CodeMirror.Doc): void;
+
+        /** Will call the given function for all documents linked to the target document. It will be passed two arguments,
+        the linked document and a boolean indicating whether that document shares history with the target. */
+        iterLinkedDocs(fn: (doc: CodeMirror.Doc, sharedHist: boolean) => void ): void;
+
+        /** Undo one edit (if any undo events are stored). */
+        undo(): void;
+
+        /** Redo one undone edit. */
+        redo(): void;
+
+        /** Returns an object with {undo, redo } properties , both of which hold integers , indicating the amount of stored undo and redo operations. */
+        historySize(): { undo: number; redo: number; };
+
+        /** Clears the editor's undo history. */
+        clearHistory(): void;
+
+        /** Get a(JSON - serializeable) representation of the undo history. */
+        getHistory(): any;
+
+        /** Replace the editor's undo history with the one provided, which must be a value as returned by getHistory.
+        Note that this will have entirely undefined results if the editor content isn't also the same as it was when getHistory was called. */
+        setHistory(history: any): void;
+
+
+        /** Can be used to mark a range of text with a specific CSS class name. from and to should be { line , ch } objects. */
+        markText(from: CodeMirror.Position, to: CodeMirror.Position, options?: CodeMirror.TextMarkerOptions): TextMarker;
+
+        /** Inserts a bookmark, a handle that follows the text around it as it is being edited, at the given position.
+        A bookmark has two methods find() and clear(). The first returns the current position of the bookmark, if it is still in the document,
+        and the second explicitly removes the bookmark. */
+        setBookmark(pos: CodeMirror.Position, options?: {
+            /** Can be used to display a DOM node at the current location of the bookmark (analogous to the replacedWith option to markText). */
+            widget?: HTMLElement;
+
+            /** By default, text typed when the cursor is on top of the bookmark will end up to the right of the bookmark.
+            Set this option to true to make it go to the left instead. */
+            insertLeft?: boolean;
+        }): CodeMirror.TextMarker;
+
+        /** Returns an array of all the bookmarks and marked ranges present at the given position. */
+        findMarksAt(pos: CodeMirror.Position): TextMarker[];
+
+        /** Returns an array containing all marked ranges in the document. */
+        getAllMarks(): CodeMirror.TextMarker[];
+
+
+        /** Gets the mode object for the editor. Note that this is distinct from getOption("mode"), which gives you the mode specification,
+        rather than the resolved, instantiated mode object. */
+        getMode(): any;
+
+        /** Calculates and returns a { line , ch } object for a zero-based index whose value is relative to the start of the editor's text.
+        If the index is out of range of the text then the returned object is clipped to start or end of the text respectively. */
+        posFromIndex(index: number): CodeMirror.Position;
+
+        /** The reverse of posFromIndex. */
+        indexFromPos(object: CodeMirror.Position): number;
+
+    }
+
+    interface LineHandle {
+        text: string;
+    }
+
+    interface TextMarker {
+        /** Remove the mark. */
+        clear(): void;
+
+        /** Returns a {from, to} object (both holding document positions), indicating the current position of the marked range,
+        or undefined if the marker is no longer in the document. */
+        find(): CodeMirror.Position;
+
+        /**  Returns an object representing the options for the marker. If copyWidget is given true, it will clone the value of the replacedWith option, if any. */
+        getOptions(copyWidget: boolean): CodeMirror.TextMarkerOptions;
+    }
+
+    interface LineWidget {
+        /** Removes the widget. */
+        clear(): void;
+
+        /** Call this if you made some change to the widget's DOM node that might affect its height.
+        It'll force CodeMirror to update the height of the line that contains the widget. */
+        changed(): void;
+    }
+
+    interface EditorChange {
+        /** Position (in the pre-change coordinate system) where the change started. */
+        from: CodeMirror.Position;
+        /** Position (in the pre-change coordinate system) where the change ended. */
+        to: CodeMirror.Position;
+        /** Array of strings representing the text that replaced the changed range (split by line). */
+        text: string[];
+        /**  Text that used to be between from and to, which is overwritten by this change. */
+        removed: string;
+    }
+
+    interface EditorChangeLinkedList extends CodeMirror.EditorChange {
+        /** Points to another change object (which may point to another, etc). */
+        next?: CodeMirror.EditorChangeLinkedList;
+    }
+
+    interface EditorChangeCancellable extends CodeMirror.EditorChange {
+        /** may be used to modify the change. All three arguments to update are optional, and can be left off to leave the existing value for that field intact. */
+        update(from?: CodeMirror.Position, to?: CodeMirror.Position, text?: string): void;
+
+        cancel(): void;
+    }
+
+    interface Position {
+        ch: number;
+        line: number;
+    }
+
+    interface EditorConfiguration {
+        /** string| The starting value of the editor. Can be a string, or a document object. */
+        value?: any;
+
+        /** string|object. The mode to use. When not given, this will default to the first mode that was loaded.
+        It may be a string, which either simply names the mode or is a MIME type associated with the mode.
+        Alternatively, it may be an object containing configuration options for the mode,
+        with a name property that names the mode (for example {name: "javascript", json: true}). */
+        mode?: any;
+
+        /** The theme to style the editor with. You must make sure the CSS file defining the corresponding .cm-s-[name] styles is loaded.
+        The default is "default". */
+        theme?: string;
+
+        /** How many spaces a block (whatever that means in the edited language) should be indented. The default is 2. */
+        indentUnit?: number;
+
+        /** Whether to use the context-sensitive indentation that the mode provides (or just indent the same as the line before). Defaults to true. */
+        smartIndent?: boolean;
+
+        /** The width of a tab character. Defaults to 4. */
+        tabSize?: number;
+
+        /** Whether, when indenting, the first N*tabSize spaces should be replaced by N tabs. Default is false. */
+        indentWithTabs?: boolean;
+
+        /** Configures whether the editor should re-indent the current line when a character is typed
+        that might change its proper indentation (only works if the mode supports indentation). Default is true. */
+        electricChars?: boolean;
+
+        /** Determines whether horizontal cursor movement through right-to-left (Arabic, Hebrew) text
+        is visual (pressing the left arrow moves the cursor left)
+        or logical (pressing the left arrow moves to the next lower index in the string, which is visually right in right-to-left text).
+        The default is false on Windows, and true on other platforms. */
+        rtlMoveVisually?: boolean;
+
+        /** Configures the keymap to use. The default is "default", which is the only keymap defined in codemirror.js itself.
+        Extra keymaps are found in the keymap directory. See the section on keymaps for more information. */
+        keyMap?: string;
+
+        /** Can be used to specify extra keybindings for the editor, alongside the ones defined by keyMap. Should be either null, or a valid keymap value. */
+        extraKeys?: any;
+
+        /** Whether CodeMirror should scroll or wrap for long lines. Defaults to false (scroll). */
+        lineWrapping?: boolean;
+
+        /** Whether to show line numbers to the left of the editor. */
+        lineNumbers?: boolean;
+
+        /** At which number to start counting lines. Default is 1. */
+        firstLineNumber?: number;
+
+        /** A function used to format line numbers. The function is passed the line number, and should return a string that will be shown in the gutter. */
+        lineNumberFormatter?: (line: number) => string;
+
+        /** Can be used to add extra gutters (beyond or instead of the line number gutter).
+        Should be an array of CSS class names, each of which defines a width (and optionally a background),
+        and which will be used to draw the background of the gutters.
+        May include the CodeMirror-linenumbers class, in order to explicitly set the position of the line number gutter
+        (it will default to be to the right of all other gutters). These class names are the keys passed to setGutterMarker. */
+        gutters?: string[];
+
+        /** Determines whether the gutter scrolls along with the content horizontally (false)
+        or whether it stays fixed during horizontal scrolling (true, the default). */
+        fixedGutter?: boolean;
+
+        /** boolean|string. This disables editing of the editor content by the user. If the special value "nocursor" is given (instead of simply true), focusing of the editor is also disallowed. */
+        readOnly?: any;
+
+        /**Whether the cursor should be drawn when a selection is active. Defaults to false. */
+        showCursorWhenSelecting?: boolean;
+
+        /** The maximum number of undo levels that the editor stores. Defaults to 40. */
+        undoDepth?: number;
+
+        /** The period of inactivity (in milliseconds) that will cause a new history event to be started when typing or deleting. Defaults to 500. */
+        historyEventDelay?: number;
+
+        /** The tab index to assign to the editor. If not given, no tab index will be assigned. */
+        tabindex?: number;
+
+        /** Can be used to make CodeMirror focus itself on initialization. Defaults to off.
+        When fromTextArea is used, and no explicit value is given for this option, it will be set to true when either the source textarea is focused,
+        or it has an autofocus attribute and no other element is focused. */
+        autofocus?: boolean;
+
+        /** Controls whether drag-and - drop is enabled. On by default. */
+        dragDrop?: boolean;
+
+        /** When given , this will be called when the editor is handling a dragenter , dragover , or drop event.
+        It will be passed the editor instance and the event object as arguments.
+        The callback can choose to handle the event itself , in which case it should return true to indicate that CodeMirror should not do anything further. */
+        onDragEvent?: (instance: CodeMirror.Editor, event: Event) => boolean;
+
+        /** This provides a rather low - level hook into CodeMirror's key handling.
+        If provided, this function will be called on every keydown, keyup, and keypress event that CodeMirror captures.
+        It will be passed two arguments, the editor instance and the key event.
+        This key event is pretty much the raw key event, except that a stop() method is always added to it.
+        You could feed it to, for example, jQuery.Event to further normalize it.
+        This function can inspect the key event, and handle it if it wants to.
+        It may return true to tell CodeMirror to ignore the event.
+        Be wary that, on some browsers, stopping a keydown does not stop the keypress from firing, whereas on others it does.
+        If you respond to an event, you should probably inspect its type property and only do something when it is keydown
+        (or keypress for actions that need character data). */
+        onKeyEvent?: (instance: CodeMirror.Editor, event: Event) => boolean;
+
+        /** Half - period in milliseconds used for cursor blinking. The default blink rate is 530ms. */
+        cursorBlinkRate?: number;
+
+        /** Determines the height of the cursor. Default is 1 , meaning it spans the whole height of the line.
+        For some fonts (and by some tastes) a smaller height (for example 0.85),
+        which causes the cursor to not reach all the way to the bottom of the line, looks better */
+        cursorHeight?: number;
+
+        /** Highlighting is done by a pseudo background - thread that will work for workTime milliseconds,
+        and then use timeout to sleep for workDelay milliseconds.
+        The defaults are 200 and 300, you can change these options to make the highlighting more or less aggressive. */
+        workTime?: number;
+
+        /** See workTime. */
+        workDelay?: number;
+
+        /** Indicates how quickly CodeMirror should poll its input textarea for changes(when focused).
+        Most input is captured by events, but some things, like IME input on some browsers, don't generate events that allow CodeMirror to properly detect it.
+        Thus, it polls. Default is 100 milliseconds. */
+        pollInterval?: number
+
+        /** By default, CodeMirror will combine adjacent tokens into a single span if they have the same class.
+        This will result in a simpler DOM tree, and thus perform better. With some kinds of styling(such as rounded corners),
+        this will change the way the document looks. You can set this option to false to disable this behavior. */
+        flattenSpans?: boolean;
+
+        /** When highlighting long lines, in order to stay responsive, the editor will give up and simply style
+        the rest of the line as plain text when it reaches a certain position. The default is 10000.
+        You can set this to Infinity to turn off this behavior. */
+        maxHighlightLength?: number;
+
+        /** Specifies the amount of lines that are rendered above and below the part of the document that's currently scrolled into view.
+        This affects the amount of updates needed when scrolling, and the amount of work that such an update does.
+        You should usually leave it at its default, 10. Can be set to Infinity to make sure the whole document is always rendered,
+        and thus the browser's text search works on it. This will have bad effects on performance of big documents. */
+        viewportMargin?: number;
+    }
+
+    interface TextMarkerOptions {
+        /** Assigns a CSS class to the marked stretch of text. */
+        className?: string;
+
+        /** Determines whether text inserted on the left of the marker will end up inside or outside of it. */
+        inclusiveLeft?: boolean;
+
+        /** Like inclusiveLeft , but for the right side. */
+        inclusiveRight?: boolean;
+
+        /** Atomic ranges act as a single unit when cursor movement is concerned � i.e. it is impossible to place the cursor inside of them.
+        In atomic ranges, inclusiveLeft and inclusiveRight have a different meaning � they will prevent the cursor from being placed
+        respectively directly before and directly after the range. */
+        atomic?: boolean;
+
+        /** Collapsed ranges do not show up in the display.Setting a range to be collapsed will automatically make it atomic. */
+        collapsed?: boolean;
+
+        /** When enabled, will cause the mark to clear itself whenever the cursor enters its range.
+        This is mostly useful for text - replacement widgets that need to 'snap open' when the user tries to edit them.
+        The "clear" event fired on the range handle can be used to be notified when this happens. */
+        clearOnEnter?: boolean;
+
+        /** Use a given node to display this range.Implies both collapsed and atomic.
+        The given DOM node must be an inline element(as opposed to a block element). */
+        replacedWith?: HTMLElement;
+
+        /** A read - only span can, as long as it is not cleared, not be modified except by calling setValue to reset the whole document.
+        Note: adding a read - only span currently clears the undo history of the editor,
+        because existing undo events being partially nullified by read - only spans would corrupt the history (in the current implementation). */
+        readOnly?: boolean;
+
+        /** When set to true (default is false), adding this marker will create an event in the undo history that can be individually undone(clearing the marker). */
+        addToHistory?: boolean;
+
+        /** Can be used to specify an extra CSS class to be applied to the leftmost span that is part of the marker. */
+        startStyle?: string;
+
+        /** Equivalent to startStyle, but for the rightmost span. */
+        endStyle?: string;
+
+        /** When the target document is linked to other documents, you can set shared to true to make the marker appear in all documents.
+        By default, a marker appears only in its target document. */
+        shared?: boolean;
+    }
+
+    interface StringStream {
+        lastColumnPos: number;
+        lastColumnValue: number;
+        lineStart: number;
+
+        /**
+         * Current position in the string.
+         */
+        pos: number;
+
+        /**
+         * Where the stream's position was when it was first passed to the token function.
+         */
+        start: number;
+
+        /**
+         * The current line's content.
+         */
+        string: string;
+
+        /**
+         * Number of spaces per tab character.
+         */
+        tabSize: number;
+
+        /**
+         * Returns true only if the stream is at the end of the line.
+         */
+        eol(): boolean;
+
+        /**
+         * Returns true only if the stream is at the start of the line.
+         */
+        sol(): boolean;
+
+        /**
+         * Returns the next character in the stream without advancing it. Will return an null at the end of the line.
+         */
+        peek(): string;
+
+        /**
+         * Returns the next character in the stream and advances it. Also returns null when no more characters are available.
+         */
+        next(): string;
+
+        /**
+         * match can be a character, a regular expression, or a function that takes a character and returns a boolean.
+         * If the next character in the stream 'matches' the given argument, it is consumed and returned.
+         * Otherwise, undefined is returned.
+         */
+        eat(match: string): string;
+        eat(match: RegExp): string;
+        eat(match: (char: string) => boolean): string;
+
+        /**
+         * Repeatedly calls eat with the given argument, until it fails. Returns true if any characters were eaten.
+         */
+        eatWhile(match: string): boolean;
+        eatWhile(match: RegExp): boolean;
+        eatWhile(match: (char: string) => boolean): boolean;
+
+        /**
+         * Shortcut for eatWhile when matching white-space.
+         */
+        eatSpace(): boolean;
+
+        /**
+         * Moves the position to the end of the line.
+         */
+        skipToEnd(): void;
+
+        /**
+         * Skips to the next occurrence of the given character, if found on the current line (doesn't advance the stream if
+         * the character does not occur on the line).
+         *
+         * Returns true if the character was found.
+         */
+        skipTo(ch: string): boolean;
+
+        /**
+         * Act like a multi-character eat - if consume is true or not given - or a look-ahead that doesn't update the stream
+         * position - if it is false. pattern can be either a string or a regular expression starting with ^. When it is a
+         * string, caseFold can be set to true to make the match case-insensitive. When successfully matching a regular
+         * expression, the returned value will be the array returned by match, in case you need to extract matched groups.
+         */
+        match(pattern: string, consume?: boolean, caseFold?: boolean): boolean;
+        match(pattern: RegExp, consume?: boolean): string[];
+
+        /**
+         * Backs up the stream n characters. Backing it up further than the start of the current token will cause things to
+         * break, so be careful.
+         */
+        backUp(n: number): void;
+
+        /**
+         * Returns the column (taking into account tabs) at which the current token starts.
+         */
+        column(): number;
+
+        /**
+         * Tells you how far the current line has been indented, in spaces. Corrects for tab characters.
+         */
+        indentation(): number;
+
+        /**
+         * Get the string between the start of the current token and the current stream position.
+         */
+        current(): string;
+    }
+}
diff --git a/typings/es6-promise.d.ts b/typings/es6-promise.d.ts
new file mode 100644
index 0000000..4a793e5
--- /dev/null
+++ b/typings/es6-promise.d.ts
@@ -0,0 +1,71 @@
+// Type definitions for es6-promise
+// Project: https://github.com/jakearchibald/ES6-Promise
+// Definitions by: François de Campredon <https://github.com/fdecampredon/>, vvakame <https://github.com/vvakame>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Thenable<R> {
+	then<U>(onFulfilled?: (value: R) => U | Thenable<U>,  onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+}
+
+declare class Promise<R> implements Thenable<R> {
+	/**
+	 * If you call resolve in the body of the callback passed to the constructor,
+	 * your promise is fulfilled with result object passed to resolve.
+	 * If you call reject your promise is rejected with the object passed to resolve.
+	 * For consistency and debugging (eg stack traces), obj should be an instanceof Error.
+	 * Any errors thrown in the constructor callback will be implicitly passed to reject().
+	 */
+	constructor(callback: (resolve : (value?: R | Thenable<R>) => void, reject: (error?: any) => void) => void);
+
+	/**
+	 * onFulfilled is called when/if "promise" resolves. onRejected is called when/if "promise" rejects.
+	 * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called.
+	 * Both callbacks have a single parameter , the fulfillment value or rejection reason.
+	 * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve.
+	 * If an error is thrown in the callback, the returned promise rejects with that error.
+	 *
+	 * @param onFulfilled called when/if "promise" resolves
+	 * @param onRejected called when/if "promise" rejects
+	 */
+	then<U>(onFulfilled?: (value: R) => U | Thenable<U>,  onRejected?: (error: any) => U | Thenable<U>): Promise<U>;
+
+	/**
+	 * Sugar for promise.then(undefined, onRejected)
+	 *
+	 * @param onRejected called when/if "promise" rejects
+	 */
+	catch<U>(onRejected?: (error: any) => U | Thenable<U>): Promise<U>;
+}
+
+declare module Promise {
+	/**
+	 * Make a new promise from the thenable.
+	 * A thenable is promise-like in as far as it has a "then" method.
+	 */
+	function resolve<R>(value?: R | Thenable<R>): Promise<R>;
+
+	/**
+	 * Make a promise that rejects to obj. For consistency and debugging (eg stack traces), obj should be an instanceof Error
+	 */
+	function reject(error: any): Promise<any>;
+
+	/**
+	 * Make a promise that fulfills when every item in the array fulfills, and rejects if (and when) any item rejects.
+	 * the array passed to all can be a mixture of promise-like objects and other objects.
+	 * The fulfillment value is an array (in order) of fulfillment values. The rejection value is the first rejection value.
+	 */
+	function all<R>(promises: (R | Thenable<R>)[]): Promise<R[]>;
+
+	/**
+	 * Make a Promise that fulfills when any item fulfills, and rejects if any item rejects.
+	 */
+	function race<R>(promises: (R | Thenable<R>)[]): Promise<R>;
+}
+
+declare module 'es6-promise' {
+	var foo: typeof Promise; // Temp variable to reference Promise in local context
+	module rsvp {
+		export var Promise: typeof foo;
+	}
+	export = rsvp;
+}
diff --git a/typings/expect.js/expect.js.d.ts b/typings/expect.js/expect.js.d.ts
new file mode 100644
index 0000000..a208ed1
--- /dev/null
+++ b/typings/expect.js/expect.js.d.ts
@@ -0,0 +1,227 @@
+// Type definitions for expect.js 0.3.1
+// Project: https://github.com/Automattic/expect.js
+// Definitions by: Teppei Sato <https://github.com/teppeis>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare function expect(target?: any): Expect.Root;
+
+declare module Expect {
+    interface Assertion {
+        /**
+         * Check if the value is truthy
+         */
+        ok(): void;
+
+        /**
+         * Creates an anonymous function which calls fn with arguments.
+         */
+        withArgs(...args: any[]): Root;
+
+        /**
+         * Assert that the function throws.
+         *
+         * @param fn callback to match error string against
+         */
+        throwError(fn?: (exception: any) => void): void;
+
+        /**
+         * Assert that the function throws.
+         *
+         * @param fn callback to match error string against
+         */
+        throwException(fn?: (exception: any) => void): void;
+
+        /**
+         * Assert that the function throws.
+         *
+         * @param regexp regexp to match error string against
+         */
+        throwError(regexp: RegExp): void;
+
+        /**
+         * Assert that the function throws.
+         *
+         * @param fn callback to match error string against
+         */
+        throwException(regexp: RegExp): void;
+
+        /**
+         * Checks if the array is empty.
+         */
+        empty(): Assertion;
+
+        /**
+         * Checks if the obj exactly equals another.
+         */
+        equal(obj: any): Assertion;
+
+        /**
+         * Checks if the obj sortof equals another.
+         */
+        eql(obj: any): Assertion;
+
+        /**
+         * Assert within start to finish (inclusive).
+         *
+         * @param start
+         * @param finish
+         */
+        within(start: number, finish: number): Assertion;
+
+        /**
+         * Assert typeof.
+         */
+        a(type: string): Assertion;
+
+        /**
+         * Assert instanceof.
+         */
+        a(type: Function): Assertion;
+
+        /**
+         * Assert typeof / instanceof.
+         */
+        an: An;
+
+        /**
+         * Assert numeric value above n.
+         */
+        greaterThan(n: number): Assertion;
+
+        /**
+         * Assert numeric value above n.
+         */
+        above(n: number): Assertion;
+
+        /**
+         * Assert numeric value below n.
+         */
+        lessThan(n: number): Assertion;
+
+        /**
+         * Assert numeric value below n.
+         */
+        below(n: number): Assertion;
+
+        /**
+         * Assert string value matches regexp.
+         *
+         * @param regexp
+         */
+        match(regexp: RegExp): Assertion;
+
+        /**
+         * Assert property "length" exists and has value of n.
+         *
+         * @param n
+         */
+        length(n: number): Assertion;
+
+        /**
+         * Assert property name exists, with optional val.
+         *
+         * @param name
+         * @param val
+         */
+        property(name: string, val?: any): Assertion;
+
+        /**
+         * Assert that string contains str.
+         */
+        contain(str: string): Assertion;
+        string(str: string): Assertion;
+
+        /**
+         * Assert that the array contains obj.
+         */
+        contain(obj: any): Assertion;
+        string(obj: any): Assertion;
+
+        /**
+         * Assert exact keys or inclusion of keys by using the `.own` modifier.
+         */
+        key(keys: string[]): Assertion;
+        /**
+         * Assert exact keys or inclusion of keys by using the `.own` modifier.
+         */
+        key(...keys: string[]): Assertion;
+        /**
+         * Assert exact keys or inclusion of keys by using the `.own` modifier.
+         */
+        keys(keys: string[]): Assertion;
+        /**
+         * Assert exact keys or inclusion of keys by using the `.own` modifier.
+         */
+        keys(...keys: string[]): Assertion;
+
+        /**
+         * Assert a failure.
+         */
+        fail(message?: string): Assertion;
+    }
+
+    interface Root extends Assertion {
+        not: Not;
+        to: To;
+        only: Only;
+        have: Have;
+        be: Be;
+    }
+
+    interface Be extends Assertion {
+        /**
+         * Checks if the obj exactly equals another.
+         */
+        (obj: any): Assertion;
+
+        an: An;
+    }
+
+    interface An extends Assertion {
+        /**
+         * Assert typeof.
+         */
+        (type: string): Assertion;
+
+        /**
+         * Assert instanceof.
+         */
+        (type: Function): Assertion;
+    }
+
+    interface Not extends Expect.NotBase {
+        to: Expect.ToBase;
+    }
+
+    interface NotBase extends Assertion {
+        be: Be;
+        have: Have;
+        include: Assertion;
+        only: Only;
+    }
+
+    interface To extends Expect.ToBase {
+        not: Expect.NotBase;
+    }
+
+    interface ToBase extends Assertion {
+        be: Be;
+        have: Have;
+        include: Assertion;
+        only: Only;
+    }
+
+    interface Only extends Assertion {
+        have: Have;
+    }
+
+    interface Have extends Assertion {
+        own: Assertion;
+    }
+}
+
+declare module "expect.js" {
+
+    export = expect;
+
+}
diff --git a/typings/mocha/mocha.d.ts b/typings/mocha/mocha.d.ts
new file mode 100644
index 0000000..b4f182a
--- /dev/null
+++ b/typings/mocha/mocha.d.ts
@@ -0,0 +1,220 @@
+// Type definitions for mocha 2.2.5
+// Project: http://mochajs.org/
+// Definitions by: Kazi Manzur Rashid <https://github.com/kazimanzurrashid/>, otiai10 <https://github.com/otiai10>, jt000 <https://github.com/jt000>, Vadim Macagon <https://github.com/enlight>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface MochaSetupOptions {
+    //milliseconds to wait before considering a test slow
+    slow?: number;
+
+    // timeout in milliseconds
+    timeout?: number;
+
+    // ui name "bdd", "tdd", "exports" etc
+    ui?: string;
+
+    //array of accepted globals
+    globals?: any[];
+
+    // reporter instance (function or string), defaults to `mocha.reporters.Spec`
+    reporter?: any;
+
+    // bail on the first test failure
+    bail?: boolean;
+
+    // ignore global leaks
+    ignoreLeaks?: boolean;
+
+    // grep string or regexp to filter tests with
+    grep?: any;
+}
+
+interface MochaDone {
+    (error?: Error): void;
+}
+
+declare var mocha: Mocha;
+declare var describe: Mocha.IContextDefinition;
+declare var xdescribe: Mocha.IContextDefinition;
+// alias for `describe`
+declare var context: Mocha.IContextDefinition;
+// alias for `describe`
+declare var suite: Mocha.IContextDefinition;
+declare var it: Mocha.ITestDefinition;
+declare var xit: Mocha.ITestDefinition;
+// alias for `it`
+declare var test: Mocha.ITestDefinition;
+
+declare function before(action: () => void): void;
+
+declare function before(action: (done: MochaDone) => void): void;
+
+declare function setup(action: () => void): void;
+
+declare function setup(action: (done: MochaDone) => void): void;
+
+declare function after(action: () => void): void;
+
+declare function after(action: (done: MochaDone) => void): void;
+
+declare function teardown(action: () => void): void;
+
+declare function teardown(action: (done: MochaDone) => void): void;
+
+declare function beforeEach(action: () => void): void;
+
+declare function beforeEach(action: (done: MochaDone) => void): void;
+
+declare function suiteSetup(action: () => void): void;
+
+declare function suiteSetup(action: (done: MochaDone) => void): void;
+
+declare function afterEach(action: () => void): void;
+
+declare function afterEach(action: (done: MochaDone) => void): void;
+
+declare function suiteTeardown(action: () => void): void;
+
+declare function suiteTeardown(action: (done: MochaDone) => void): void;
+
+declare class Mocha {
+    constructor(options?: {
+        grep?: RegExp;
+        ui?: string;
+        reporter?: string;
+        timeout?: number;
+        bail?: boolean;
+    });
+
+    /** Setup mocha with the given options. */
+    setup(options: MochaSetupOptions): Mocha;
+    bail(value?: boolean): Mocha;
+    addFile(file: string): Mocha;
+    /** Sets reporter by name, defaults to "spec". */
+    reporter(name: string): Mocha;
+    /** Sets reporter constructor, defaults to mocha.reporters.Spec. */
+    reporter(reporter: (runner: Mocha.IRunner, options: any) => any): Mocha;
+    ui(value: string): Mocha;
+    grep(value: string): Mocha;
+    grep(value: RegExp): Mocha;
+    invert(): Mocha;
+    ignoreLeaks(value: boolean): Mocha;
+    checkLeaks(): Mocha;
+    /**
+     * Function to allow assertion libraries to throw errors directly into mocha.
+     * This is useful when running tests in a browser because window.onerror will
+     * only receive the 'message' attribute of the Error.
+     */
+    throwError(error: Error): void;
+    /** Enables growl support. */
+    growl(): Mocha;
+    globals(value: string): Mocha;
+    globals(values: string[]): Mocha;
+    useColors(value: boolean): Mocha;
+    useInlineDiffs(value: boolean): Mocha;
+    timeout(value: number): Mocha;
+    slow(value: number): Mocha;
+    enableTimeouts(value: boolean): Mocha;
+    asyncOnly(value: boolean): Mocha;
+    noHighlighting(value: boolean): Mocha;
+    /** Runs tests and invokes `onComplete()` when finished. */
+    run(onComplete?: (failures: number) => void): Mocha.IRunner;
+}
+
+// merge the Mocha class declaration with a module
+declare module Mocha {
+    /** Partial interface for Mocha's `Runnable` class. */
+    interface IRunnable {
+        title: string;
+        fn: Function;
+        async: boolean;
+        sync: boolean;
+        timedOut: boolean;
+    }
+
+    /** Partial interface for Mocha's `Suite` class. */
+    interface ISuite {
+        parent: ISuite;
+        title: string;
+
+        fullTitle(): string;
+    }
+
+    /** Partial interface for Mocha's `Test` class. */
+    interface ITest extends IRunnable {
+        parent: ISuite;
+        pending: boolean;
+
+        fullTitle(): string;
+    }
+
+    /** Partial interface for Mocha's `Runner` class. */
+    interface IRunner {}
+
+    interface IContextDefinition {
+        (description: string, spec: () => void): ISuite;
+        only(description: string, spec: () => void): ISuite;
+        skip(description: string, spec: () => void): void;
+        timeout(ms: number): void;
+    }
+
+    interface ITestDefinition {
+        (expectation: string, assertion?: () => void): ITest;
+        (expectation: string, assertion?: (done: MochaDone) => void): ITest;
+        only(expectation: string, assertion?: () => void): ITest;
+        only(expectation: string, assertion?: (done: MochaDone) => void): ITest;
+        skip(expectation: string, assertion?: () => void): void;
+        skip(expectation: string, assertion?: (done: MochaDone) => void): void;
+        timeout(ms: number): void;
+    }
+
+    export module reporters {
+        export class Base {
+            stats: {
+                suites: number;
+                tests: number;
+                passes: number;
+                pending: number;
+                failures: number;
+            };
+
+            constructor(runner: IRunner);
+        }
+
+        export class Doc extends Base {}
+        export class Dot extends Base {}
+        export class HTML extends Base {}
+        export class HTMLCov extends Base {}
+        export class JSON extends Base {}
+        export class JSONCov extends Base {}
+        export class JSONStream extends Base {}
+        export class Landing extends Base {}
+        export class List extends Base {}
+        export class Markdown extends Base {}
+        export class Min extends Base {}
+        export class Nyan extends Base {}
+        export class Progress extends Base {
+            /**
+             * @param options.open String used to indicate the start of the progress bar.
+             * @param options.complete String used to indicate a complete test on the progress bar.
+             * @param options.incomplete String used to indicate an incomplete test on the progress bar.
+             * @param options.close String used to indicate the end of the progress bar.
+             */
+            constructor(runner: IRunner, options?: {
+                open?: string;
+                complete?: string;
+                incomplete?: string;
+                close?: string;
+            });
+        }
+        export class Spec extends Base {}
+        export class TAP extends Base {}
+        export class XUnit extends Base {
+            constructor(runner: IRunner, options?: any);
+        }
+    }
+}
+
+declare module "mocha" {
+    export = Mocha;
+}

From 9f8d4fadd10ffa6ecadb6589d78f968c506e09e3 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Tue, 10 Nov 2015 18:43:01 +0000
Subject: [PATCH 02/10] Cleanup

---
 lib/index.d.ts | 170 ++++++++++++++++++++++++++++++++++++++++++
 lib/index.js   | 197 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/index.ts   |   6 +-
 3 files changed, 371 insertions(+), 2 deletions(-)
 create mode 100644 lib/index.d.ts
 create mode 100644 lib/index.js

diff --git a/lib/index.d.ts b/lib/index.d.ts
new file mode 100644
index 0000000..cc179d6
--- /dev/null
+++ b/lib/index.d.ts
@@ -0,0 +1,170 @@
+import { IDisposable } from 'phosphor-disposable';
+import { Message } from 'phosphor-messaging';
+import { Signal, ISignal } from 'phosphor-signaling';
+import { Widget, ResizeMessage } from 'phosphor-widget';
+/**
+ * The interface required for an editor model.
+ */
+export interface IEditorModel {
+    /**
+     * Saves the current data in the existing file.
+     *
+     * @param data - A string containing the entire data to be saved.
+     */
+    save(data: string): void;
+    /**
+     * Renames the current file.
+     *
+     * @param name - A string denoting the new filename.
+     *
+     * #### Notes
+     * This does *not* remove the existing file, it simply saves a
+     * new file with the same data.
+     */
+    rename(name: string): void;
+}
+/**
+ * An implementation of IEditorModel.
+ */
+export declare class EditorModel implements IEditorModel {
+    save(data: string): void;
+    rename(name: string): void;
+    private _filename;
+    private _mode;
+    private _lineNumbers;
+    private _tabSize;
+}
+/**
+ * An interface required for implementing the view-model
+ * for an editor.
+ */
+export interface IEditorViewModel {
+    /**
+     * Save the current text buffer to the file.
+     */
+    save(data: string): void;
+    /**
+     * Rename this file.
+     */
+    rename(name: string): void;
+    /**
+     * The mode of the editor, eg. for code this would be
+     * the language, like 'python' or 'javascript'.
+     */
+    mode(): string;
+    /**
+     * Sets the view class on on the view model.
+     */
+    setView(view: IEditorWidget): void;
+    /**
+     * A flag to determine whether to show line numbers.
+     */
+    showLineNumbers: boolean;
+    /**
+     * A flag to determine whether to allow editing.
+     */
+    readOnly: boolean;
+    /**
+     * The number of spaces to insert for each tab.
+     */
+    tabSize: number;
+}
+export declare class EditorViewModel implements IDisposable, IEditorViewModel {
+    /**
+     * Construct an editor view model.
+     */
+    constructor(model: IEditorModel);
+    /**
+     * Set the view object for this view model.
+     */
+    setView(view: IEditorWidget): void;
+    /**
+     * Save the current buffer in the existing file.
+     */
+    save(): void;
+    /**
+     * Rename the current file.
+     */
+    rename(name: string): void;
+    /**
+     * The mode of the current editor.
+     */
+    mode(): string;
+    /**
+     * Dispose of this object.
+     */
+    dispose(): void;
+    /**
+     * Get the disposed status of this object.
+     */
+    isDisposed: boolean;
+    private _updateBuffer();
+    private _startBufferTimer();
+    showLineNumbers: boolean;
+    readOnly: boolean;
+    tabSize: number;
+    private _mode;
+    private _disposed;
+    private _view;
+    private _model;
+    private _buffer;
+    /**
+     * The delay in milliseconds between view buffer-fetches.
+     */
+    private _bufferDelay;
+    /**
+     * The id returned by setTimeout.
+     */
+    private _bufferTimeoutId;
+}
+/**
+ * The interface to fulfil in order to implement
+ * an EditorWidget.
+ */
+export interface IEditorWidget {
+    /**
+     * Get the entire contents of the current editor.
+     */
+    getContents(): string;
+}
+/**
+ * A widget used for entering text/code.
+ *
+ * #### Notes
+ * This class happens to use Codemirror as the hosted widget for
+ * text entry, but Codemirror is entirely encapsulated
+ * within this class. As long as the IEditorWidget interface is
+ * adhered to, any other text editor widget can be easily
+ * swapped in.
+ */
+export declare class EditorWidget extends Widget implements IEditorWidget {
+    /**
+     * A signal which is emitted when the view contents change.
+     *
+     * #### Notes
+     * This is designed for the view-model. The data is *not* passed
+     * as the signal argument in order that the view-model can decide
+     * when to pull the potentially large data string from the view.
+     */
+    static contentsChangedSignal: Signal<IEditorWidget, boolean>;
+    /**
+     * A delegate for [[contentsChangedSignal]].
+     */
+    static getContentsChanged(item: IEditorWidget): ISignal<IEditorWidget, boolean>;
+    /**
+     * Construct an EditorWidget.
+     */
+    constructor(vm: IEditorViewModel);
+    /**
+     * Get the contents of the current view as a string.
+     */
+    getContents(): string;
+    /**
+     * Set the font size in the editor.
+     */
+    fontSize: string;
+    protected onAfterAttach(msg: Message): void;
+    protected onResize(msg: ResizeMessage): void;
+    private _viewmodel;
+    private _editor;
+}
diff --git a/lib/index.js b/lib/index.js
new file mode 100644
index 0000000..31b1342
--- /dev/null
+++ b/lib/index.js
@@ -0,0 +1,197 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) 2014-2015, PhosphorJS Contributors
+|
+| Distributed under the terms of the BSD 3-Clause License.
+|
+| The full license is in the file LICENSE, distributed with this software.
+|----------------------------------------------------------------------------*/
+'use strict';
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var phosphor_signaling_1 = require('phosphor-signaling');
+var phosphor_widget_1 = require('phosphor-widget');
+/**
+ * An implementation of IEditorModel.
+ */
+var EditorModel = (function () {
+    function EditorModel() {
+        this._lineNumbers = true;
+        this._tabSize = 2;
+    }
+    EditorModel.prototype.save = function (data) {
+        console.log('MODEL SAVE');
+    };
+    EditorModel.prototype.rename = function (name) {
+        console.log("MODEL RENAME");
+    };
+    return EditorModel;
+})();
+exports.EditorModel = EditorModel;
+var EditorViewModel = (function () {
+    /**
+     * Construct an editor view model.
+     */
+    function EditorViewModel(model) {
+        this.showLineNumbers = true;
+        this.readOnly = true;
+        this.tabSize = 2; // TODO
+        this._mode = '';
+        this._disposed = false;
+        this._view = null;
+        this._buffer = '';
+        /**
+         * The delay in milliseconds between view buffer-fetches.
+         */
+        this._bufferDelay = 1000;
+        /**
+         * The id returned by setTimeout.
+         */
+        this._bufferTimeoutId = 0;
+        this._model = model;
+    }
+    /**
+     * Set the view object for this view model.
+     */
+    EditorViewModel.prototype.setView = function (view) {
+        this._view = view;
+        EditorWidget
+            .getContentsChanged(this._view)
+            .connect(this._startBufferTimer, this);
+    };
+    /**
+     * Save the current buffer in the existing file.
+     */
+    EditorViewModel.prototype.save = function () {
+        this._updateBuffer();
+        this._model.save(this._buffer);
+    };
+    /**
+     * Rename the current file.
+     */
+    EditorViewModel.prototype.rename = function (name) {
+        this._model.rename(name);
+    };
+    /**
+     * The mode of the current editor.
+     */
+    EditorViewModel.prototype.mode = function () {
+        return this._mode;
+    };
+    /**
+     * Dispose of this object.
+     */
+    EditorViewModel.prototype.dispose = function () {
+        this._disposed = true;
+        phosphor_signaling_1.clearSignalData(this);
+        this._model = null;
+        this._view = null;
+    };
+    Object.defineProperty(EditorViewModel.prototype, "isDisposed", {
+        /**
+         * Get the disposed status of this object.
+         */
+        get: function () {
+            return this._disposed;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    EditorViewModel.prototype._updateBuffer = function () {
+        if (!this.isDisposed) {
+            var data = this._view.getContents();
+            this._buffer = data;
+        }
+    };
+    EditorViewModel.prototype._startBufferTimer = function () {
+        var _this = this;
+        clearTimeout(this._bufferTimeoutId);
+        //console.log("setting timeout...");
+        this._bufferTimeoutId = setTimeout(function () {
+            //console.log("TIMED OUT");
+            _this._updateBuffer();
+        }, this._bufferDelay);
+    };
+    return EditorViewModel;
+})();
+exports.EditorViewModel = EditorViewModel;
+/**
+ * A widget used for entering text/code.
+ *
+ * #### Notes
+ * This class happens to use Codemirror as the hosted widget for
+ * text entry, but Codemirror is entirely encapsulated
+ * within this class. As long as the IEditorWidget interface is
+ * adhered to, any other text editor widget can be easily
+ * swapped in.
+ */
+var EditorWidget = (function (_super) {
+    __extends(EditorWidget, _super);
+    /**
+     * Construct an EditorWidget.
+     */
+    function EditorWidget(vm) {
+        var _this = this;
+        _super.call(this);
+        this.addClass('EditorWidget');
+        var config = {
+            mode: vm.mode(),
+            lineNumbers: vm.showLineNumbers,
+            tabSize: vm.tabSize
+        };
+        this._editor = CodeMirror(this.node, config);
+        this._editor.on("change", function () {
+            EditorWidget.getContentsChanged(_this).emit(true);
+        });
+        this._viewmodel = vm;
+        this._viewmodel.setView(this);
+    }
+    /**
+     * A delegate for [[contentsChangedSignal]].
+     */
+    EditorWidget.getContentsChanged = function (item) {
+        return EditorWidget.contentsChangedSignal.bind(item);
+    };
+    /**
+     * Get the contents of the current view as a string.
+     */
+    EditorWidget.prototype.getContents = function () {
+        var doc = this._editor.getDoc();
+        return doc.getValue();
+    };
+    Object.defineProperty(EditorWidget.prototype, "fontSize", {
+        /**
+         * Set the font size in the editor.
+         */
+        set: function (size) {
+            (this._editor.getWrapperElement()).style["font-size"] = size;
+            this._editor.refresh();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    EditorWidget.prototype.onAfterAttach = function (msg) {
+        this._editor.refresh();
+    };
+    EditorWidget.prototype.onResize = function (msg) {
+        if (msg.width < 0 || msg.height < 0) {
+            this._editor.refresh();
+        }
+        else {
+            this._editor.setSize(msg.width, msg.height);
+        }
+    };
+    /**
+     * A signal which is emitted when the view contents change.
+     *
+     * #### Notes
+     * This is designed for the view-model. The data is *not* passed
+     * as the signal argument in order that the view-model can decide
+     * when to pull the potentially large data string from the view.
+     */
+    EditorWidget.contentsChangedSignal = new phosphor_signaling_1.Signal();
+    return EditorWidget;
+})(phosphor_widget_1.Widget);
+exports.EditorWidget = EditorWidget;
diff --git a/src/index.ts b/src/index.ts
index 6ab08f7..db8e71a 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -55,11 +55,13 @@ export
 class EditorModel implements IEditorModel {
 
   save(data: string) {
-    console.log('MODEL SAVE');
+    // to be delegated to jupyter-js-services.
+    console.log('model save');
   }
 
   rename(name: string) {
-    console.log("MODEL RENAME");
+    // to be delegated to jupyter-js-services.
+    console.log('model rename');
   }
 
   private _filename: string;

From d08596b690f4330d02e6597b3479019bb1b39208 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Tue, 10 Nov 2015 18:58:47 +0000
Subject: [PATCH 03/10] Cleanup

---
 example/bundle.js | 15 +++++++++------
 lib/index.d.ts    |  7 +++++--
 lib/index.js      | 15 +++++++++------
 src/index.ts      | 15 ++++++++-------
 4 files changed, 31 insertions(+), 21 deletions(-)

diff --git a/example/bundle.js b/example/bundle.js
index d2573f0..dbd56c6 100644
--- a/example/bundle.js
+++ b/example/bundle.js
@@ -43,11 +43,16 @@ var EditorModel = (function () {
         this._lineNumbers = true;
         this._tabSize = 2;
     }
+    /**
+     * Save the data to file.
+     */
     EditorModel.prototype.save = function (data) {
-        console.log('MODEL SAVE');
+        // to be delegated to jupyter-js-services.
+        console.log('model save');
     };
     EditorModel.prototype.rename = function (name) {
-        console.log("MODEL RENAME");
+        // to be delegated to jupyter-js-services.
+        console.log('model rename');
     };
     return EditorModel;
 })();
@@ -59,7 +64,7 @@ var EditorViewModel = (function () {
     function EditorViewModel(model) {
         this.showLineNumbers = true;
         this.readOnly = true;
-        this.tabSize = 2; // TODO
+        this.tabSize = 2;
         this._mode = '';
         this._disposed = false;
         this._view = null;
@@ -130,9 +135,7 @@ var EditorViewModel = (function () {
     EditorViewModel.prototype._startBufferTimer = function () {
         var _this = this;
         clearTimeout(this._bufferTimeoutId);
-        //console.log("setting timeout...");
         this._bufferTimeoutId = setTimeout(function () {
-            //console.log("TIMED OUT");
             _this._updateBuffer();
         }, this._bufferDelay);
     };
@@ -171,7 +174,7 @@ var EditorWidget = (function (_super) {
         this._viewmodel.setView(this);
     }
     /**
-     * A delegate for [[contentsChangedSignal]].
+     * A pure delegate for [[contentsChangedSignal]].
      */
     EditorWidget.getContentsChanged = function (item) {
         return EditorWidget.contentsChangedSignal.bind(item);
diff --git a/lib/index.d.ts b/lib/index.d.ts
index cc179d6..63845ba 100644
--- a/lib/index.d.ts
+++ b/lib/index.d.ts
@@ -9,7 +9,7 @@ export interface IEditorModel {
     /**
      * Saves the current data in the existing file.
      *
-     * @param data - A string containing the entire data to be saved.
+     * @param data - A string containing the complete data to be saved.
      */
     save(data: string): void;
     /**
@@ -27,6 +27,9 @@ export interface IEditorModel {
  * An implementation of IEditorModel.
  */
 export declare class EditorModel implements IEditorModel {
+    /**
+     * Save the data to file.
+     */
     save(data: string): void;
     rename(name: string): void;
     private _filename;
@@ -148,7 +151,7 @@ export declare class EditorWidget extends Widget implements IEditorWidget {
      */
     static contentsChangedSignal: Signal<IEditorWidget, boolean>;
     /**
-     * A delegate for [[contentsChangedSignal]].
+     * A pure delegate for [[contentsChangedSignal]].
      */
     static getContentsChanged(item: IEditorWidget): ISignal<IEditorWidget, boolean>;
     /**
diff --git a/lib/index.js b/lib/index.js
index 31b1342..5836b4a 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -21,11 +21,16 @@ var EditorModel = (function () {
         this._lineNumbers = true;
         this._tabSize = 2;
     }
+    /**
+     * Save the data to file.
+     */
     EditorModel.prototype.save = function (data) {
-        console.log('MODEL SAVE');
+        // to be delegated to jupyter-js-services.
+        console.log('model save');
     };
     EditorModel.prototype.rename = function (name) {
-        console.log("MODEL RENAME");
+        // to be delegated to jupyter-js-services.
+        console.log('model rename');
     };
     return EditorModel;
 })();
@@ -37,7 +42,7 @@ var EditorViewModel = (function () {
     function EditorViewModel(model) {
         this.showLineNumbers = true;
         this.readOnly = true;
-        this.tabSize = 2; // TODO
+        this.tabSize = 2;
         this._mode = '';
         this._disposed = false;
         this._view = null;
@@ -108,9 +113,7 @@ var EditorViewModel = (function () {
     EditorViewModel.prototype._startBufferTimer = function () {
         var _this = this;
         clearTimeout(this._bufferTimeoutId);
-        //console.log("setting timeout...");
         this._bufferTimeoutId = setTimeout(function () {
-            //console.log("TIMED OUT");
             _this._updateBuffer();
         }, this._bufferDelay);
     };
@@ -149,7 +152,7 @@ var EditorWidget = (function (_super) {
         this._viewmodel.setView(this);
     }
     /**
-     * A delegate for [[contentsChangedSignal]].
+     * A pure delegate for [[contentsChangedSignal]].
      */
     EditorWidget.getContentsChanged = function (item) {
         return EditorWidget.contentsChangedSignal.bind(item);
diff --git a/src/index.ts b/src/index.ts
index db8e71a..b3e608e 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -32,7 +32,7 @@ interface IEditorModel {
   /**
    * Saves the current data in the existing file.
    *
-   * @param data - A string containing the entire data to be saved.
+   * @param data - A string containing the complete data to be saved.
    */
   save(data: string): void;
   /**
@@ -54,12 +54,15 @@ interface IEditorModel {
 export
 class EditorModel implements IEditorModel {
 
-  save(data: string) {
+  /**
+   * Save the data to file.
+   */
+  save(data: string): void {
     // to be delegated to jupyter-js-services.
     console.log('model save');
   }
 
-  rename(name: string) {
+  rename(name: string): void {
     // to be delegated to jupyter-js-services.
     console.log('model rename');
   }
@@ -176,16 +179,14 @@ class EditorViewModel implements IDisposable, IEditorViewModel {
 
   private _startBufferTimer(): void {
     clearTimeout(this._bufferTimeoutId);
-    //console.log("setting timeout...");
     this._bufferTimeoutId = setTimeout(() => {
-      //console.log("TIMED OUT");
       this._updateBuffer();
     }, this._bufferDelay);
   }
 
   showLineNumbers = true;
   readOnly = true;
-  tabSize = 2; // TODO
+  tabSize = 2;
 
   private _mode = '';
   private _disposed = false;
@@ -238,7 +239,7 @@ class EditorWidget extends Widget implements IEditorWidget {
   static contentsChangedSignal = new Signal<IEditorWidget, boolean>();
 
   /**
-   * A delegate for [[contentsChangedSignal]].
+   * A pure delegate for [[contentsChangedSignal]].
    */
   static getContentsChanged(item: IEditorWidget): ISignal<IEditorWidget, boolean> {
     return EditorWidget.contentsChangedSignal.bind(item);

From 57a79a7801bae6f1c3fad51c92ccc9eddc4ba1f5 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Wed, 11 Nov 2015 16:09:02 +0000
Subject: [PATCH 04/10] Cleanup

---
 .gitignore        |  1 -
 example/bundle.js | 12 ++++++++++++
 lib/index.d.ts    | 16 ++++++++++++++--
 lib/index.js      | 12 ++++++++++++
 src/index.ts      | 22 ++++++++++++++++++----
 5 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/.gitignore b/.gitignore
index 765c327..6dcab80 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,3 @@
 node_modules
 npm-debug.log
 test/build
-lib
diff --git a/example/bundle.js b/example/bundle.js
index dbd56c6..e85ed12 100644
--- a/example/bundle.js
+++ b/example/bundle.js
@@ -50,6 +50,9 @@ var EditorModel = (function () {
         // to be delegated to jupyter-js-services.
         console.log('model save');
     };
+    /**
+     * Rename the current file.
+     */
     EditorModel.prototype.rename = function (name) {
         // to be delegated to jupyter-js-services.
         console.log('model rename');
@@ -62,8 +65,17 @@ var EditorViewModel = (function () {
      * Construct an editor view model.
      */
     function EditorViewModel(model) {
+        /**
+         * Flag that determines whether to show line numbers.
+         */
         this.showLineNumbers = true;
+        /**
+         * Flag that determines whether the view is read-only.
+         */
         this.readOnly = true;
+        /**
+         * Number of spaces to use for a tab.
+         */
         this.tabSize = 2;
         this._mode = '';
         this._disposed = false;
diff --git a/lib/index.d.ts b/lib/index.d.ts
index 63845ba..f83f0a0 100644
--- a/lib/index.d.ts
+++ b/lib/index.d.ts
@@ -31,6 +31,9 @@ export declare class EditorModel implements IEditorModel {
      * Save the data to file.
      */
     save(data: string): void;
+    /**
+     * Rename the current file.
+     */
     rename(name: string): void;
     private _filename;
     private _mode;
@@ -101,11 +104,20 @@ export declare class EditorViewModel implements IDisposable, IEditorViewModel {
      * Get the disposed status of this object.
      */
     isDisposed: boolean;
-    private _updateBuffer();
-    private _startBufferTimer();
+    /**
+     * Flag that determines whether to show line numbers.
+     */
     showLineNumbers: boolean;
+    /**
+     * Flag that determines whether the view is read-only.
+     */
     readOnly: boolean;
+    /**
+     * Number of spaces to use for a tab.
+     */
     tabSize: number;
+    private _updateBuffer();
+    private _startBufferTimer();
     private _mode;
     private _disposed;
     private _view;
diff --git a/lib/index.js b/lib/index.js
index 5836b4a..3461eef 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -28,6 +28,9 @@ var EditorModel = (function () {
         // to be delegated to jupyter-js-services.
         console.log('model save');
     };
+    /**
+     * Rename the current file.
+     */
     EditorModel.prototype.rename = function (name) {
         // to be delegated to jupyter-js-services.
         console.log('model rename');
@@ -40,8 +43,17 @@ var EditorViewModel = (function () {
      * Construct an editor view model.
      */
     function EditorViewModel(model) {
+        /**
+         * Flag that determines whether to show line numbers.
+         */
         this.showLineNumbers = true;
+        /**
+         * Flag that determines whether the view is read-only.
+         */
         this.readOnly = true;
+        /**
+         * Number of spaces to use for a tab.
+         */
         this.tabSize = 2;
         this._mode = '';
         this._disposed = false;
diff --git a/src/index.ts b/src/index.ts
index b3e608e..c5c360e 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -62,6 +62,9 @@ class EditorModel implements IEditorModel {
     console.log('model save');
   }
 
+  /**
+   * Rename the current file.
+   */
   rename(name: string): void {
     // to be delegated to jupyter-js-services.
     console.log('model rename');
@@ -170,6 +173,21 @@ class EditorViewModel implements IDisposable, IEditorViewModel {
     return this._disposed;
   }
 
+  /**
+   * Flag that determines whether to show line numbers.
+   */
+  showLineNumbers = true;
+
+  /**
+   * Flag that determines whether the view is read-only.
+   */
+  readOnly = true;
+
+  /**
+   * Number of spaces to use for a tab.
+   */
+  tabSize = 2;
+
   private _updateBuffer(): void {
     if (!this.isDisposed) {
       var data = this._view.getContents();
@@ -184,10 +202,6 @@ class EditorViewModel implements IDisposable, IEditorViewModel {
     }, this._bufferDelay);
   }
 
-  showLineNumbers = true;
-  readOnly = true;
-  tabSize = 2;
-
   private _mode = '';
   private _disposed = false;
   private _view: IEditorWidget = null;

From bb36a4c2b8b6a288247a8a5054fac628817c4d59 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Wed, 11 Nov 2015 16:12:01 +0000
Subject: [PATCH 05/10] Fix gitignore

---
 .gitignore                 |  2 ++
 example/build/index.d.ts   |  0
 example/build/index.js     | 20 --------------------
 example/build/index.js.map |  1 -
 4 files changed, 2 insertions(+), 21 deletions(-)
 delete mode 100644 example/build/index.d.ts
 delete mode 100644 example/build/index.js
 delete mode 100644 example/build/index.js.map

diff --git a/.gitignore b/.gitignore
index 6dcab80..5f65f07 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,5 @@
 node_modules
 npm-debug.log
 test/build
+example/build
+lib/
diff --git a/example/build/index.d.ts b/example/build/index.d.ts
deleted file mode 100644
index e69de29..0000000
diff --git a/example/build/index.js b/example/build/index.js
deleted file mode 100644
index 1e29c94..0000000
--- a/example/build/index.js
+++ /dev/null
@@ -1,20 +0,0 @@
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use-strict';
-var phosphor_widget_1 = require('phosphor-widget');
-var index_1 = require('../../lib/index');
-function main() {
-    var model = new index_1.EditorModel();
-    var viewmodel = new index_1.EditorViewModel(model);
-    var view = new index_1.EditorWidget(viewmodel);
-    phosphor_widget_1.Widget.attach(view, document.getElementById('main'));
-    view.update();
-    window.onresize = function () { return view.update(); };
-}
-window.onload = main;
-//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/example/build/index.js.map b/example/build/index.js.map
deleted file mode 100644
index af5a633..0000000
--- a/example/build/index.js.map
+++ /dev/null
@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":["main"],"mappings":"AAAA;;;;;;+EAM+E;AAC/E,YAAY,CAAC;AAEb,gCAEO,iBAAiB,CAAC,CAAA;AAEzB,sBAEO,iBAAiB,CAAC,CAAA;AAEzB;IACEA,IAAIA,KAAKA,GAAGA,IAAIA,mBAAWA,EAAEA,CAACA;IAC9BA,IAAIA,SAASA,GAAGA,IAAIA,uBAAeA,CAACA,KAAKA,CAACA,CAACA;IAC3CA,IAAIA,IAAIA,GAAGA,IAAIA,oBAAYA,CAACA,SAASA,CAACA,CAACA;IAEvCA,wBAAMA,CAACA,MAAMA,CAACA,IAAIA,EAAEA,QAAQA,CAACA,cAAcA,CAACA,MAAMA,CAACA,CAACA,CAACA;IACrDA,IAAIA,CAACA,MAAMA,EAAEA,CAACA;IAEdA,MAAMA,CAACA,QAAQA,GAAGA,cAAMA,OAAAA,IAAIA,CAACA,MAAMA,EAAEA,EAAbA,CAAaA,CAACA;AACxCA,CAACA;AAED,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC"}
\ No newline at end of file

From 725e701f01896bc912c3667885119158d0f813a2 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Thu, 12 Nov 2015 19:01:14 +0000
Subject: [PATCH 06/10] Remove separate view-model, move timer to widget

---
 example/index.css    |   2 +-
 example/src/index.ts |   6 +-
 lib/index.d.ts       | 128 +++++++++-----------------
 lib/index.js         | 141 +++++++++-------------------
 package.json         |   1 -
 src/index.ts         | 212 +++++++++++++++----------------------------
 6 files changed, 163 insertions(+), 327 deletions(-)

diff --git a/example/index.css b/example/index.css
index b7f98bc..3ef4ff2 100644
--- a/example/index.css
+++ b/example/index.css
@@ -2,7 +2,7 @@
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
-.EditorWidget {
+.Ph-EditorWidget {
   min-width: 50px;
   min-height: 50px;
   border: 1px solid #C0C0C0;
diff --git a/example/src/index.ts b/example/src/index.ts
index effedc6..cfb027c 100644
--- a/example/src/index.ts
+++ b/example/src/index.ts
@@ -12,13 +12,13 @@ import {
 } from 'phosphor-widget';
 
 import {
-  EditorWidget, EditorModel, EditorViewModel
+  EditorWidget, EditorModel
 } from '../../lib/index';
 
+
 function main(): void {
   var model = new EditorModel();
-  var viewmodel = new EditorViewModel(model);
-  var view = new EditorWidget(viewmodel);
+  var view = new EditorWidget(model);
 
   Widget.attach(view, document.getElementById('main'));
   view.update();
diff --git a/lib/index.d.ts b/lib/index.d.ts
index f83f0a0..54017bc 100644
--- a/lib/index.d.ts
+++ b/lib/index.d.ts
@@ -1,11 +1,16 @@
 import { IDisposable } from 'phosphor-disposable';
 import { Message } from 'phosphor-messaging';
-import { Signal, ISignal } from 'phosphor-signaling';
 import { Widget, ResizeMessage } from 'phosphor-widget';
 /**
- * The interface required for an editor model.
+ * An interface required for implementing the editor model
  */
 export interface IEditorModel {
+    /**
+     * Updates the buffer stored in the model.
+     *
+     * @param value - A string containing the complete data in the view.
+     */
+    updateBuffer(value: string): void;
     /**
      * Saves the current data in the existing file.
      *
@@ -22,46 +27,11 @@ export interface IEditorModel {
      * new file with the same data.
      */
     rename(name: string): void;
-}
-/**
- * An implementation of IEditorModel.
- */
-export declare class EditorModel implements IEditorModel {
-    /**
-     * Save the data to file.
-     */
-    save(data: string): void;
-    /**
-     * Rename the current file.
-     */
-    rename(name: string): void;
-    private _filename;
-    private _mode;
-    private _lineNumbers;
-    private _tabSize;
-}
-/**
- * An interface required for implementing the view-model
- * for an editor.
- */
-export interface IEditorViewModel {
-    /**
-     * Save the current text buffer to the file.
-     */
-    save(data: string): void;
-    /**
-     * Rename this file.
-     */
-    rename(name: string): void;
     /**
      * The mode of the editor, eg. for code this would be
      * the language, like 'python' or 'javascript'.
      */
     mode(): string;
-    /**
-     * Sets the view class on on the view model.
-     */
-    setView(view: IEditorWidget): void;
     /**
      * A flag to determine whether to show line numbers.
      */
@@ -75,15 +45,41 @@ export interface IEditorViewModel {
      */
     tabSize: number;
 }
-export declare class EditorViewModel implements IDisposable, IEditorViewModel {
+/**
+ * Interface that must be implemented to set defaults on an EditorModel.
+ */
+export interface IEditorConfigOptions {
     /**
-     * Construct an editor view model.
+     * The mode of the view, ie. 'python', 'text' or 'javascript'.
      */
-    constructor(model: IEditorModel);
+    mode?: string;
+    /**
+     * A flag to determine whether to show line numbers.
+     */
+    showLineNumbers?: boolean;
     /**
-     * Set the view object for this view model.
+     * A flag to determine whether the view is read-only.
      */
-    setView(view: IEditorWidget): void;
+    readOnly?: boolean;
+    /**
+     * The number of spaces to use for a tab.
+     */
+    tabSize?: number;
+}
+/**
+ * The data model behind the editor view.
+ */
+export declare class EditorModel implements IDisposable, IEditorModel {
+    /**
+     * Construct an Editor Model.
+     */
+    constructor(config?: IEditorConfigOptions);
+    /**
+     * Updates the buffer stored in the model.
+     *
+     * @param value - A string containing the complete data in the view.
+     */
+    updateBuffer(value: string): void;
     /**
      * Save the current buffer in the existing file.
      */
@@ -116,31 +112,9 @@ export declare class EditorViewModel implements IDisposable, IEditorViewModel {
      * Number of spaces to use for a tab.
      */
     tabSize: number;
-    private _updateBuffer();
-    private _startBufferTimer();
     private _mode;
     private _disposed;
-    private _view;
-    private _model;
     private _buffer;
-    /**
-     * The delay in milliseconds between view buffer-fetches.
-     */
-    private _bufferDelay;
-    /**
-     * The id returned by setTimeout.
-     */
-    private _bufferTimeoutId;
-}
-/**
- * The interface to fulfil in order to implement
- * an EditorWidget.
- */
-export interface IEditorWidget {
-    /**
-     * Get the entire contents of the current editor.
-     */
-    getContents(): string;
 }
 /**
  * A widget used for entering text/code.
@@ -152,34 +126,20 @@ export interface IEditorWidget {
  * adhered to, any other text editor widget can be easily
  * swapped in.
  */
-export declare class EditorWidget extends Widget implements IEditorWidget {
-    /**
-     * A signal which is emitted when the view contents change.
-     *
-     * #### Notes
-     * This is designed for the view-model. The data is *not* passed
-     * as the signal argument in order that the view-model can decide
-     * when to pull the potentially large data string from the view.
-     */
-    static contentsChangedSignal: Signal<IEditorWidget, boolean>;
-    /**
-     * A pure delegate for [[contentsChangedSignal]].
-     */
-    static getContentsChanged(item: IEditorWidget): ISignal<IEditorWidget, boolean>;
+export declare class EditorWidget extends Widget {
     /**
      * Construct an EditorWidget.
      */
-    constructor(vm: IEditorViewModel);
-    /**
-     * Get the contents of the current view as a string.
-     */
-    getContents(): string;
+    constructor(model: IEditorModel);
     /**
      * Set the font size in the editor.
      */
     fontSize: string;
     protected onAfterAttach(msg: Message): void;
     protected onResize(msg: ResizeMessage): void;
-    private _viewmodel;
+    private _startBufferTimer();
+    private _model;
     private _editor;
+    private _bufferTimeoutId;
+    private _bufferDelay;
 }
diff --git a/lib/index.js b/lib/index.js
index 3461eef..65ea22f 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -11,38 +11,15 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var phosphor_signaling_1 = require('phosphor-signaling');
 var phosphor_widget_1 = require('phosphor-widget');
 /**
- * An implementation of IEditorModel.
+ * The data model behind the editor view.
  */
 var EditorModel = (function () {
-    function EditorModel() {
-        this._lineNumbers = true;
-        this._tabSize = 2;
-    }
-    /**
-     * Save the data to file.
-     */
-    EditorModel.prototype.save = function (data) {
-        // to be delegated to jupyter-js-services.
-        console.log('model save');
-    };
-    /**
-     * Rename the current file.
-     */
-    EditorModel.prototype.rename = function (name) {
-        // to be delegated to jupyter-js-services.
-        console.log('model rename');
-    };
-    return EditorModel;
-})();
-exports.EditorModel = EditorModel;
-var EditorViewModel = (function () {
     /**
-     * Construct an editor view model.
+     * Construct an Editor Model.
      */
-    function EditorViewModel(model) {
+    function EditorModel(config) {
         /**
          * Flag that determines whether to show line numbers.
          */
@@ -57,56 +34,50 @@ var EditorViewModel = (function () {
         this.tabSize = 2;
         this._mode = '';
         this._disposed = false;
-        this._view = null;
         this._buffer = '';
-        /**
-         * The delay in milliseconds between view buffer-fetches.
-         */
-        this._bufferDelay = 1000;
-        /**
-         * The id returned by setTimeout.
-         */
-        this._bufferTimeoutId = 0;
-        this._model = model;
+        var cfg = config || {};
+        this._mode = config.mode || 'python';
+        this.showLineNumbers = config.showLineNumbers || true;
+        this.readOnly = config.readOnly || false;
+        this.tabSize = config.tabSize || 4;
     }
     /**
-     * Set the view object for this view model.
+     * Updates the buffer stored in the model.
+     *
+     * @param value - A string containing the complete data in the view.
      */
-    EditorViewModel.prototype.setView = function (view) {
-        this._view = view;
-        EditorWidget
-            .getContentsChanged(this._view)
-            .connect(this._startBufferTimer, this);
+    EditorModel.prototype.updateBuffer = function (value) {
+        if (!this.isDisposed) {
+            this._buffer = value;
+        }
     };
     /**
      * Save the current buffer in the existing file.
      */
-    EditorViewModel.prototype.save = function () {
-        this._updateBuffer();
-        this._model.save(this._buffer);
+    EditorModel.prototype.save = function () {
+        // delegate to jupyter-js-services
+        console.log('model save');
     };
     /**
      * Rename the current file.
      */
-    EditorViewModel.prototype.rename = function (name) {
-        this._model.rename(name);
+    EditorModel.prototype.rename = function (name) {
+        // delegate to jupyter-js-services
+        console.log('model rename');
     };
     /**
      * The mode of the current editor.
      */
-    EditorViewModel.prototype.mode = function () {
+    EditorModel.prototype.mode = function () {
         return this._mode;
     };
     /**
      * Dispose of this object.
      */
-    EditorViewModel.prototype.dispose = function () {
+    EditorModel.prototype.dispose = function () {
         this._disposed = true;
-        phosphor_signaling_1.clearSignalData(this);
-        this._model = null;
-        this._view = null;
     };
-    Object.defineProperty(EditorViewModel.prototype, "isDisposed", {
+    Object.defineProperty(EditorModel.prototype, "isDisposed", {
         /**
          * Get the disposed status of this object.
          */
@@ -116,22 +87,9 @@ var EditorViewModel = (function () {
         enumerable: true,
         configurable: true
     });
-    EditorViewModel.prototype._updateBuffer = function () {
-        if (!this.isDisposed) {
-            var data = this._view.getContents();
-            this._buffer = data;
-        }
-    };
-    EditorViewModel.prototype._startBufferTimer = function () {
-        var _this = this;
-        clearTimeout(this._bufferTimeoutId);
-        this._bufferTimeoutId = setTimeout(function () {
-            _this._updateBuffer();
-        }, this._bufferDelay);
-    };
-    return EditorViewModel;
+    return EditorModel;
 })();
-exports.EditorViewModel = EditorViewModel;
+exports.EditorModel = EditorModel;
 /**
  * A widget used for entering text/code.
  *
@@ -147,35 +105,23 @@ var EditorWidget = (function (_super) {
     /**
      * Construct an EditorWidget.
      */
-    function EditorWidget(vm) {
+    function EditorWidget(model) {
         var _this = this;
         _super.call(this);
-        this.addClass('EditorWidget');
+        this._bufferTimeoutId = 0;
+        this._bufferDelay = 1000;
+        this.addClass('Ph-EditorWidget');
         var config = {
-            mode: vm.mode(),
-            lineNumbers: vm.showLineNumbers,
-            tabSize: vm.tabSize
+            mode: model.mode(),
+            lineNumbers: model.showLineNumbers,
+            tabSize: model.tabSize
         };
         this._editor = CodeMirror(this.node, config);
         this._editor.on("change", function () {
-            EditorWidget.getContentsChanged(_this).emit(true);
+            _this._startBufferTimer();
         });
-        this._viewmodel = vm;
-        this._viewmodel.setView(this);
+        this._model = model;
     }
-    /**
-     * A pure delegate for [[contentsChangedSignal]].
-     */
-    EditorWidget.getContentsChanged = function (item) {
-        return EditorWidget.contentsChangedSignal.bind(item);
-    };
-    /**
-     * Get the contents of the current view as a string.
-     */
-    EditorWidget.prototype.getContents = function () {
-        var doc = this._editor.getDoc();
-        return doc.getValue();
-    };
     Object.defineProperty(EditorWidget.prototype, "fontSize", {
         /**
          * Set the font size in the editor.
@@ -198,15 +144,14 @@ var EditorWidget = (function (_super) {
             this._editor.setSize(msg.width, msg.height);
         }
     };
-    /**
-     * A signal which is emitted when the view contents change.
-     *
-     * #### Notes
-     * This is designed for the view-model. The data is *not* passed
-     * as the signal argument in order that the view-model can decide
-     * when to pull the potentially large data string from the view.
-     */
-    EditorWidget.contentsChangedSignal = new phosphor_signaling_1.Signal();
+    EditorWidget.prototype._startBufferTimer = function () {
+        var _this = this;
+        clearTimeout(this._bufferTimeoutId);
+        this._bufferTimeoutId = setTimeout(function () {
+            var text = _this._editor.getDoc().getValue();
+            _this._model.updateBuffer(text);
+        }, this._bufferDelay);
+    };
     return EditorWidget;
 })(phosphor_widget_1.Widget);
 exports.EditorWidget = EditorWidget;
diff --git a/package.json b/package.json
index 24bb3b4..9499c0b 100644
--- a/package.json
+++ b/package.json
@@ -7,7 +7,6 @@
   "dependencies": {
     "phosphor-disposable": "^1.0.4",
     "phosphor-messaging": "^1.0.5",
-    "phosphor-signaling": "^1.1.2",
     "phosphor-widget": "^0.9.13"
   },
   "devDependencies": {
diff --git a/src/index.ts b/src/index.ts
index c5c360e..98d279b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -15,20 +15,22 @@ import {
   Message
 } from 'phosphor-messaging';
 
-import {
-  Signal, ISignal, clearSignalData
-} from 'phosphor-signaling';
-
 import {
   Widget, ResizeMessage
 } from 'phosphor-widget';
 
 
 /**
- * The interface required for an editor model.
+ * An interface required for implementing the editor model
  */
 export
 interface IEditorModel {
+  /**
+   * Updates the buffer stored in the model.
+   *
+   * @param value - A string containing the complete data in the view.
+   */
+  updateBuffer(value: string): void;
   /**
    * Saves the current data in the existing file.
    *
@@ -45,108 +47,92 @@ interface IEditorModel {
    * new file with the same data.
    */
   rename(name: string): void;
-}
-
-
-/**
- * An implementation of IEditorModel.
- */
-export
-class EditorModel implements IEditorModel {
-
   /**
-   * Save the data to file.
+   * The mode of the editor, eg. for code this would be
+   * the language, like 'python' or 'javascript'.
    */
-  save(data: string): void {
-    // to be delegated to jupyter-js-services.
-    console.log('model save');
-  }
-
+  mode(): string;
   /**
-   * Rename the current file.
+   * A flag to determine whether to show line numbers.
    */
-  rename(name: string): void {
-    // to be delegated to jupyter-js-services.
-    console.log('model rename');
-  }
-
-  private _filename: string;
-  private _mode: string;
-  private _lineNumbers = true;
-  private _tabSize = 2;
+  showLineNumbers: boolean;
+  /**
+   * A flag to determine whether to allow editing.
+   */
+  readOnly: boolean;
+  /**
+   * The number of spaces to insert for each tab.
+   */
+  tabSize: number;
 }
 
 
 /**
- * An interface required for implementing the view-model
- * for an editor.
+ * Interface that must be implemented to set defaults on an EditorModel.
  */
 export
-interface IEditorViewModel {
-  /**
-   * Save the current text buffer to the file.
-   */
-  save(data: string): void;
+interface IEditorConfigOptions {
   /**
-   * Rename this file.
+   * The mode of the view, ie. 'python', 'text' or 'javascript'.
    */
-  rename(name: string): void;
-  /**
-   * The mode of the editor, eg. for code this would be
-   * the language, like 'python' or 'javascript'.
-   */
-  mode(): string;
-  /**
-   * Sets the view class on on the view model.
-   */
-  setView(view: IEditorWidget): void;
+  mode?: string;
   /**
    * A flag to determine whether to show line numbers.
    */
-  showLineNumbers: boolean;
+  showLineNumbers?: boolean;
   /**
-   * A flag to determine whether to allow editing.
+   * A flag to determine whether the view is read-only.
    */
-  readOnly: boolean;
+  readOnly?: boolean;
   /**
-   * The number of spaces to insert for each tab.
+   * The number of spaces to use for a tab.
    */
-  tabSize: number;
+  tabSize?: number;
 }
 
+
+/**
+ * The data model behind the editor view.
+ */
 export
-class EditorViewModel implements IDisposable, IEditorViewModel {
+class EditorModel implements IDisposable, IEditorModel {
 
   /**
-   * Construct an editor view model.
+   * Construct an Editor Model.
    */
-  constructor(model: IEditorModel) {
-    this._model = model;
+  constructor(config?: IEditorConfigOptions) {
+    var cfg = config || {};
+    this._mode = config.mode || 'python';
+    this.showLineNumbers = config.showLineNumbers || true;
+    this.readOnly = config.readOnly || false;
+    this.tabSize = config.tabSize || 4;
   }
 
   /**
-   * Set the view object for this view model.
+   * Updates the buffer stored in the model.
+   *
+   * @param value - A string containing the complete data in the view.
    */
-  setView(view: IEditorWidget): void {
-    this._view = view;
-    EditorWidget
-      .getContentsChanged(this._view)
-      .connect(this._startBufferTimer, this);
+  updateBuffer(value: string): void {
+    if (!this.isDisposed) {
+      this._buffer = value;
+    }
   }
 
   /**
    * Save the current buffer in the existing file.
    */
   save(): void {
-    this._updateBuffer();
-    this._model.save(this._buffer);
+    // delegate to jupyter-js-services
+    console.log('model save');
   }
 
   /**
    * Rename the current file.
    */
   rename(name: string): void {
-    this._model.rename(name);
+    // delegate to jupyter-js-services
+    console.log('model rename');
   }
 
   /**
@@ -161,9 +147,6 @@ class EditorViewModel implements IDisposable, IEditorViewModel {
    */
   dispose(): void {
     this._disposed = true;
-    clearSignalData(this);
-    this._model = null;
-    this._view = null;
   }
 
   /**
@@ -188,45 +171,9 @@ class EditorViewModel implements IDisposable, IEditorViewModel {
    */
   tabSize = 2;
 
-  private _updateBuffer(): void {
-    if (!this.isDisposed) {
-      var data = this._view.getContents();
-      this._buffer = data;
-    }
-  }
-
-  private _startBufferTimer(): void {
-    clearTimeout(this._bufferTimeoutId);
-    this._bufferTimeoutId = setTimeout(() => {
-      this._updateBuffer();
-    }, this._bufferDelay);
-  }
-
   private _mode = '';
   private _disposed = false;
-  private _view: IEditorWidget = null;
-  private _model: IEditorModel;
   private _buffer = '';
-  /**
-   * The delay in milliseconds between view buffer-fetches.
-   */
-  private _bufferDelay = 1000;
-  /**
-   * The id returned by setTimeout.
-   */
-  private _bufferTimeoutId = 0;
-}
-
-/**
- * The interface to fulfil in order to implement
- * an EditorWidget.
- */
-export
-interface IEditorWidget {
-  /**
-   * Get the entire contents of the current editor.
-   */
-  getContents(): string;
 }
 
 /**
@@ -240,52 +187,26 @@ interface IEditorWidget {
  * swapped in.
  */
 export
-class EditorWidget extends Widget implements IEditorWidget {
-
-  /**
-   * A signal which is emitted when the view contents change.
-   *
-   * #### Notes
-   * This is designed for the view-model. The data is *not* passed
-   * as the signal argument in order that the view-model can decide
-   * when to pull the potentially large data string from the view.
-   */
-  static contentsChangedSignal = new Signal<IEditorWidget, boolean>();
-
-  /**
-   * A pure delegate for [[contentsChangedSignal]].
-   */
-  static getContentsChanged(item: IEditorWidget): ISignal<IEditorWidget, boolean> {
-    return EditorWidget.contentsChangedSignal.bind(item);
-  }
+class EditorWidget extends Widget {
 
   /**
    * Construct an EditorWidget.
    */
-  constructor(vm: IEditorViewModel) {
+  constructor(model: IEditorModel) {
     super();
-    this.addClass('EditorWidget');
+    this.addClass('Ph-EditorWidget');
 
     var config = {
-      mode: vm.mode(),
-      lineNumbers: vm.showLineNumbers,
-      tabSize: vm.tabSize
+      mode: model.mode(),
+      lineNumbers: model.showLineNumbers,
+      tabSize: model.tabSize
     };
     this._editor = CodeMirror(this.node, config);
     this._editor.on("change", () => {
-      EditorWidget.getContentsChanged(this).emit(true);
+      this._startBufferTimer();
     });
 
-    this._viewmodel = vm;
-    this._viewmodel.setView(this);
-  }
-
-  /**
-   * Get the contents of the current view as a string.
-   */
-  getContents(): string {
-    var doc = this._editor.getDoc();
-    return doc.getValue();
+    this._model = model;
   }
 
   /**
@@ -308,6 +229,17 @@ class EditorWidget extends Widget implements IEditorWidget {
     }
   }
 
-  private _viewmodel: IEditorViewModel;
+  private _startBufferTimer(): void {
+    clearTimeout(this._bufferTimeoutId);
+    this._bufferTimeoutId = setTimeout(() => {
+      var text = this._editor.getDoc().getValue();
+      this._model.updateBuffer(text);
+    }, this._bufferDelay);
+  }
+
+  private _model: IEditorModel;
   private _editor: CodeMirror.Editor;
+
+  private _bufferTimeoutId = 0;
+  private _bufferDelay = 1000;
 }

From 3e1967066f649f0f7ae32f5e2b79f0d7df3c6e54 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Thu, 12 Nov 2015 20:32:35 +0000
Subject: [PATCH 07/10] Convert to signals and properties

---
 lib/index.d.ts | 149 +++++++++++++++++++++++-----
 lib/index.js   | 257 ++++++++++++++++++++++++++++++++++++++---------
 package.json   |   2 +
 src/index.ts   | 263 ++++++++++++++++++++++++++++++++++++++++---------
 4 files changed, 554 insertions(+), 117 deletions(-)

diff --git a/lib/index.d.ts b/lib/index.d.ts
index 54017bc..5c59735 100644
--- a/lib/index.d.ts
+++ b/lib/index.d.ts
@@ -1,5 +1,7 @@
 import { IDisposable } from 'phosphor-disposable';
 import { Message } from 'phosphor-messaging';
+import { IChangedArgs, Property } from 'phosphor-properties';
+import { ISignal, Signal } from 'phosphor-signaling';
 import { Widget, ResizeMessage } from 'phosphor-widget';
 /**
  * An interface required for implementing the editor model
@@ -27,11 +29,19 @@ export interface IEditorModel {
      * new file with the same data.
      */
     rename(name: string): void;
+    /**
+     * A signal emitted when the editor model state changes.
+     */
+    changed: ISignal<EditorModel, IChangedArgs<any>>;
     /**
      * The mode of the editor, eg. for code this would be
      * the language, like 'python' or 'javascript'.
      */
-    mode(): string;
+    mode: string;
+    /**
+     * The current state of the buffer.
+     */
+    buffer: string;
     /**
      * A flag to determine whether to show line numbers.
      */
@@ -70,49 +80,143 @@ export interface IEditorConfigOptions {
  * The data model behind the editor view.
  */
 export declare class EditorModel implements IDisposable, IEditorModel {
+    /**
+     * A signal emitted when the title state changes.
+     *
+     * **See also:** [[changed]]
+     */
+    static changedSignal: Signal<EditorModel, IChangedArgs<any>>;
+    /**
+     * The property descriptor for the mode text.
+     *
+     * This will be used to set the mode of the editor.
+     *
+     * The default value is an empty string.
+     *
+     * **See also:** [[mode]]
+     */
+    static modeProperty: Property<EditorModel, string>;
+    /**
+     * The property descriptor for the showLineNumbers flag.
+     *
+     * This will be used to set whether line numbers are visible
+     * in the editor.
+     *
+     * The default value is `true`.
+     *
+     * **See also:** [[showLineNumbers]]
+     */
+    static showLineNumbersProperty: Property<EditorModel, boolean>;
+    /**
+     * The property descriptor for the readOnly flag.
+     *
+     * This will be used to set whether the editor is read-only,
+     * or if it is editable.
+     *
+     * The default value is `false`.
+     *
+     * **See also:** [[readOnly]]
+     */
+    static readOnlyProperty: Property<EditorModel, boolean>;
+    /**
+     * The property descriptor for the tabSize number.
+     *
+     * This determines the number of spaces to use in place of a tab.
+     *
+     * The default value is `2`.
+     *
+     * **See also** [[tabSize]]
+     */
+    static tabSizeProperty: Property<EditorModel, number>;
     /**
      * Construct an Editor Model.
      */
     constructor(config?: IEditorConfigOptions);
     /**
-     * Updates the buffer stored in the model.
+     * Get the string for the current buffer.
+     */
+    buffer: string;
+    /**
+     * A signal emitted when the editor model state changes.
      *
-     * @param value - A string containing the complete data in the view.
+     * #### Notes
+     * This is a pure delegate to the [[changedSignal]].
      */
-    updateBuffer(value: string): void;
+    changed: ISignal<EditorModel, IChangedArgs<any>>;
     /**
-     * Save the current buffer in the existing file.
+     * Get the mode for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[modeProperty]].
      */
-    save(): void;
     /**
-     * Rename the current file.
+     * Set the text for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[modeProperty]].
      */
-    rename(name: string): void;
+    mode: string;
     /**
-     * The mode of the current editor.
+     * Get the showLineNumbers flag for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[showLineNumbersProperty]].
      */
-    mode(): string;
     /**
-     * Dispose of this object.
+     * Set the showLineNumbers flag for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[showLineNumbersProperty]].
+     */
+    showLineNumbers: boolean;
+    /**
+     * Get the readOnly flag for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[readOnlyProperty]].
      */
-    dispose(): void;
+    /**
+     * Set the readOnly flag for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[readOnlyProperty]].
+     */
+    readOnly: boolean;
+    /**
+     * Get the tabSize number for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[tabSizeProperty]].
+     */
+    /**
+     * Set the tabSize number for the editor model.
+     *
+     * #### Notes
+     * This is a pure delegate to the [[tabSizeProperty]]
+     */
+    tabSize: number;
     /**
      * Get the disposed status of this object.
      */
     isDisposed: boolean;
     /**
-     * Flag that determines whether to show line numbers.
+     * Updates the buffer stored in the model.
+     *
+     * @param value - A string containing the complete data in the view.
      */
-    showLineNumbers: boolean;
+    updateBuffer(value: string): void;
     /**
-     * Flag that determines whether the view is read-only.
+     * Save the current buffer in the existing file.
      */
-    readOnly: boolean;
+    save(): void;
     /**
-     * Number of spaces to use for a tab.
+     * Rename the current file.
      */
-    tabSize: number;
-    private _mode;
+    rename(name: string): void;
+    /**
+     * Dispose of this object.
+     */
+    dispose(): void;
     private _disposed;
     private _buffer;
 }
@@ -131,13 +235,12 @@ export declare class EditorWidget extends Widget {
      * Construct an EditorWidget.
      */
     constructor(model: IEditorModel);
-    /**
-     * Set the font size in the editor.
-     */
-    fontSize: string;
     protected onAfterAttach(msg: Message): void;
     protected onResize(msg: ResizeMessage): void;
+    private _buildConfig();
+    private _applyConfig(config);
     private _startBufferTimer();
+    private _modelChanged(sender, value);
     private _model;
     private _editor;
     private _bufferTimeoutId;
diff --git a/lib/index.js b/lib/index.js
index 65ea22f..9de8dbe 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -11,6 +11,8 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
+var phosphor_properties_1 = require('phosphor-properties');
+var phosphor_signaling_1 = require('phosphor-signaling');
 var phosphor_widget_1 = require('phosphor-widget');
 /**
  * The data model behind the editor view.
@@ -20,27 +22,135 @@ var EditorModel = (function () {
      * Construct an Editor Model.
      */
     function EditorModel(config) {
+        this._disposed = false;
+        this._buffer = '';
+        var cfg = config || {};
+        this.mode = cfg.mode || '';
+        this.showLineNumbers = cfg.showLineNumbers || true;
+        this.readOnly = cfg.readOnly || false;
+        this.tabSize = cfg.tabSize || 4;
+    }
+    Object.defineProperty(EditorModel.prototype, "buffer", {
         /**
-         * Flag that determines whether to show line numbers.
+         * Get the string for the current buffer.
          */
-        this.showLineNumbers = true;
+        get: function () {
+            return this._buffer;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditorModel.prototype, "changed", {
         /**
-         * Flag that determines whether the view is read-only.
+         * A signal emitted when the editor model state changes.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[changedSignal]].
          */
-        this.readOnly = true;
+        get: function () {
+            return EditorModel.changedSignal.bind(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditorModel.prototype, "mode", {
         /**
-         * Number of spaces to use for a tab.
+         * Get the mode for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[modeProperty]].
          */
-        this.tabSize = 2;
-        this._mode = '';
-        this._disposed = false;
-        this._buffer = '';
-        var cfg = config || {};
-        this._mode = config.mode || 'python';
-        this.showLineNumbers = config.showLineNumbers || true;
-        this.readOnly = config.readOnly || false;
-        this.tabSize = config.tabSize || 4;
-    }
+        get: function () {
+            return EditorModel.modeProperty.get(this);
+        },
+        /**
+         * Set the text for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[modeProperty]].
+         */
+        set: function (value) {
+            EditorModel.modeProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditorModel.prototype, "showLineNumbers", {
+        /**
+         * Get the showLineNumbers flag for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[showLineNumbersProperty]].
+         */
+        get: function () {
+            return EditorModel.showLineNumbersProperty.get(this);
+        },
+        /**
+         * Set the showLineNumbers flag for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[showLineNumbersProperty]].
+         */
+        set: function (value) {
+            EditorModel.showLineNumbersProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditorModel.prototype, "readOnly", {
+        /**
+         * Get the readOnly flag for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[readOnlyProperty]].
+         */
+        get: function () {
+            return EditorModel.readOnlyProperty.get(this);
+        },
+        /**
+         * Set the readOnly flag for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[readOnlyProperty]].
+         */
+        set: function (value) {
+            EditorModel.readOnlyProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditorModel.prototype, "tabSize", {
+        /**
+         * Get the tabSize number for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[tabSizeProperty]].
+         */
+        get: function () {
+            return EditorModel.tabSizeProperty.get(this);
+        },
+        /**
+         * Set the tabSize number for the editor model.
+         *
+         * #### Notes
+         * This is a pure delegate to the [[tabSizeProperty]]
+         */
+        set: function (value) {
+            EditorModel.tabSizeProperty.set(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditorModel.prototype, "isDisposed", {
+        /**
+         * Get the disposed status of this object.
+         */
+        get: function () {
+            return this._disposed;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Updates the buffer stored in the model.
      *
@@ -65,27 +175,75 @@ var EditorModel = (function () {
         // delegate to jupyter-js-services
         console.log('model rename');
     };
-    /**
-     * The mode of the current editor.
-     */
-    EditorModel.prototype.mode = function () {
-        return this._mode;
-    };
     /**
      * Dispose of this object.
      */
     EditorModel.prototype.dispose = function () {
         this._disposed = true;
     };
-    Object.defineProperty(EditorModel.prototype, "isDisposed", {
-        /**
-         * Get the disposed status of this object.
-         */
-        get: function () {
-            return this._disposed;
-        },
-        enumerable: true,
-        configurable: true
+    /**
+     * A signal emitted when the title state changes.
+     *
+     * **See also:** [[changed]]
+     */
+    EditorModel.changedSignal = new phosphor_signaling_1.Signal();
+    /**
+     * The property descriptor for the mode text.
+     *
+     * This will be used to set the mode of the editor.
+     *
+     * The default value is an empty string.
+     *
+     * **See also:** [[mode]]
+     */
+    EditorModel.modeProperty = new phosphor_properties_1.Property({
+        name: 'mode',
+        value: '',
+        notify: EditorModel.changedSignal
+    });
+    /**
+     * The property descriptor for the showLineNumbers flag.
+     *
+     * This will be used to set whether line numbers are visible
+     * in the editor.
+     *
+     * The default value is `true`.
+     *
+     * **See also:** [[showLineNumbers]]
+     */
+    EditorModel.showLineNumbersProperty = new phosphor_properties_1.Property({
+        name: 'showLineNumbers',
+        value: true,
+        notify: EditorModel.changedSignal
+    });
+    /**
+     * The property descriptor for the readOnly flag.
+     *
+     * This will be used to set whether the editor is read-only,
+     * or if it is editable.
+     *
+     * The default value is `false`.
+     *
+     * **See also:** [[readOnly]]
+     */
+    EditorModel.readOnlyProperty = new phosphor_properties_1.Property({
+        name: 'readOnly',
+        value: false,
+        notify: EditorModel.changedSignal
+    });
+    /**
+     * The property descriptor for the tabSize number.
+     *
+     * This determines the number of spaces to use in place of a tab.
+     *
+     * The default value is `2`.
+     *
+     * **See also** [[tabSize]]
+     */
+    EditorModel.tabSizeProperty = new phosphor_properties_1.Property({
+        name: 'tabSize',
+        value: 2,
+        notify: EditorModel.changedSignal
     });
     return EditorModel;
 })();
@@ -111,28 +269,14 @@ var EditorWidget = (function (_super) {
         this._bufferTimeoutId = 0;
         this._bufferDelay = 1000;
         this.addClass('Ph-EditorWidget');
-        var config = {
-            mode: model.mode(),
-            lineNumbers: model.showLineNumbers,
-            tabSize: model.tabSize
-        };
+        this._model = model;
+        this._model.changed.connect(this._modelChanged);
+        var config = this._buildConfig();
         this._editor = CodeMirror(this.node, config);
         this._editor.on("change", function () {
             _this._startBufferTimer();
         });
-        this._model = model;
     }
-    Object.defineProperty(EditorWidget.prototype, "fontSize", {
-        /**
-         * Set the font size in the editor.
-         */
-        set: function (size) {
-            (this._editor.getWrapperElement()).style["font-size"] = size;
-            this._editor.refresh();
-        },
-        enumerable: true,
-        configurable: true
-    });
     EditorWidget.prototype.onAfterAttach = function (msg) {
         this._editor.refresh();
     };
@@ -144,6 +288,21 @@ var EditorWidget = (function (_super) {
             this._editor.setSize(msg.width, msg.height);
         }
     };
+    EditorWidget.prototype._buildConfig = function () {
+        return {
+            mode: this._model.mode,
+            lineNumbers: this._model.showLineNumbers,
+            tabSize: this._model.tabSize
+        };
+    };
+    EditorWidget.prototype._applyConfig = function (config) {
+        var _this = this;
+        config.value = this._model.buffer;
+        this._editor = CodeMirror(this.node, config);
+        this._editor.on("change", function () {
+            _this._startBufferTimer();
+        });
+    };
     EditorWidget.prototype._startBufferTimer = function () {
         var _this = this;
         clearTimeout(this._bufferTimeoutId);
@@ -152,6 +311,10 @@ var EditorWidget = (function (_super) {
             _this._model.updateBuffer(text);
         }, this._bufferDelay);
     };
+    EditorWidget.prototype._modelChanged = function (sender, value) {
+        var config = this._buildConfig();
+        this._applyConfig(config);
+    };
     return EditorWidget;
 })(phosphor_widget_1.Widget);
 exports.EditorWidget = EditorWidget;
diff --git a/package.json b/package.json
index 9499c0b..2442fee 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,8 @@
   "dependencies": {
     "phosphor-disposable": "^1.0.4",
     "phosphor-messaging": "^1.0.5",
+    "phosphor-properties": "^2.0.0",
+    "phosphor-signaling": "^1.1.2",
     "phosphor-widget": "^0.9.13"
   },
   "devDependencies": {
diff --git a/src/index.ts b/src/index.ts
index 98d279b..30996e9 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -15,6 +15,14 @@ import {
   Message
 } from 'phosphor-messaging';
 
+import {
+  IChangedArgs, Property
+} from 'phosphor-properties';
+
+import {
+  ISignal, Signal
+} from 'phosphor-signaling';
+
 import {
   Widget, ResizeMessage
 } from 'phosphor-widget';
@@ -47,11 +55,19 @@ interface IEditorModel {
    * new file with the same data.
    */
   rename(name: string): void;
+  /**
+   * A signal emitted when the editor model state changes.
+   */
+  changed: ISignal<EditorModel, IChangedArgs<any>>
   /**
    * The mode of the editor, eg. for code this would be
    * the language, like 'python' or 'javascript'.
    */
-  mode(): string;
+  mode: string;
+  /**
+   * The current state of the buffer.
+   */
+  buffer: string;
   /**
    * A flag to determine whether to show line numbers.
    */
@@ -97,56 +113,181 @@ interface IEditorConfigOptions {
 export
 class EditorModel implements IDisposable, IEditorModel {
 
+  /**
+   * A signal emitted when the title state changes.
+   *
+   * **See also:** [[changed]]
+   */
+  static changedSignal = new Signal<EditorModel, IChangedArgs<any>>();
+
+  /**
+   * The property descriptor for the mode text.
+   *
+   * This will be used to set the mode of the editor.
+   *
+   * The default value is an empty string.
+   *
+   * **See also:** [[mode]]
+   */
+  static modeProperty = new Property<EditorModel, string>({
+    name: 'mode',
+    value: '',
+    notify: EditorModel.changedSignal
+  });
+
+  /**
+   * The property descriptor for the showLineNumbers flag.
+   *
+   * This will be used to set whether line numbers are visible
+   * in the editor.
+   *
+   * The default value is `true`.
+   *
+   * **See also:** [[showLineNumbers]]
+   */
+  static showLineNumbersProperty = new Property<EditorModel, boolean>({
+    name: 'showLineNumbers',
+    value: true,
+    notify: EditorModel.changedSignal
+  });
+
+  /**
+   * The property descriptor for the readOnly flag.
+   *
+   * This will be used to set whether the editor is read-only,
+   * or if it is editable.
+   *
+   * The default value is `false`.
+   *
+   * **See also:** [[readOnly]]
+   */
+  static readOnlyProperty = new Property<EditorModel, boolean>({
+    name: 'readOnly',
+    value: false,
+    notify: EditorModel.changedSignal
+  });
+
+  /**
+   * The property descriptor for the tabSize number.
+   *
+   * This determines the number of spaces to use in place of a tab.
+   *
+   * The default value is `2`.
+   *
+   * **See also** [[tabSize]]
+   */
+  static tabSizeProperty = new Property<EditorModel, number>({
+    name: 'tabSize',
+    value: 2,
+    notify: EditorModel.changedSignal
+  });
+
   /**
    * Construct an Editor Model.
    */
   constructor(config?: IEditorConfigOptions) {
     var cfg = config || {};
-    this._mode = config.mode || 'python';
-    this.showLineNumbers = config.showLineNumbers || true;
-    this.readOnly = config.readOnly || false;
-    this.tabSize = config.tabSize || 4;
+    this.mode = cfg.mode || '';
+    this.showLineNumbers = cfg.showLineNumbers || true;
+    this.readOnly = cfg.readOnly || false;
+    this.tabSize = cfg.tabSize || 4;
   }
 
   /**
-   * Updates the buffer stored in the model.
+   * Get the string for the current buffer.
+   */
+  get buffer(): string {
+    return this._buffer;
+  }
+
+  /**
+   * A signal emitted when the editor model state changes.
    *
-   * @param value - A string containing the complete data in the view.
+   * #### Notes
+   * This is a pure delegate to the [[changedSignal]].
    */
-  updateBuffer(value: string): void {
-    if (!this.isDisposed) {
-      this._buffer = value;
-    }
+  get changed(): ISignal<EditorModel, IChangedArgs<any>> {
+    return EditorModel.changedSignal.bind(this);
   }
 
   /**
-   * Save the current buffer in the existing file.
+   * Get the mode for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[modeProperty]].
    */
-  save(): void {
-    // delegate to jupyter-js-services
-    console.log('model save');
+  get mode(): string {
+    return EditorModel.modeProperty.get(this);
   }
 
   /**
-   * Rename the current file.
+   * Set the text for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[modeProperty]].
    */
-  rename(name: string): void {
-    // delegate to jupyter-js-services
-    console.log('model rename');
+  set mode(value: string) {
+    EditorModel.modeProperty.set(this, value);
   }
 
   /**
-   * The mode of the current editor.
+   * Get the showLineNumbers flag for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[showLineNumbersProperty]].
    */
-  mode(): string {
-    return this._mode;
+  get showLineNumbers(): boolean {
+    return EditorModel.showLineNumbersProperty.get(this);
   }
 
   /**
-   * Dispose of this object.
+   * Set the showLineNumbers flag for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[showLineNumbersProperty]].
    */
-  dispose(): void {
-    this._disposed = true;
+  set showLineNumbers(value: boolean) {
+    EditorModel.showLineNumbersProperty.set(this, value);
+  }
+
+  /**
+   * Get the readOnly flag for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[readOnlyProperty]].
+   */
+  get readOnly(): boolean {
+    return EditorModel.readOnlyProperty.get(this);
+  }
+
+  /**
+   * Set the readOnly flag for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[readOnlyProperty]].
+   */
+  set readOnly(value: boolean) {
+    EditorModel.readOnlyProperty.set(this, value);
+  }
+
+  /**
+   * Get the tabSize number for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[tabSizeProperty]].
+   */
+  get tabSize(): number {
+    return EditorModel.tabSizeProperty.get(this);
+  }
+
+  /**
+   * Set the tabSize number for the editor model.
+   *
+   * #### Notes
+   * This is a pure delegate to the [[tabSizeProperty]]
+   */
+  set tabSize(value: number) {
+    EditorModel.tabSizeProperty.set(this, value);
   }
 
   /**
@@ -157,25 +298,44 @@ class EditorModel implements IDisposable, IEditorModel {
   }
 
   /**
-   * Flag that determines whether to show line numbers.
+   * Updates the buffer stored in the model.
+   *
+   * @param value - A string containing the complete data in the view.
    */
-  showLineNumbers = true;
+  updateBuffer(value: string): void {
+    if (!this.isDisposed) {
+      this._buffer = value;
+    }
+  }
 
   /**
-   * Flag that determines whether the view is read-only.
+   * Save the current buffer in the existing file.
    */
-  readOnly = true;
+  save(): void {
+    // delegate to jupyter-js-services
+    console.log('model save');
+  }
 
   /**
-   * Number of spaces to use for a tab.
+   * Rename the current file.
    */
-  tabSize = 2;
+  rename(name: string): void {
+    // delegate to jupyter-js-services
+    console.log('model rename');
+  }
+
+  /**
+   * Dispose of this object.
+   */
+  dispose(): void {
+    this._disposed = true;
+  }
 
-  private _mode = '';
   private _disposed = false;
   private _buffer = '';
 }
 
+
 /**
  * A widget used for entering text/code.
  *
@@ -195,26 +355,14 @@ class EditorWidget extends Widget {
   constructor(model: IEditorModel) {
     super();
     this.addClass('Ph-EditorWidget');
+    this._model = model;
+    this._model.changed.connect(this._modelChanged);
 
-    var config = {
-      mode: model.mode(),
-      lineNumbers: model.showLineNumbers,
-      tabSize: model.tabSize
-    };
+    var config = this._buildConfig();
     this._editor = CodeMirror(this.node, config);
     this._editor.on("change", () => {
       this._startBufferTimer();
     });
-
-    this._model = model;
-  }
-
-  /**
-   * Set the font size in the editor.
-   */
-  set fontSize(size: string) {
-    (<any>(this._editor.getWrapperElement())).style["font-size"] = size;
-    this._editor.refresh();
   }
 
   protected onAfterAttach(msg: Message): void {
@@ -229,6 +377,22 @@ class EditorWidget extends Widget {
     }
   }
 
+  private _buildConfig(): any {
+    return {
+      mode: this._model.mode,
+      lineNumbers: this._model.showLineNumbers,
+      tabSize: this._model.tabSize
+    };
+  }
+
+  private _applyConfig(config: any) {
+    config.value = this._model.buffer;
+    this._editor = CodeMirror(this.node, config);
+    this._editor.on("change", () => {
+      this._startBufferTimer();
+    });
+  }
+
   private _startBufferTimer(): void {
     clearTimeout(this._bufferTimeoutId);
     this._bufferTimeoutId = setTimeout(() => {
@@ -237,6 +401,11 @@ class EditorWidget extends Widget {
     }, this._bufferDelay);
   }
 
+  private _modelChanged(sender: IEditorModel, value: IChangedArgs<any>) {
+    var config = this._buildConfig();
+    this._applyConfig(config);
+  }
+
   private _model: IEditorModel;
   private _editor: CodeMirror.Editor;
 

From ede3b43af4d367f153d98cb43916b55b55a879fa Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Thu, 12 Nov 2015 20:33:17 +0000
Subject: [PATCH 08/10] Fix gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 5f65f07..0d12cbf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,5 @@ node_modules
 npm-debug.log
 test/build
 example/build
+example/bundle.js
 lib/

From 2e1c705952ebcaa192478e62ae5ca9bd008aef11 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Thu, 12 Nov 2015 23:34:23 +0000
Subject: [PATCH 09/10] Cleanup

---
 README.md    | 3 +--
 src/index.ts | 5 ++---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index c66a2ed..e5d6f6a 100644
--- a/README.md
+++ b/README.md
@@ -66,7 +66,6 @@ Supported Runtimes
 The runtime versions which are currently *known to work* are listed below.
 Earlier versions may also work, but come with no guarantees.
 
-- Node 0.12.7+
 - IE 11+
 - Firefox 32+
 - Chrome 38+
@@ -86,5 +85,5 @@ browserify myapp.js -o mybundle.js
 Usage Examples
 --------------
 
-**Note:** This module is fully compatible with Node/Babel/ES6/ES5. Simply
+**Note:** This module is fully compatible with Babel/ES6/ES5. Simply
 omit the type declarations when using a language other than TypeScript.
diff --git a/src/index.ts b/src/index.ts
index 30996e9..1106cca 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -342,8 +342,7 @@ class EditorModel implements IDisposable, IEditorModel {
  * #### Notes
  * This class happens to use Codemirror as the hosted widget for
  * text entry, but Codemirror is entirely encapsulated
- * within this class. As long as the IEditorWidget interface is
- * adhered to, any other text editor widget can be easily
+ * within this class so any other text editor widget can be easily
  * swapped in.
  */
 export
@@ -354,7 +353,7 @@ class EditorWidget extends Widget {
    */
   constructor(model: IEditorModel) {
     super();
-    this.addClass('Ph-EditorWidget');
+    this.addClass('jp-EditorWidget');
     this._model = model;
     this._model.changed.connect(this._modelChanged);
 

From ecd1979c6489cf2fb1bc3a076506d62cf449a9c4 Mon Sep 17 00:00:00 2001
From: Dave Willmer <dave.willmer@gmail.com>
Date: Fri, 13 Nov 2015 12:43:02 +0000
Subject: [PATCH 10/10] Remove bundle

---
 example/bundle.js | 3868 ---------------------------------------------
 1 file changed, 3868 deletions(-)
 delete mode 100644 example/bundle.js

diff --git a/example/bundle.js b/example/bundle.js
deleted file mode 100644
index e85ed12..0000000
--- a/example/bundle.js
+++ /dev/null
@@ -1,3868 +0,0 @@
-(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use-strict';
-var phosphor_widget_1 = require('phosphor-widget');
-var index_1 = require('../../lib/index');
-function main() {
-    var model = new index_1.EditorModel();
-    var viewmodel = new index_1.EditorViewModel(model);
-    var view = new index_1.EditorWidget(viewmodel);
-    phosphor_widget_1.Widget.attach(view, document.getElementById('main'));
-    view.update();
-    window.onresize = function () { return view.update(); };
-}
-window.onload = main;
-
-},{"../../lib/index":2,"phosphor-widget":8}],2:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-var __extends = (this && this.__extends) || function (d, b) {
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-};
-var phosphor_signaling_1 = require('phosphor-signaling');
-var phosphor_widget_1 = require('phosphor-widget');
-/**
- * An implementation of IEditorModel.
- */
-var EditorModel = (function () {
-    function EditorModel() {
-        this._lineNumbers = true;
-        this._tabSize = 2;
-    }
-    /**
-     * Save the data to file.
-     */
-    EditorModel.prototype.save = function (data) {
-        // to be delegated to jupyter-js-services.
-        console.log('model save');
-    };
-    /**
-     * Rename the current file.
-     */
-    EditorModel.prototype.rename = function (name) {
-        // to be delegated to jupyter-js-services.
-        console.log('model rename');
-    };
-    return EditorModel;
-})();
-exports.EditorModel = EditorModel;
-var EditorViewModel = (function () {
-    /**
-     * Construct an editor view model.
-     */
-    function EditorViewModel(model) {
-        /**
-         * Flag that determines whether to show line numbers.
-         */
-        this.showLineNumbers = true;
-        /**
-         * Flag that determines whether the view is read-only.
-         */
-        this.readOnly = true;
-        /**
-         * Number of spaces to use for a tab.
-         */
-        this.tabSize = 2;
-        this._mode = '';
-        this._disposed = false;
-        this._view = null;
-        this._buffer = '';
-        /**
-         * The delay in milliseconds between view buffer-fetches.
-         */
-        this._bufferDelay = 1000;
-        /**
-         * The id returned by setTimeout.
-         */
-        this._bufferTimeoutId = 0;
-        this._model = model;
-    }
-    /**
-     * Set the view object for this view model.
-     */
-    EditorViewModel.prototype.setView = function (view) {
-        this._view = view;
-        EditorWidget
-            .getContentsChanged(this._view)
-            .connect(this._startBufferTimer, this);
-    };
-    /**
-     * Save the current buffer in the existing file.
-     */
-    EditorViewModel.prototype.save = function () {
-        this._updateBuffer();
-        this._model.save(this._buffer);
-    };
-    /**
-     * Rename the current file.
-     */
-    EditorViewModel.prototype.rename = function (name) {
-        this._model.rename(name);
-    };
-    /**
-     * The mode of the current editor.
-     */
-    EditorViewModel.prototype.mode = function () {
-        return this._mode;
-    };
-    /**
-     * Dispose of this object.
-     */
-    EditorViewModel.prototype.dispose = function () {
-        this._disposed = true;
-        phosphor_signaling_1.clearSignalData(this);
-        this._model = null;
-        this._view = null;
-    };
-    Object.defineProperty(EditorViewModel.prototype, "isDisposed", {
-        /**
-         * Get the disposed status of this object.
-         */
-        get: function () {
-            return this._disposed;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    EditorViewModel.prototype._updateBuffer = function () {
-        if (!this.isDisposed) {
-            var data = this._view.getContents();
-            this._buffer = data;
-        }
-    };
-    EditorViewModel.prototype._startBufferTimer = function () {
-        var _this = this;
-        clearTimeout(this._bufferTimeoutId);
-        this._bufferTimeoutId = setTimeout(function () {
-            _this._updateBuffer();
-        }, this._bufferDelay);
-    };
-    return EditorViewModel;
-})();
-exports.EditorViewModel = EditorViewModel;
-/**
- * A widget used for entering text/code.
- *
- * #### Notes
- * This class happens to use Codemirror as the hosted widget for
- * text entry, but Codemirror is entirely encapsulated
- * within this class. As long as the IEditorWidget interface is
- * adhered to, any other text editor widget can be easily
- * swapped in.
- */
-var EditorWidget = (function (_super) {
-    __extends(EditorWidget, _super);
-    /**
-     * Construct an EditorWidget.
-     */
-    function EditorWidget(vm) {
-        var _this = this;
-        _super.call(this);
-        this.addClass('EditorWidget');
-        var config = {
-            mode: vm.mode(),
-            lineNumbers: vm.showLineNumbers,
-            tabSize: vm.tabSize
-        };
-        this._editor = CodeMirror(this.node, config);
-        this._editor.on("change", function () {
-            EditorWidget.getContentsChanged(_this).emit(true);
-        });
-        this._viewmodel = vm;
-        this._viewmodel.setView(this);
-    }
-    /**
-     * A pure delegate for [[contentsChangedSignal]].
-     */
-    EditorWidget.getContentsChanged = function (item) {
-        return EditorWidget.contentsChangedSignal.bind(item);
-    };
-    /**
-     * Get the contents of the current view as a string.
-     */
-    EditorWidget.prototype.getContents = function () {
-        var doc = this._editor.getDoc();
-        return doc.getValue();
-    };
-    Object.defineProperty(EditorWidget.prototype, "fontSize", {
-        /**
-         * Set the font size in the editor.
-         */
-        set: function (size) {
-            (this._editor.getWrapperElement()).style["font-size"] = size;
-            this._editor.refresh();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    EditorWidget.prototype.onAfterAttach = function (msg) {
-        this._editor.refresh();
-    };
-    EditorWidget.prototype.onResize = function (msg) {
-        if (msg.width < 0 || msg.height < 0) {
-            this._editor.refresh();
-        }
-        else {
-            this._editor.setSize(msg.width, msg.height);
-        }
-    };
-    /**
-     * A signal which is emitted when the view contents change.
-     *
-     * #### Notes
-     * This is designed for the view-model. The data is *not* passed
-     * as the signal argument in order that the view-model can decide
-     * when to pull the potentially large data string from the view.
-     */
-    EditorWidget.contentsChangedSignal = new phosphor_signaling_1.Signal();
-    return EditorWidget;
-})(phosphor_widget_1.Widget);
-exports.EditorWidget = EditorWidget;
-
-},{"phosphor-signaling":6,"phosphor-widget":8}],3:[function(require,module,exports){
-'use strict';
-// For more information about browser field, check out the browser field at https://github.com/substack/browserify-handbook#browser-field.
-
-module.exports = {
-    // Create a <link> tag with optional data attributes
-    createLink: function(href, attributes) {
-        var head = document.head || document.getElementsByTagName('head')[0];
-        var link = document.createElement('link');
-
-        link.href = href;
-        link.rel = 'stylesheet';
-
-        for (var key in attributes) {
-            if ( ! attributes.hasOwnProperty(key)) {
-                continue;
-            }
-            var value = attributes[key];
-            link.setAttribute('data-' + key, value);
-        }
-
-        head.appendChild(link);
-    },
-    // Create a <style> tag with optional data attributes
-    createStyle: function(cssText, attributes) {
-        var head = document.head || document.getElementsByTagName('head')[0],
-            style = document.createElement('style');
-
-        style.type = 'text/css';
-
-        for (var key in attributes) {
-            if ( ! attributes.hasOwnProperty(key)) {
-                continue;
-            }
-            var value = attributes[key];
-            style.setAttribute('data-' + key, value);
-        }
-        
-        if (style.sheet) { // for jsdom and IE9+
-            style.innerHTML = cssText;
-            style.sheet.cssText = cssText;
-            head.appendChild(style);
-        } else if (style.styleSheet) { // for IE8 and below
-            head.appendChild(style);
-            style.styleSheet.cssText = cssText;
-        } else { // for Chrome, Firefox, and Safari
-            style.appendChild(document.createTextNode(cssText));
-            head.appendChild(style);
-        }
-    }
-};
-
-},{}],4:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-var phosphor_queue_1 = require('phosphor-queue');
-/**
- * A mesage which can be sent or posted to a message handler.
- *
- * #### Notes
- * This class may be subclassed to create complex message types.
- *
- * **See Also** [[postMessage]] and [[sendMessage]].
- */
-var Message = (function () {
-    /**
-     * Construct a new message.
-     *
-     * @param type - The type of the message. Consumers of a message will
-     *   use this value to cast the message to the appropriately derived
-     *   message type.
-     */
-    function Message(type) {
-        this._type = type;
-    }
-    Object.defineProperty(Message.prototype, "type", {
-        /**
-         * Get the type of the message.
-         */
-        get: function () {
-            return this._type;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return Message;
-})();
-exports.Message = Message;
-/**
- * Send a message to the message handler to process immediately.
- *
- * @param handler - The handler which should process the message.
- *
- * @param msg - The message to send to the handler.
- *
- * #### Notes
- * Unlike [[postMessage]], [[sendMessage]] delivers the message to
- * the handler immediately. The handler will not have the opportunity
- * to compress the message, however the message will still be sent
- * through any installed message filters.
- *
- * **See Also** [[postMessage]].
- */
-function sendMessage(handler, msg) {
-    getDispatcher(handler).sendMessage(handler, msg);
-}
-exports.sendMessage = sendMessage;
-/**
- * Post a message to the message handler to process in the future.
- *
- * @param handler - The handler which should process the message.
- *
- * @param msg - The message to post to the handler.
- *
- * #### Notes
- * Unlike [[sendMessage]], [[postMessage]] will schedule the deliver of
- * the message for the next cycle of the event loop. The handler will
- * have the opportunity to compress the message in order to optimize
- * its handling of similar messages. The message will be sent through
- * any installed message filters before being delivered to the handler.
- *
- * **See Also** [[sendMessage]].
- */
-function postMessage(handler, msg) {
-    getDispatcher(handler).postMessage(handler, msg);
-}
-exports.postMessage = postMessage;
-/**
- * Test whether a message handler has posted messages pending delivery.
- *
- * @param handler - The message handler of interest.
- *
- * @returns `true` if the handler has pending posted messages, `false`
- *   otherwise.
- *
- * **See Also** [[sendPendingMessage]].
- */
-function hasPendingMessages(handler) {
-    return getDispatcher(handler).hasPendingMessages();
-}
-exports.hasPendingMessages = hasPendingMessages;
-/**
- * Send the first pending posted message to the message handler.
- *
- * @param handler - The message handler of interest.
- *
- * #### Notes
- * If the handler has no pending messages, this is a no-op.
- *
- * **See Also** [[hasPendingMessages]].
- */
-function sendPendingMessage(handler) {
-    getDispatcher(handler).sendPendingMessage(handler);
-}
-exports.sendPendingMessage = sendPendingMessage;
-/**
- * Install a message filter for a message handler.
- *
- * A message filter is invoked before the message handler processes a
- * message. If the filter returns `true` from its [[filterMessage]] method,
- * no other filters will be invoked, and the message will not be delivered.
- *
- * The most recently installed message filter is executed first.
- *
- * @param handler - The handler whose messages should be filtered.
- *
- * @param filter - The filter to install for the handler.
- *
- * #### Notes
- * It is possible to install the same filter multiple times. If the
- * filter should be unique, call [[removeMessageFilter]] first.
- *
- * **See Also** [[removeMessageFilter]].
- */
-function installMessageFilter(handler, filter) {
-    getDispatcher(handler).installMessageFilter(filter);
-}
-exports.installMessageFilter = installMessageFilter;
-/**
- * Remove a previously installed message filter for a message handler.
- *
- * @param handler - The handler for which the filter is installed.
- *
- * @param filter - The filter to remove.
- *
- * #### Notes
- * This will remove **all** occurrences of the filter. If the filter is
- * not installed, this is a no-op.
- *
- * It is safe to call this function while the filter is executing.
- *
- * **See Also** [[installMessageFilter]].
- */
-function removeMessageFilter(handler, filter) {
-    getDispatcher(handler).removeMessageFilter(filter);
-}
-exports.removeMessageFilter = removeMessageFilter;
-/**
- * Clear all message data associated with the message handler.
- *
- * @param handler - The message handler for which to clear the data.
- *
- * #### Notes
- * This will remove all pending messages and filters for the handler.
- */
-function clearMessageData(handler) {
-    var dispatcher = dispatcherMap.get(handler);
-    if (dispatcher)
-        dispatcher.clear();
-    dispatchQueue.removeAll(handler);
-}
-exports.clearMessageData = clearMessageData;
-/**
- * The internal mapping of message handler to message dispatcher
- */
-var dispatcherMap = new WeakMap();
-/**
- * The internal queue of pending message handlers.
- */
-var dispatchQueue = new phosphor_queue_1.Queue();
-/**
- * The internal animation frame id for the message loop wake up call.
- */
-var frameId = void 0;
-/**
- * A local reference to an event loop hook.
- */
-var raf;
-if (typeof requestAnimationFrame === 'function') {
-    raf = requestAnimationFrame;
-}
-else {
-    raf = setImmediate;
-}
-/**
- * Get or create the message dispatcher for a message handler.
- */
-function getDispatcher(handler) {
-    var dispatcher = dispatcherMap.get(handler);
-    if (dispatcher)
-        return dispatcher;
-    dispatcher = new MessageDispatcher();
-    dispatcherMap.set(handler, dispatcher);
-    return dispatcher;
-}
-/**
- * Wake up the message loop to process any pending dispatchers.
- *
- * This is a no-op if a wake up is not needed or is already pending.
- */
-function wakeUpMessageLoop() {
-    if (frameId === void 0 && !dispatchQueue.empty) {
-        frameId = raf(runMessageLoop);
-    }
-}
-/**
- * Run an iteration of the message loop.
- *
- * This will process all pending dispatchers in the queue. Dispatchers
- * which are added to the queue while the message loop is running will
- * be processed on the next message loop cycle.
- */
-function runMessageLoop() {
-    // Clear the frame id so the next wake up call can be scheduled.
-    frameId = void 0;
-    // If the queue is empty, there is nothing else to do.
-    if (dispatchQueue.empty) {
-        return;
-    }
-    // Add a null sentinel value to the end of the queue. The queue
-    // will only be processed up to the first null value. This means
-    // that messages posted during this cycle will execute on the next
-    // cycle of the loop. If the last value in the array is null, it
-    // means that an exception was thrown by a message handler and the
-    // loop had to be restarted.
-    if (dispatchQueue.back !== null) {
-        dispatchQueue.push(null);
-    }
-    // The message dispatch loop. If the dispatcher is the null sentinel,
-    // the processing of the current block of messages is complete and
-    // another loop is scheduled. Otherwise, the pending message is
-    // dispatched to the message handler.
-    while (!dispatchQueue.empty) {
-        var handler = dispatchQueue.pop();
-        if (handler === null) {
-            wakeUpMessageLoop();
-            return;
-        }
-        dispatchMessage(dispatcherMap.get(handler), handler);
-    }
-}
-/**
- * Safely process the pending handler message.
- *
- * If the message handler throws an exception, the message loop will
- * be restarted and the exception will be rethrown.
- */
-function dispatchMessage(dispatcher, handler) {
-    try {
-        dispatcher.sendPendingMessage(handler);
-    }
-    catch (ex) {
-        wakeUpMessageLoop();
-        throw ex;
-    }
-}
-/**
- * An internal class which manages message dispatching for a handler.
- */
-var MessageDispatcher = (function () {
-    function MessageDispatcher() {
-        this._filters = null;
-        this._messages = null;
-    }
-    /**
-     * Send a message to the handler immediately.
-     *
-     * The message will first be sent through installed filters.
-     */
-    MessageDispatcher.prototype.sendMessage = function (handler, msg) {
-        if (!this._filterMessage(handler, msg)) {
-            handler.processMessage(msg);
-        }
-    };
-    /**
-     * Post a message for delivery in the future.
-     *
-     * The message will first be compressed if possible.
-     */
-    MessageDispatcher.prototype.postMessage = function (handler, msg) {
-        if (!this._compressMessage(handler, msg)) {
-            this._enqueueMessage(handler, msg);
-        }
-    };
-    /**
-     * Test whether the dispatcher has messages pending delivery.
-     */
-    MessageDispatcher.prototype.hasPendingMessages = function () {
-        return !!(this._messages && !this._messages.empty);
-    };
-    /**
-     * Send the first pending message to the message handler.
-     */
-    MessageDispatcher.prototype.sendPendingMessage = function (handler) {
-        if (this._messages && !this._messages.empty) {
-            this.sendMessage(handler, this._messages.pop());
-        }
-    };
-    /**
-     * Install a message filter for the dispatcher.
-     */
-    MessageDispatcher.prototype.installMessageFilter = function (filter) {
-        this._filters = { next: this._filters, filter: filter };
-    };
-    /**
-     * Remove all occurrences of a message filter from the dispatcher.
-     */
-    MessageDispatcher.prototype.removeMessageFilter = function (filter) {
-        var link = this._filters;
-        var prev = null;
-        while (link !== null) {
-            if (link.filter === filter) {
-                link.filter = null;
-            }
-            else if (prev === null) {
-                this._filters = link;
-                prev = link;
-            }
-            else {
-                prev.next = link;
-                prev = link;
-            }
-            link = link.next;
-        }
-        if (!prev) {
-            this._filters = null;
-        }
-        else {
-            prev.next = null;
-        }
-    };
-    /**
-     * Clear all messages and filters from the dispatcher.
-     */
-    MessageDispatcher.prototype.clear = function () {
-        if (this._messages) {
-            this._messages.clear();
-        }
-        for (var link = this._filters; link !== null; link = link.next) {
-            link.filter = null;
-        }
-        this._filters = null;
-    };
-    /**
-     * Run the installed message filters for the handler.
-     *
-     * Returns `true` if the message was filtered, `false` otherwise.
-     */
-    MessageDispatcher.prototype._filterMessage = function (handler, msg) {
-        for (var link = this._filters; link !== null; link = link.next) {
-            if (link.filter && link.filter.filterMessage(handler, msg)) {
-                return true;
-            }
-        }
-        return false;
-    };
-    /**
-     * Compress the mssage for the given handler.
-     *
-     * Returns `true` if the message was compressed, `false` otherwise.
-     */
-    MessageDispatcher.prototype._compressMessage = function (handler, msg) {
-        if (!handler.compressMessage) {
-            return false;
-        }
-        if (!this._messages || this._messages.empty) {
-            return false;
-        }
-        return handler.compressMessage(msg, this._messages);
-    };
-    /**
-     * Enqueue the message for future delivery to the handler.
-     */
-    MessageDispatcher.prototype._enqueueMessage = function (handler, msg) {
-        (this._messages || (this._messages = new phosphor_queue_1.Queue())).push(msg);
-        dispatchQueue.push(handler);
-        wakeUpMessageLoop();
-    };
-    return MessageDispatcher;
-})();
-
-},{"phosphor-queue":5}],5:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-/**
- * A generic FIFO queue data structure.
- *
- * #### Notes
- * This queue is implemented internally using a singly linked list and
- * can grow to arbitrary size.
- *
- * #### Example
- * ```typescript
- * var q = new Queue<number>([0, 1, 2]);
- * q.size;      // 3
- * q.empty;     // false
- * q.pop();     // 0
- * q.pop();     // 1
- * q.push(42);  // undefined
- * q.size;      // 2
- * q.pop();     // 2
- * q.pop();     // 42
- * q.pop();     // undefined
- * q.size;      // 0
- * q.empty;     // true
- * ```
- */
-var Queue = (function () {
-    /**
-     * Construct a new queue.
-     *
-     * @param items - The initial items for the queue.
-     */
-    function Queue(items) {
-        var _this = this;
-        this._size = 0;
-        this._front = null;
-        this._back = null;
-        if (items)
-            items.forEach(function (item) { return _this.push(item); });
-    }
-    Object.defineProperty(Queue.prototype, "size", {
-        /**
-         * Get the number of elements in the queue.
-         *
-         * #### Notes
-         * This has `O(1)` complexity.
-         */
-        get: function () {
-            return this._size;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Queue.prototype, "empty", {
-        /**
-         * Test whether the queue is empty.
-         *
-         * #### Notes
-         * This has `O(1)` complexity.
-         */
-        get: function () {
-            return this._size === 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Queue.prototype, "front", {
-        /**
-         * Get the value at the front of the queue.
-         *
-         * #### Notes
-         * This has `O(1)` complexity.
-         *
-         * If the queue is empty, this value will be `undefined`.
-         */
-        get: function () {
-            return this._front !== null ? this._front.value : void 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Queue.prototype, "back", {
-        /**
-         * Get the value at the back of the queue.
-         *
-         * #### Notes
-         * This has `O(1)` complexity.
-         *
-         * If the queue is empty, this value will be `undefined`.
-         */
-        get: function () {
-            return this._back !== null ? this._back.value : void 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Push a value onto the back of the queue.
-     *
-     * @param value - The value to add to the queue.
-     *
-     * #### Notes
-     * This has `O(1)` complexity.
-     */
-    Queue.prototype.push = function (value) {
-        var link = { next: null, value: value };
-        if (this._back === null) {
-            this._front = link;
-            this._back = link;
-        }
-        else {
-            this._back.next = link;
-            this._back = link;
-        }
-        this._size++;
-    };
-    /**
-     * Pop and return the value at the front of the queue.
-     *
-     * @returns The value at the front of the queue.
-     *
-     * #### Notes
-     * This has `O(1)` complexity.
-     *
-     * If the queue is empty, the return value will be `undefined`.
-     */
-    Queue.prototype.pop = function () {
-        var link = this._front;
-        if (link === null) {
-            return void 0;
-        }
-        if (link.next === null) {
-            this._front = null;
-            this._back = null;
-        }
-        else {
-            this._front = link.next;
-        }
-        this._size--;
-        return link.value;
-    };
-    /**
-     * Remove the first occurrence of a value from the queue.
-     *
-     * @param value - The value to remove from the queue.
-     *
-     * @returns `true` on success, `false` otherwise.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     */
-    Queue.prototype.remove = function (value) {
-        var link = this._front;
-        var prev = null;
-        while (link !== null) {
-            if (link.value === value) {
-                if (prev === null) {
-                    this._front = link.next;
-                }
-                else {
-                    prev.next = link.next;
-                }
-                if (link.next === null) {
-                    this._back = prev;
-                }
-                this._size--;
-                return true;
-            }
-            prev = link;
-            link = link.next;
-        }
-        return false;
-    };
-    /**
-     * Remove all occurrences of a value from the queue.
-     *
-     * @param value - The value to remove from the queue.
-     *
-     * @returns The number of occurrences removed.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     */
-    Queue.prototype.removeAll = function (value) {
-        var count = 0;
-        var link = this._front;
-        var prev = null;
-        while (link !== null) {
-            if (link.value === value) {
-                count++;
-                this._size--;
-            }
-            else if (prev === null) {
-                this._front = link;
-                prev = link;
-            }
-            else {
-                prev.next = link;
-                prev = link;
-            }
-            link = link.next;
-        }
-        if (!prev) {
-            this._front = null;
-            this._back = null;
-        }
-        else {
-            prev.next = null;
-            this._back = prev;
-        }
-        return count;
-    };
-    /**
-     * Remove all values from the queue.
-     *
-     * #### Notes
-     * This has `O(1)` complexity.
-     */
-    Queue.prototype.clear = function () {
-        this._size = 0;
-        this._front = null;
-        this._back = null;
-    };
-    /**
-     * Create an array from the values in the queue.
-     *
-     * @returns An array of all values in the queue.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     */
-    Queue.prototype.toArray = function () {
-        var result = new Array(this._size);
-        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
-            result[i] = link.value;
-        }
-        return result;
-    };
-    /**
-     * Test whether any value in the queue passes a predicate function.
-     *
-     * @param pred - The predicate to apply to the values.
-     *
-     * @returns `true` if any value in the queue passes the predicate,
-     *   or `false` otherwise.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     *
-     * It is **not** safe for the predicate to modify the queue while
-     * iterating.
-     */
-    Queue.prototype.some = function (pred) {
-        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
-            if (pred(link.value, i))
-                return true;
-        }
-        return false;
-    };
-    /**
-     * Test whether all values in the queue pass a predicate function.
-     *
-     * @param pred - The predicate to apply to the values.
-     *
-     * @returns `true` if all values in the queue pass the predicate,
-     *   or `false` otherwise.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     *
-     * It is **not** safe for the predicate to modify the queue while
-     * iterating.
-     */
-    Queue.prototype.every = function (pred) {
-        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
-            if (!pred(link.value, i))
-                return false;
-        }
-        return true;
-    };
-    /**
-     * Create an array of the values which pass a predicate function.
-     *
-     * @param pred - The predicate to apply to the values.
-     *
-     * @returns The array of values which pass the predicate.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     *
-     * It is **not** safe for the predicate to modify the queue while
-     * iterating.
-     */
-    Queue.prototype.filter = function (pred) {
-        var result = [];
-        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
-            if (pred(link.value, i))
-                result.push(link.value);
-        }
-        return result;
-    };
-    /**
-     * Create an array of mapped values for the values in the queue.
-     *
-     * @param callback - The map function to apply to the values.
-     *
-     * @returns The array of values returned by the map function.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     *
-     * It is **not** safe for the callback to modify the queue while
-     * iterating.
-     */
-    Queue.prototype.map = function (callback) {
-        var result = new Array(this._size);
-        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
-            result[i] = callback(link.value, i);
-        }
-        return result;
-    };
-    /**
-     * Execute a callback for each value in the queue.
-     *
-     * @param callback - The function to apply to the values.
-     *
-     * @returns The first value returned by the callback which is not
-     *   `undefined`.
-     *
-     * #### Notes
-     * This has `O(N)` complexity.
-     *
-     * Iteration will terminate immediately if the callback returns any
-     * value other than `undefined`.
-     *
-     * It is **not** safe for the callback to modify the queue while
-     * iterating.
-     */
-    Queue.prototype.forEach = function (callback) {
-        for (var i = 0, link = this._front; link !== null; link = link.next, ++i) {
-            var result = callback(link.value, i);
-            if (result !== void 0)
-                return result;
-        }
-        return void 0;
-    };
-    return Queue;
-})();
-exports.Queue = Queue;
-
-},{}],6:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-/**
- * An object used for type-safe inter-object communication.
- *
- * Signals provide a type-safe implementation of the publish-subscribe
- * pattern. An object (publisher) declares which signals it will emit,
- * and consumers connect callbacks (subscribers) to those signals. The
- * subscribers are invoked whenever the publisher emits the signal.
- *
- * A `Signal` object must be bound to a sender in order to be useful.
- * A common pattern is to declare a `Signal` object as a static class
- * member, along with a convenience getter which binds the signal to
- * the `this` instance on-demand.
- *
- * #### Example
- * ```typescript
- * import { ISignal, Signal } from 'phosphor-signaling';
- *
- * class MyClass {
- *
- *   static valueChangedSignal = new Signal<MyClass, number>();
- *
- *   constructor(name: string) {
- *     this._name = name;
- *   }
- *
- *   get valueChanged(): ISignal<MyClass, number> {
- *     return MyClass.valueChangedSignal.bind(this);
- *   }
- *
- *   get name(): string {
- *     return this._name;
- *   }
- *
- *   get value(): number {
- *     return this._value;
- *   }
- *
- *   set value(value: number) {
- *     if (value !== this._value) {
- *       this._value = value;
- *       this.valueChanged.emit(value);
- *     }
- *   }
- *
- *   private _name: string;
- *   private _value = 0;
- * }
- *
- * function logger(sender: MyClass, value: number): void {
- *   console.log(sender.name, value);
- * }
- *
- * var m1 = new MyClass('foo');
- * var m2 = new MyClass('bar');
- *
- * m1.valueChanged.connect(logger);
- * m2.valueChanged.connect(logger);
- *
- * m1.value = 42;  // logs: foo 42
- * m2.value = 17;  // logs: bar 17
- * ```
- */
-var Signal = (function () {
-    function Signal() {
-    }
-    /**
-     * Bind the signal to a specific sender.
-     *
-     * @param sender - The sender object to bind to the signal.
-     *
-     * @returns The bound signal object which can be used for connecting,
-     *   disconnecting, and emitting the signal.
-     */
-    Signal.prototype.bind = function (sender) {
-        return new BoundSignal(this, sender);
-    };
-    return Signal;
-})();
-exports.Signal = Signal;
-/**
- * Remove all connections where the given object is the sender.
- *
- * @param sender - The sender object of interest.
- *
- * #### Example
- * ```typescript
- * disconnectSender(someObject);
- * ```
- */
-function disconnectSender(sender) {
-    var list = senderMap.get(sender);
-    if (!list) {
-        return;
-    }
-    var conn = list.first;
-    while (conn !== null) {
-        removeFromSendersList(conn);
-        conn.callback = null;
-        conn.thisArg = null;
-        conn = conn.nextReceiver;
-    }
-    senderMap.delete(sender);
-}
-exports.disconnectSender = disconnectSender;
-/**
- * Remove all connections where the given object is the receiver.
- *
- * @param receiver - The receiver object of interest.
- *
- * #### Notes
- * If a `thisArg` is provided when connecting a signal, that object
- * is considered the receiver. Otherwise, the `callback` is used as
- * the receiver.
- *
- * #### Example
- * ```typescript
- * // disconnect a regular object receiver
- * disconnectReceiver(myObject);
- *
- * // disconnect a plain callback receiver
- * disconnectReceiver(myCallback);
- * ```
- */
-function disconnectReceiver(receiver) {
-    var conn = receiverMap.get(receiver);
-    if (!conn) {
-        return;
-    }
-    while (conn !== null) {
-        var next = conn.nextSender;
-        conn.callback = null;
-        conn.thisArg = null;
-        conn.prevSender = null;
-        conn.nextSender = null;
-        conn = next;
-    }
-    receiverMap.delete(receiver);
-}
-exports.disconnectReceiver = disconnectReceiver;
-/**
- * Clear all signal data associated with the given object.
- *
- * @param obj - The object for which the signal data should be cleared.
- *
- * #### Notes
- * This removes all signal connections where the object is used as
- * either the sender or the receiver.
- *
- * #### Example
- * ```typescript
- * clearSignalData(someObject);
- * ```
- */
-function clearSignalData(obj) {
-    disconnectSender(obj);
-    disconnectReceiver(obj);
-}
-exports.clearSignalData = clearSignalData;
-/**
- * A concrete implementation of ISignal.
- */
-var BoundSignal = (function () {
-    /**
-     * Construct a new bound signal.
-     */
-    function BoundSignal(signal, sender) {
-        this._signal = signal;
-        this._sender = sender;
-    }
-    /**
-     * Connect a callback to the signal.
-     */
-    BoundSignal.prototype.connect = function (callback, thisArg) {
-        return connect(this._sender, this._signal, callback, thisArg);
-    };
-    /**
-     * Disconnect a callback from the signal.
-     */
-    BoundSignal.prototype.disconnect = function (callback, thisArg) {
-        return disconnect(this._sender, this._signal, callback, thisArg);
-    };
-    /**
-     * Emit the signal and invoke the connected callbacks.
-     */
-    BoundSignal.prototype.emit = function (args) {
-        emit(this._sender, this._signal, args);
-    };
-    return BoundSignal;
-})();
-/**
- * A struct which holds connection data.
- */
-var Connection = (function () {
-    function Connection() {
-        /**
-         * The signal for the connection.
-         */
-        this.signal = null;
-        /**
-         * The callback connected to the signal.
-         */
-        this.callback = null;
-        /**
-         * The `this` context for the callback.
-         */
-        this.thisArg = null;
-        /**
-         * The next connection in the singly linked receivers list.
-         */
-        this.nextReceiver = null;
-        /**
-         * The next connection in the doubly linked senders list.
-         */
-        this.nextSender = null;
-        /**
-         * The previous connection in the doubly linked senders list.
-         */
-        this.prevSender = null;
-    }
-    return Connection;
-})();
-/**
- * The list of receiver connections for a specific sender.
- */
-var ConnectionList = (function () {
-    function ConnectionList() {
-        /**
-         * The ref count for the list.
-         */
-        this.refs = 0;
-        /**
-         * The first connection in the list.
-         */
-        this.first = null;
-        /**
-         * The last connection in the list.
-         */
-        this.last = null;
-    }
-    return ConnectionList;
-})();
-/**
- * A mapping of sender object to its receiver connection list.
- */
-var senderMap = new WeakMap();
-/**
- * A mapping of receiver object to its sender connection list.
- */
-var receiverMap = new WeakMap();
-/**
- * Create a connection between a sender, signal, and callback.
- */
-function connect(sender, signal, callback, thisArg) {
-    // Coerce a `null` thisArg to `undefined`.
-    thisArg = thisArg || void 0;
-    // Search for an equivalent connection and bail if one exists.
-    var list = senderMap.get(sender);
-    if (list && findConnection(list, signal, callback, thisArg)) {
-        return false;
-    }
-    // Create a new connection.
-    var conn = new Connection();
-    conn.signal = signal;
-    conn.callback = callback;
-    conn.thisArg = thisArg;
-    // Add the connection to the receivers list.
-    if (!list) {
-        list = new ConnectionList();
-        list.first = conn;
-        list.last = conn;
-        senderMap.set(sender, list);
-    }
-    else if (list.last === null) {
-        list.first = conn;
-        list.last = conn;
-    }
-    else {
-        list.last.nextReceiver = conn;
-        list.last = conn;
-    }
-    // Add the connection to the senders list.
-    var receiver = thisArg || callback;
-    var head = receiverMap.get(receiver);
-    if (head) {
-        head.prevSender = conn;
-        conn.nextSender = head;
-    }
-    receiverMap.set(receiver, conn);
-    return true;
-}
-/**
- * Break the connection between a sender, signal, and callback.
- */
-function disconnect(sender, signal, callback, thisArg) {
-    // Coerce a `null` thisArg to `undefined`.
-    thisArg = thisArg || void 0;
-    // Search for an equivalent connection and bail if none exists.
-    var list = senderMap.get(sender);
-    if (!list) {
-        return false;
-    }
-    var conn = findConnection(list, signal, callback, thisArg);
-    if (!conn) {
-        return false;
-    }
-    // Remove the connection from the senders list. It will be removed
-    // from the receivers list the next time the signal is emitted.
-    removeFromSendersList(conn);
-    // Clear the connection data so it becomes a dead connection.
-    conn.callback = null;
-    conn.thisArg = null;
-    return true;
-}
-/**
- * Emit a signal and invoke the connected callbacks.
- */
-function emit(sender, signal, args) {
-    var list = senderMap.get(sender);
-    if (!list) {
-        return;
-    }
-    list.refs++;
-    try {
-        var dirty = invokeList(list, sender, signal, args);
-    }
-    finally {
-        list.refs--;
-    }
-    if (dirty && list.refs === 0) {
-        cleanList(list);
-    }
-}
-/**
- * Find a matching connection in the given connection list.
- *
- * Returns `null` if no matching connection is found.
- */
-function findConnection(list, signal, callback, thisArg) {
-    var conn = list.first;
-    while (conn !== null) {
-        if (conn.signal === signal &&
-            conn.callback === callback &&
-            conn.thisArg === thisArg) {
-            return conn;
-        }
-        conn = conn.nextReceiver;
-    }
-    return null;
-}
-/**
- * Invoke the callbacks for the matching signals in the list.
- *
- * Connections added during dispatch will not be invoked. This returns
- * `true` if there are dead connections in the list, `false` otherwise.
- */
-function invokeList(list, sender, signal, args) {
-    var dirty = false;
-    var last = list.last;
-    var conn = list.first;
-    while (conn !== null) {
-        if (!conn.callback) {
-            dirty = true;
-        }
-        else if (conn.signal === signal) {
-            conn.callback.call(conn.thisArg, sender, args);
-        }
-        if (conn === last) {
-            break;
-        }
-        conn = conn.nextReceiver;
-    }
-    return dirty;
-}
-/**
- * Remove the dead connections from the given connection list.
- */
-function cleanList(list) {
-    var prev;
-    var conn = list.first;
-    while (conn !== null) {
-        var next = conn.nextReceiver;
-        if (!conn.callback) {
-            conn.nextReceiver = null;
-        }
-        else if (!prev) {
-            list.first = conn;
-            prev = conn;
-        }
-        else {
-            prev.nextReceiver = conn;
-            prev = conn;
-        }
-        conn = next;
-    }
-    if (!prev) {
-        list.first = null;
-        list.last = null;
-    }
-    else {
-        prev.nextReceiver = null;
-        list.last = prev;
-    }
-}
-/**
- * Remove a connection from the doubly linked list of senders.
- */
-function removeFromSendersList(conn) {
-    var receiver = conn.thisArg || conn.callback;
-    var prev = conn.prevSender;
-    var next = conn.nextSender;
-    if (prev === null && next === null) {
-        receiverMap.delete(receiver);
-    }
-    else if (prev === null) {
-        receiverMap.set(receiver, next);
-        next.prevSender = null;
-    }
-    else if (next === null) {
-        prev.nextSender = null;
-    }
-    else {
-        prev.nextSender = next;
-        next.prevSender = prev;
-    }
-    conn.prevSender = null;
-    conn.nextSender = null;
-}
-
-},{}],7:[function(require,module,exports){
-var css = "/*-----------------------------------------------------------------------------\r\n| Copyright (c) 2014-2015, PhosphorJS Contributors\r\n|\r\n| Distributed under the terms of the BSD 3-Clause License.\r\n|\r\n| The full license is in the file LICENSE, distributed with this software.\r\n|----------------------------------------------------------------------------*/\n.p-Widget {\n  box-sizing: border-box;\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n  overflow: hidden;\n  cursor: default;\n}\n.p-Widget.p-mod-hidden {\n  display: none;\n}\n"; (require("browserify-css").createStyle(css, { "href": "node_modules/phosphor-widget/lib/index.css"})); module.exports = css;
-},{"browserify-css":3}],8:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-__export(require('./title'));
-__export(require('./widget'));
-require('./index.css');
-
-},{"./index.css":7,"./title":9,"./widget":10}],9:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-var phosphor_properties_1 = require('phosphor-properties');
-/**
- * An object which holds data related to a widget title.
- */
-var Title = (function () {
-    function Title() {
-    }
-    Object.defineProperty(Title.prototype, "text", {
-        /**
-         * Get the text for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[textProperty]].
-         */
-        get: function () {
-            return Title.textProperty.get(this);
-        },
-        /**
-         * Set the text for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[textProperty]].
-         */
-        set: function (value) {
-            Title.textProperty.set(this, value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Title.prototype, "icon", {
-        /**
-         * Get the icon class for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[iconProperty]].
-         */
-        get: function () {
-            return Title.iconProperty.get(this);
-        },
-        /**
-         * Set the icon class for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[iconProperty]].
-         */
-        set: function (value) {
-            Title.iconProperty.set(this, value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Title.prototype, "editable", {
-        /**
-         * Get the editable state for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[editableProperty]].
-         */
-        get: function () {
-            return Title.editableProperty.get(this);
-        },
-        /**
-         * Set the editable state for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[editableProperty]].
-         */
-        set: function (value) {
-            Title.editableProperty.set(this, value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Title.prototype, "editHandler", {
-        /**
-         * Get the edit handler for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[editHandlerProperty]].
-         */
-        get: function () {
-            return Title.editHandlerProperty.get(this);
-        },
-        /**
-         * Set the edit handler for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[editHandlerProperty]].
-         */
-        set: function (value) {
-            Title.editHandlerProperty.set(this, value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Title.prototype, "closable", {
-        /**
-         * Get the closable state for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[closableProperty]].
-         */
-        get: function () {
-            return Title.closableProperty.get(this);
-        },
-        /**
-         * Set the closable state for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[closableProperty]].
-         */
-        set: function (value) {
-            Title.closableProperty.set(this, value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Title.prototype, "className", {
-        /**
-         * Get the extra class name for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[classNameProperty]].
-         */
-        get: function () {
-            return Title.classNameProperty.get(this);
-        },
-        /**
-         * Set the extra class name for the title.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[classNameProperty]].
-         */
-        set: function (value) {
-            Title.classNameProperty.set(this, value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * The property descriptor for the title text.
-     *
-     * This will be used as the display text in title contexts.
-     *
-     * The default value is an empty string.
-     *
-     * **See also:** [[text]]
-     */
-    Title.textProperty = new phosphor_properties_1.Property({
-        value: '',
-    });
-    /**
-     * The property descriptor for the title icon class.
-     *
-     * This will be added to the class name of the title icon node.
-     *
-     * Multiple class names can be separated with whitespace.
-     *
-     * The default value is an empty string.
-     *
-     * **See also:** [[icon]]
-     */
-    Title.iconProperty = new phosphor_properties_1.Property({
-        value: '',
-    });
-    /**
-     * The property descriptor for the title editable state.
-     *
-     * This controls whether the title is editable by the user.
-     *
-     * The default value is `false`.
-     *
-     * **See also:** [[editable]]
-     */
-    Title.editableProperty = new phosphor_properties_1.Property({
-        value: false,
-    });
-    /**
-     * The property descriptor for the title edit handler.
-     *
-     * If the title is user editable, this handler will be invoked when
-     * the text is edited by the user. The handler should update its own
-     * internal state and then update the title text as appropriate. If
-     * this is not provided, the title text will be updated directly.
-     *
-     * The default value is `null`.
-     *
-     * **See also:** [[editHandler]]
-     */
-    Title.editHandlerProperty = new phosphor_properties_1.Property({
-        value: null,
-    });
-    /**
-     * The property descriptor for the title closable state.
-     *
-     * This controls whether the title area shows a close icon.
-     *
-     * The default value is `false`.
-     *
-     * **See also:** [[closable]]
-     */
-    Title.closableProperty = new phosphor_properties_1.Property({
-        value: false,
-    });
-    /**
-     * The property descriptor for the title extra class name.
-     *
-     * This will be added to the class name of the title area node.
-     *
-     * Multiple class names can be separated with whitespace.
-     *
-     * The default value is an empty string.
-     *
-     * **See also:** [[className]]
-     */
-    Title.classNameProperty = new phosphor_properties_1.Property({
-        value: '',
-    });
-    return Title;
-})();
-exports.Title = Title;
-
-},{"phosphor-properties":13}],10:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-var __extends = (this && this.__extends) || function (d, b) {
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-};
-var arrays = require('phosphor-arrays');
-var phosphor_messaging_1 = require('phosphor-messaging');
-var phosphor_nodewrapper_1 = require('phosphor-nodewrapper');
-var phosphor_properties_1 = require('phosphor-properties');
-var phosphor_signaling_1 = require('phosphor-signaling');
-var title_1 = require('./title');
-/**
- * The class name added to Widget instances.
- */
-var WIDGET_CLASS = 'p-Widget';
-/**
- * The class name added to hidden widgets.
- */
-var HIDDEN_CLASS = 'p-mod-hidden';
-/**
- * The base class of the Phosphor widget hierarchy.
- *
- * #### Notes
- * This class will typically be subclassed in order to create a useful
- * widget. However, it can be used by itself to host foreign content
- * such as a React or Bootstrap component. Simply instantiate an empty
- * widget and add the content directly to its `.node`. The widget and
- * its content can then be embedded within a Phosphor widget hierarchy.
- */
-var Widget = (function (_super) {
-    __extends(Widget, _super);
-    /**
-     * Construct a new widget.
-     */
-    function Widget() {
-        _super.call(this);
-        this._flags = 0;
-        this._parent = null;
-        this._children = [];
-        this.addClass(WIDGET_CLASS);
-    }
-    /**
-     * Attach a widget to a host DOM node.
-     *
-     * @param widget - The widget to attach to the DOM.
-     *
-     * @param host - The node to use as the widget's host.
-     *
-     * @throws Will throw an error if the widget is not a root widget,
-     *   if the widget is already attached to the DOM, or if the host
-     *   is not attached to the DOM.
-     *
-     * #### Notes
-     * The function should be used in lieu of manual DOM attachment. It
-     * ensures that an `'after-attach'` message is properly dispatched
-     * to the widget hierarchy.
-     */
-    Widget.attach = function (widget, host) {
-        if (widget.parent) {
-            throw new Error('only a root widget can be attached to the DOM');
-        }
-        if (widget.isAttached || document.body.contains(widget.node)) {
-            throw new Error('widget is already attached to the DOM');
-        }
-        if (!document.body.contains(host)) {
-            throw new Error('host is not attached to the DOM');
-        }
-        host.appendChild(widget.node);
-        phosphor_messaging_1.sendMessage(widget, Widget.MsgAfterAttach);
-    };
-    /**
-     * Detach a widget from its host DOM node.
-     *
-     * @param widget - The widget to detach from the DOM.
-     *
-     * @throws Will throw an error if the widget is not a root widget,
-     *   or if the widget is not attached to the DOM.
-     *
-     * #### Notes
-     * The function should be used in lieu of manual DOM detachment. It
-     * ensures that a `'before-detach'` message is properly dispatched
-     * to the widget hierarchy.
-     */
-    Widget.detach = function (widget) {
-        if (widget.parent) {
-            throw new Error('only a root widget can be detached from the DOM');
-        }
-        if (!widget.isAttached || !document.body.contains(widget.node)) {
-            throw new Error('widget is not attached to the DOM');
-        }
-        phosphor_messaging_1.sendMessage(widget, Widget.MsgBeforeDetach);
-        widget.node.parentNode.removeChild(widget.node);
-    };
-    /**
-     * Dispose of the widget and its descendant widgets.
-     *
-     * #### Notes
-     * It is generally unsafe to use the widget after it has been
-     * disposed.
-     *
-     * If this method is called more than once, all calls made after
-     * the first will be a no-op.
-     */
-    Widget.prototype.dispose = function () {
-        if (this.isDisposed) {
-            return;
-        }
-        this._flags |= WidgetFlag.IsDisposed;
-        this.disposed.emit(void 0);
-        if (this._parent) {
-            this._parent.removeChild(this);
-        }
-        else if (this.isAttached) {
-            Widget.detach(this);
-        }
-        while (this._children.length > 0) {
-            var child = this._children.pop();
-            child._parent = null;
-            child.dispose();
-        }
-        phosphor_signaling_1.clearSignalData(this);
-        phosphor_messaging_1.clearMessageData(this);
-        phosphor_properties_1.clearPropertyData(this);
-    };
-    Object.defineProperty(Widget.prototype, "disposed", {
-        /**
-         * A signal emitted when the widget is disposed.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[disposedSignal]].
-         */
-        get: function () {
-            return Widget.disposedSignal.bind(this);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "isAttached", {
-        /**
-         * Test whether the widget's node is attached to the DOM.
-         *
-         * #### Notes
-         * This is a read-only property which is always safe to access.
-         *
-         * **See also:** [[attach]], [[detach]]
-         */
-        get: function () {
-            return (this._flags & WidgetFlag.IsAttached) !== 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "isDisposed", {
-        /**
-         * Test whether the widget has been disposed.
-         *
-         * #### Notes
-         * This is a read-only property which is always safe to access.
-         *
-         * **See also:** [[disposed]]
-         */
-        get: function () {
-            return (this._flags & WidgetFlag.IsDisposed) !== 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "isVisible", {
-        /**
-         * Test whether the widget is visible.
-         *
-         * #### Notes
-         * A widget is visible when it is attached to the DOM, is not
-         * explicitly hidden, and has no explicitly hidden ancestors.
-         *
-         * This is a read-only property which is always safe to access.
-         *
-         * **See also:** [[hidden]]
-         */
-        get: function () {
-            return (this._flags & WidgetFlag.IsVisible) !== 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "hidden", {
-        /**
-         * Get whether the widget is explicitly hidden.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[hiddenProperty]].
-         *
-         * **See also:** [[isVisible]]
-         */
-        get: function () {
-            return Widget.hiddenProperty.get(this);
-        },
-        /**
-         * Set whether the widget is explicitly hidden.
-         *
-         * #### Notes
-         * This is a pure delegate to the [[hiddenProperty]].
-         *
-         * **See also:** [[isVisible]]
-         */
-        set: function (value) {
-            Widget.hiddenProperty.set(this, value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "title", {
-        /**
-         * Get the title data object for the widget.
-         *
-         * #### Notes
-         * The title data is used by some container widgets when displaying
-         * the widget along with a title, such as a tab panel or dock panel.
-         *
-         * Not all widgets will make use of the title data, so it is created
-         * on-demand the first time it is accessed.
-         */
-        get: function () {
-            return getTitle(this);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "parent", {
-        /**
-         * Get the parent of the widget.
-         *
-         * #### Notes
-         * This will be `null` if the widget does not have a parent.
-         */
-        get: function () {
-            return this._parent;
-        },
-        /**
-         * Set the parent of the widget.
-         *
-         * @throws Will throw an error if the widget is the parent.
-         *
-         * #### Notes
-         * If the specified parent is the current parent, this is a no-op.
-         *
-         * If the specified parent is `null`, this is equivalent to the
-         * expression `widget.parent.removeChild(widget)`, otherwise it
-         * is equivalent to the expression `parent.addChild(widget)`.
-         *
-         * **See also:** [[addChild]], [[insertChild]], [[removeChild]]
-         */
-        set: function (parent) {
-            if (parent && parent !== this._parent) {
-                parent.addChild(this);
-            }
-            else if (!parent && this._parent) {
-                this._parent.removeChild(this);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "children", {
-        /**
-         * Get a shallow copy of the array of child widgets.
-         *
-         * #### Notes
-         * When only iterating over the children, it can be faster to use
-         * the child query methods, which do not perform a copy.
-         *
-         * **See also:** [[childCount]], [[childAt]]
-         */
-        get: function () {
-            return this._children.slice();
-        },
-        /**
-         * Set the children of the widget.
-         *
-         * #### Notes
-         * This will clear the current child widgets and add the specified
-         * child widgets. Depending on the desired outcome, it can be more
-         * efficient to use one of the child manipulation methods.
-         *
-         * **See also:** [[addChild]], [[insertChild]], [[removeChild]]
-         */
-        set: function (children) {
-            var _this = this;
-            this.clearChildren();
-            children.forEach(function (child) { _this.addChild(child); });
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Widget.prototype, "childCount", {
-        /**
-         * Get the number of children of the widget.
-         *
-         * #### Notes
-         * This is a read-only property.
-         *
-         * **See also:** [[children]], [[childAt]]
-         */
-        get: function () {
-            return this._children.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Get the child widget at a specific index.
-     *
-     * @param index - The index of the child of interest.
-     *
-     * @returns The child widget at the specified index, or `undefined`
-     *  if the index is out of range.
-     *
-     * **See also:** [[childCount]], [[childIndex]]
-     */
-    Widget.prototype.childAt = function (index) {
-        return this._children[index | 0];
-    };
-    /**
-     * Get the index of a specific child widget.
-     *
-     * @param child - The child widget of interest.
-     *
-     * @returns The index of the specified child widget, or `-1` if
-     *   the widget is not a child of this widget.
-     *
-     * **See also:** [[childCount]], [[childAt]]
-     */
-    Widget.prototype.childIndex = function (child) {
-        return this._children.indexOf(child);
-    };
-    /**
-     * Add a child widget to the end of the widget's children.
-     *
-     * @param child - The child widget to add to this widget.
-     *
-     * @returns The new index of the child.
-     *
-     * @throws Will throw an error if a widget is added to itself.
-     *
-     * #### Notes
-     * The child will be automatically removed from its current parent
-     * before being added to this widget.
-     *
-     * **See also:** [[insertChild]], [[moveChild]]
-     */
-    Widget.prototype.addChild = function (child) {
-        return this.insertChild(this._children.length, child);
-    };
-    /**
-     * Insert a child widget at a specific index.
-     *
-     * @param index - The target index for the widget. This will be
-     *   clamped to the bounds of the children.
-     *
-     * @param child - The child widget to insert into the widget.
-     *
-     * @returns The new index of the child.
-     *
-     * @throws Will throw an error if a widget is inserted into itself.
-     *
-     * #### Notes
-     * The child will be automatically removed from its current parent
-     * before being added to this widget.
-     *
-     * **See also:** [[addChild]], [[moveChild]]
-     */
-    Widget.prototype.insertChild = function (index, child) {
-        if (child === this) {
-            throw new Error('invalid child widget');
-        }
-        if (child._parent) {
-            child._parent.removeChild(child);
-        }
-        else if (child.isAttached) {
-            Widget.detach(child);
-        }
-        child._parent = this;
-        var i = arrays.insert(this._children, index, child);
-        phosphor_messaging_1.sendMessage(this, new ChildMessage('child-added', child, -1, i));
-        return i;
-    };
-    /**
-     * Move a child widget from one index to another.
-     *
-     * @param fromIndex - The index of the child of interest.
-     *
-     * @param toIndex - The target index for the child.
-     *
-     * @returns 'true' if the child was moved, or `false` if either
-     *   of the given indices are out of range.
-     *
-     * #### Notes
-     * This method can be more efficient than re-inserting an existing
-     * child, as some widgets may be able to optimize child moves and
-     * avoid making unnecessary changes to the DOM.
-     *
-     * **See also:** [[addChild]], [[insertChild]]
-     */
-    Widget.prototype.moveChild = function (fromIndex, toIndex) {
-        var i = fromIndex | 0;
-        var j = toIndex | 0;
-        if (!arrays.move(this._children, i, j)) {
-            return false;
-        }
-        if (i !== j) {
-            var child = this._children[j];
-            phosphor_messaging_1.sendMessage(this, new ChildMessage('child-moved', child, i, j));
-        }
-        return true;
-    };
-    /**
-     * Remove the child widget at a specific index.
-     *
-     * @param index - The index of the child of interest.
-     *
-     * @returns The removed child widget, or `undefined` if the index
-     *   is out of range.
-     *
-     * **See also:** [[removeChild]], [[clearChildren]]
-     */
-    Widget.prototype.removeChildAt = function (index) {
-        var i = index | 0;
-        var child = arrays.removeAt(this._children, i);
-        if (child) {
-            child._parent = null;
-            phosphor_messaging_1.sendMessage(this, new ChildMessage('child-removed', child, i, -1));
-        }
-        return child;
-    };
-    /**
-     * Remove a specific child widget from this widget.
-     *
-     * @param child - The child widget of interest.
-     *
-     * @returns The index which the child occupied, or `-1` if the
-     *   child is not a child of this widget.
-     *
-     * **See also:** [[removeChildAt]], [[clearChildren]]
-     */
-    Widget.prototype.removeChild = function (child) {
-        var i = this.childIndex(child);
-        if (i !== -1)
-            this.removeChildAt(i);
-        return i;
-    };
-    /**
-     * Remove all child widgets from the widget.
-     *
-     * #### Notes
-     * This will continue to remove children until the `childCount`
-     * reaches zero. It is therefore possible to enter an infinite
-     * loop if a message handler causes a child widget to be added
-     * in response to one being removed.
-     *
-     * **See also:** [[removeChild]], [[removeChildAt]]
-     */
-    Widget.prototype.clearChildren = function () {
-        while (this.childCount > 0) {
-            this.removeChildAt(this.childCount - 1);
-        }
-    };
-    /**
-     * Dispatch an `'update-request'` message to the widget.
-     *
-     * @param immediate - Whether to dispatch the message immediately
-     *   (`true`) or in the future (`false`). The default is `false`.
-     *
-     * **See also:** [[MsgUpdateRequest]], [[onUpdateRequest]]
-     */
-    Widget.prototype.update = function (immediate) {
-        if (immediate === void 0) { immediate = false; }
-        if (immediate) {
-            phosphor_messaging_1.sendMessage(this, Widget.MsgUpdateRequest);
-        }
-        else {
-            phosphor_messaging_1.postMessage(this, Widget.MsgUpdateRequest);
-        }
-    };
-    /**
-     * Dispatch a `'close-request'` message to the widget.
-     *
-     * @param immediate - Whether to dispatch the message immediately
-     *   (`true`) or in the future (`false`). The default is `false`.
-     *
-     * **See also:** [[MsgCloseRequest]], [[onCloseRequest]]
-     */
-    Widget.prototype.close = function (immediate) {
-        if (immediate === void 0) { immediate = false; }
-        if (immediate) {
-            phosphor_messaging_1.sendMessage(this, Widget.MsgCloseRequest);
-        }
-        else {
-            phosphor_messaging_1.postMessage(this, Widget.MsgCloseRequest);
-        }
-    };
-    /**
-     * Process a message sent to the widget.
-     *
-     * @param msg - The message sent to the widget.
-     *
-     * #### Notes
-     * Subclasses may reimplement this method as needed.
-     */
-    Widget.prototype.processMessage = function (msg) {
-        switch (msg.type) {
-            case 'resize':
-                this.onResize(msg);
-                break;
-            case 'update-request':
-                this.onUpdateRequest(msg);
-                break;
-            case 'layout-request':
-                this.onLayoutRequest(msg);
-                break;
-            case 'child-added':
-                this.onChildAdded(msg);
-                break;
-            case 'child-removed':
-                this.onChildRemoved(msg);
-                break;
-            case 'child-moved':
-                this.onChildMoved(msg);
-                break;
-            case 'after-show':
-                this._flags |= WidgetFlag.IsVisible;
-                this.onAfterShow(msg);
-                sendToShown(this._children, msg);
-                break;
-            case 'before-hide':
-                this.onBeforeHide(msg);
-                sendToShown(this._children, msg);
-                this._flags &= ~WidgetFlag.IsVisible;
-                break;
-            case 'after-attach':
-                var visible = !this.hidden && (!this._parent || this._parent.isVisible);
-                if (visible)
-                    this._flags |= WidgetFlag.IsVisible;
-                this._flags |= WidgetFlag.IsAttached;
-                this.onAfterAttach(msg);
-                sendToAll(this._children, msg);
-                break;
-            case 'before-detach':
-                this.onBeforeDetach(msg);
-                sendToAll(this._children, msg);
-                this._flags &= ~WidgetFlag.IsVisible;
-                this._flags &= ~WidgetFlag.IsAttached;
-                break;
-            case 'child-shown':
-                this.onChildShown(msg);
-                break;
-            case 'child-hidden':
-                this.onChildHidden(msg);
-                break;
-            case 'close-request':
-                this.onCloseRequest(msg);
-                break;
-        }
-    };
-    /**
-     * Compress a message posted to the widget.
-     *
-     * @param msg - The message posted to the widget.
-     *
-     * @param pending - The queue of pending messages for the widget.
-     *
-     * @returns `true` if the message was compressed and should be
-     *   dropped, or `false` if the message should be enqueued for
-     *   delivery as normal.
-     *
-     * #### Notes
-     * The default implementation compresses the following messages:
-     * `'update-request'`, `'layout-request'`, and `'close-request'`.
-     *
-     * Subclasses may reimplement this method as needed.
-     */
-    Widget.prototype.compressMessage = function (msg, pending) {
-        switch (msg.type) {
-            case 'update-request':
-            case 'layout-request':
-            case 'close-request':
-                return pending.some(function (other) { return other.type === msg.type; });
-        }
-        return false;
-    };
-    /**
-     * A message handler invoked on a `'child-added'` message.
-     *
-     * #### Notes
-     * The default implementation adds the child node to the widget
-     * node at the proper location and dispatches an `'after-attach'`
-     * message if appropriate.
-     *
-     * Subclasses may reimplement this method to control how the child
-     * node is added, but they must dispatch an `'after-attach'` message
-     * if appropriate.
-     */
-    Widget.prototype.onChildAdded = function (msg) {
-        var next = this.childAt(msg.currentIndex + 1);
-        this.node.insertBefore(msg.child.node, next && next.node);
-        if (this.isAttached)
-            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgAfterAttach);
-    };
-    /**
-     * A message handler invoked on a `'child-removed'` message.
-     *
-     * #### Notes
-     * The default implementation removes the child node from the widget
-     * node and dispatches a `'before-detach'` message if appropriate.
-     *
-     * Subclasses may reimplement this method to control how the child
-     * node is removed, but they must  dispatch a `'before-detach'`
-     * message if appropriate.
-     */
-    Widget.prototype.onChildRemoved = function (msg) {
-        if (this.isAttached)
-            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgBeforeDetach);
-        this.node.removeChild(msg.child.node);
-    };
-    /**
-     * A message handler invoked on a `'child-moved'` message.
-     *
-     * #### Notes
-     * The default implementation moves the child node to the proper
-     * location in the widget node and dispatches a `'before-detach'`
-     * and `'after-attach'` message if appropriate.
-     *
-     * Subclasses may reimplement this method to control how the child
-     * node is moved, but they must dispatch a `'before-detach'` and
-     * `'after-attach'` message if appropriate.
-     */
-    Widget.prototype.onChildMoved = function (msg) {
-        if (this.isAttached)
-            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgBeforeDetach);
-        var next = this.childAt(msg.currentIndex + 1);
-        this.node.insertBefore(msg.child.node, next && next.node);
-        if (this.isAttached)
-            phosphor_messaging_1.sendMessage(msg.child, Widget.MsgAfterAttach);
-    };
-    /**
-     * A message handler invoked on a `'resize'` message.
-     *
-     * #### Notes
-     * The default implementation of this handler sends an [[UnknownSize]]
-     * resize message to each child. This ensures that the resize messages
-     * propagate through all widgets in the hierarchy.
-     *
-     * Subclasses may reimplement this method as needed, but they must
-     * dispatch `'resize'` messages to their children as appropriate.
-     */
-    Widget.prototype.onResize = function (msg) {
-        sendToAll(this._children, ResizeMessage.UnknownSize);
-    };
-    /**
-     * A message handler invoked on an `'update-request'` message.
-     *
-     * #### Notes
-     * The default implementation of this handler sends an [[UnknownSize]]
-     * resize message to each child. This ensures that the resize messages
-     * propagate through all widgets in the hierarchy.
-     *
-     * Subclass may reimplement this method as needed, but they should
-     * dispatch `'resize'` messages to their children as appropriate.
-     *
-     * **See also:** [[update]], [[MsgUpdateRequest]]
-     */
-    Widget.prototype.onUpdateRequest = function (msg) {
-        sendToAll(this._children, ResizeMessage.UnknownSize);
-    };
-    /**
-     * A message handler invoked on a `'close-request'` message.
-     *
-     * #### Notes
-     * The default implementation of this handler will unparent or detach
-     * the widget as appropriate. Subclasses may reimplement this handler
-     * for custom close behavior.
-     *
-     * **See also:** [[close]], [[MsgCloseRequest]]
-     */
-    Widget.prototype.onCloseRequest = function (msg) {
-        if (this._parent) {
-            this._parent.removeChild(this);
-        }
-        else if (this.isAttached) {
-            Widget.detach(this);
-        }
-    };
-    /**
-     * A message handler invoked on a `'layout-request'` message.
-     *
-     * The default implementation of this handler is a no-op.
-     *
-     * **See also:** [[MsgLayoutRequest]]
-     */
-    Widget.prototype.onLayoutRequest = function (msg) { };
-    /**
-     * A message handler invoked on an `'after-show'` message.
-     *
-     * The default implementation of this handler is a no-op.
-     *
-     * **See also:** [[MsgAfterShow]]
-     */
-    Widget.prototype.onAfterShow = function (msg) { };
-    /**
-     * A message handler invoked on a `'before-hide'` message.
-     *
-     * The default implementation of this handler is a no-op.
-     *
-     * **See also:** [[MsgBeforeHide]]
-     */
-    Widget.prototype.onBeforeHide = function (msg) { };
-    /**
-     * A message handler invoked on an `'after-attach'` message.
-     *
-     * The default implementation of this handler is a no-op.
-     *
-     * **See also:** [[MsgAfterAttach]]
-     */
-    Widget.prototype.onAfterAttach = function (msg) { };
-    /**
-     * A message handler invoked on a `'before-detach'` message.
-     *
-     * The default implementation of this handler is a no-op.
-     *
-     * **See also:** [[MsgBeforeDetach]]
-     */
-    Widget.prototype.onBeforeDetach = function (msg) { };
-    /**
-     * A message handler invoked on a `'child-shown'` message.
-     *
-     * The default implementation of this handler is a no-op.
-     */
-    Widget.prototype.onChildShown = function (msg) { };
-    /**
-     * A message handler invoked on a `'child-hidden'` message.
-     *
-     * The default implementation of this handler is a no-op.
-     */
-    Widget.prototype.onChildHidden = function (msg) { };
-    /**
-     * A singleton `'update-request'` message.
-     *
-     * #### Notes
-     * This message can be dispatched to supporting widgets in order to
-     * update their content. Not all widgets will respond to messages of
-     * this type.
-     *
-     * This message is typically used to update the position and size of
-     * a widget's children, or to update a widget's content to reflect the
-     * current state of the widget.
-     *
-     * Messages of this type are compressed by default.
-     *
-     * **See also:** [[update]], [[onUpdateRequest]]
-     */
-    Widget.MsgUpdateRequest = new phosphor_messaging_1.Message('update-request');
-    /**
-     * A singleton `'layout-request'` message.
-     *
-     * #### Notes
-     * This message can be dispatched to supporting widgets in order to
-     * update their layout. Not all widgets will respond to messages of
-     * this type.
-     *
-     * This message is typically used to update the size contraints of
-     * a widget and to update the position and size of its children.
-     *
-     * Messages of this type are compressed by default.
-     *
-     * **See also:** [[onLayoutRequest]]
-     */
-    Widget.MsgLayoutRequest = new phosphor_messaging_1.Message('layout-request');
-    /**
-     * A singleton `'close-request'` message.
-     *
-     * #### Notes
-     * This message should be dispatched to a widget when it should close
-     * and remove itself from the widget hierarchy.
-     *
-     * Messages of this type are compressed by default.
-     *
-     * **See also:** [[close]], [[onCloseRequest]]
-     */
-    Widget.MsgCloseRequest = new phosphor_messaging_1.Message('close-request');
-    /**
-     * A singleton `'after-show'` message.
-     *
-     * #### Notes
-     * This message is sent to a widget when it becomes visible.
-     *
-     * This message is **not** sent when the widget is attached.
-     *
-     * **See also:** [[isVisible]], [[onAfterShow]]
-     */
-    Widget.MsgAfterShow = new phosphor_messaging_1.Message('after-show');
-    /**
-     * A singleton `'before-hide'` message.
-     *
-     * #### Notes
-     * This message is sent to a widget when it becomes not-visible.
-     *
-     * This message is **not** sent when the widget is detached.
-     *
-     * **See also:** [[isVisible]], [[onBeforeHide]]
-     */
-    Widget.MsgBeforeHide = new phosphor_messaging_1.Message('before-hide');
-    /**
-     * A singleton `'after-attach'` message.
-     *
-     * #### Notes
-     * This message is sent to a widget after it is attached to the DOM.
-     *
-     * **See also:** [[isAttached]], [[onAfterAttach]]
-     */
-    Widget.MsgAfterAttach = new phosphor_messaging_1.Message('after-attach');
-    /**
-     * A singleton `'before-detach'` message.
-     *
-     * #### Notes
-     * This message is sent to a widget before it is detached from the DOM.
-     *
-     * **See also:** [[isAttached]], [[onBeforeDetach]]
-     */
-    Widget.MsgBeforeDetach = new phosphor_messaging_1.Message('before-detach');
-    /**
-     * A signal emitted when the widget is disposed.
-     *
-     * **See also:** [[disposed]], [[isDisposed]]
-     */
-    Widget.disposedSignal = new phosphor_signaling_1.Signal();
-    /**
-     * A property descriptor which controls the hidden state of a widget.
-     *
-     * #### Notes
-     * This property controls whether a widget is explicitly hidden.
-     *
-     * Hiding a widget will cause the widget and all of its descendants
-     * to become not-visible.
-     *
-     * This property will toggle the presence of `'p-mod-hidden'` on a
-     * widget. It will also dispatch `'after-show'` and `'before-hide'`
-     * messages as appropriate.
-     *
-     * The default property value is `false`.
-     *
-     * **See also:** [[hidden]], [[isVisible]]
-     */
-    Widget.hiddenProperty = new phosphor_properties_1.Property({
-        value: false,
-        changed: onHiddenChanged,
-    });
-    return Widget;
-})(phosphor_nodewrapper_1.NodeWrapper);
-exports.Widget = Widget;
-/**
- * A message class for child-related messages.
- */
-var ChildMessage = (function (_super) {
-    __extends(ChildMessage, _super);
-    /**
-     * Construct a new child message.
-     *
-     * @param type - The message type.
-     *
-     * @param child - The child widget for the message.
-     *
-     * @param previousIndex - The previous index of the child, if known.
-     *   The default index is `-1` and indicates an unknown index.
-     *
-     * @param currentIndex - The current index of the child, if known.
-     *   The default index is `-1` and indicates an unknown index.
-     */
-    function ChildMessage(type, child, previousIndex, currentIndex) {
-        if (previousIndex === void 0) { previousIndex = -1; }
-        if (currentIndex === void 0) { currentIndex = -1; }
-        _super.call(this, type);
-        this._child = child;
-        this._currentIndex = currentIndex;
-        this._previousIndex = previousIndex;
-    }
-    Object.defineProperty(ChildMessage.prototype, "child", {
-        /**
-         * The child widget for the message.
-         *
-         * #### Notes
-         * This is a read-only property.
-         */
-        get: function () {
-            return this._child;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ChildMessage.prototype, "currentIndex", {
-        /**
-         * The current index of the child.
-         *
-         * #### Notes
-         * This will be `-1` if the current index is unknown.
-         *
-         * This is a read-only property.
-         */
-        get: function () {
-            return this._currentIndex;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ChildMessage.prototype, "previousIndex", {
-        /**
-         * The previous index of the child.
-         *
-         * #### Notes
-         * This will be `-1` if the previous index is unknown.
-         *
-         * This is a read-only property.
-         */
-        get: function () {
-            return this._previousIndex;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return ChildMessage;
-})(phosphor_messaging_1.Message);
-exports.ChildMessage = ChildMessage;
-/**
- * A message class for `'resize'` messages.
- */
-var ResizeMessage = (function (_super) {
-    __extends(ResizeMessage, _super);
-    /**
-     * Construct a new resize message.
-     *
-     * @param width - The **offset width** of the widget, or `-1` if
-     *   the width is not known.
-     *
-     * @param height - The **offset height** of the widget, or `-1` if
-     *   the height is not known.
-     */
-    function ResizeMessage(width, height) {
-        _super.call(this, 'resize');
-        this._width = width;
-        this._height = height;
-    }
-    Object.defineProperty(ResizeMessage.prototype, "width", {
-        /**
-         * The offset width of the widget.
-         *
-         * #### Notes
-         * This will be `-1` if the width is unknown.
-         *
-         * This is a read-only property.
-         */
-        get: function () {
-            return this._width;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ResizeMessage.prototype, "height", {
-        /**
-         * The offset height of the widget.
-         *
-         * #### Notes
-         * This will be `-1` if the height is unknown.
-         *
-         * This is a read-only property.
-         */
-        get: function () {
-            return this._height;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * A singleton `'resize'` message with an unknown size.
-     */
-    ResizeMessage.UnknownSize = new ResizeMessage(-1, -1);
-    return ResizeMessage;
-})(phosphor_messaging_1.Message);
-exports.ResizeMessage = ResizeMessage;
-/**
- * An enum of widget bit flags.
- */
-var WidgetFlag;
-(function (WidgetFlag) {
-    /**
-     * The widget is attached to the DOM.
-     */
-    WidgetFlag[WidgetFlag["IsAttached"] = 1] = "IsAttached";
-    /**
-     * The widget is visible.
-     */
-    WidgetFlag[WidgetFlag["IsVisible"] = 2] = "IsVisible";
-    /**
-     * The widget has been disposed.
-     */
-    WidgetFlag[WidgetFlag["IsDisposed"] = 4] = "IsDisposed";
-})(WidgetFlag || (WidgetFlag = {}));
-/**
- * A private attached property for the title data for a widget.
- */
-var titleProperty = new phosphor_properties_1.Property({
-    create: function () { return new title_1.Title(); },
-});
-/**
- * Lookup the title data for the given widget.
- */
-function getTitle(widget) {
-    return titleProperty.get(widget);
-}
-/**
- * The change handler for the [[hiddenProperty]].
- */
-function onHiddenChanged(owner, old, hidden) {
-    if (hidden) {
-        if (owner.isAttached && (!owner.parent || owner.parent.isVisible)) {
-            phosphor_messaging_1.sendMessage(owner, Widget.MsgBeforeHide);
-        }
-        owner.addClass(HIDDEN_CLASS);
-        if (owner.parent) {
-            phosphor_messaging_1.sendMessage(owner.parent, new ChildMessage('child-hidden', owner));
-        }
-    }
-    else {
-        owner.removeClass(HIDDEN_CLASS);
-        if (owner.isAttached && (!owner.parent || owner.parent.isVisible)) {
-            phosphor_messaging_1.sendMessage(owner, Widget.MsgAfterShow);
-        }
-        if (owner.parent) {
-            phosphor_messaging_1.sendMessage(owner.parent, new ChildMessage('child-shown', owner));
-        }
-    }
-}
-/**
- * Send a message to all widgets in an array.
- */
-function sendToAll(widgets, msg) {
-    widgets.forEach(function (w) { phosphor_messaging_1.sendMessage(w, msg); });
-}
-/**
- * Send a message to all non-hidden widgets in an array.
- */
-function sendToShown(widgets, msg) {
-    widgets.forEach(function (w) { if (!w.hidden)
-        phosphor_messaging_1.sendMessage(w, msg); });
-}
-
-},{"./title":9,"phosphor-arrays":11,"phosphor-messaging":4,"phosphor-nodewrapper":12,"phosphor-properties":13,"phosphor-signaling":6}],11:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-/**
- * Execute a callback for each element in an array.
- *
- * @param array - The array of values to iterate.
- *
- * @param callback - The callback to invoke for the array elements.
- *
- * @param fromIndex - The starting index for iteration.
- *
- * @param wrap - Whether iteration wraps around at the end of the array.
- *
- * @returns The first value returned by `callback` which is not
- *   equal to `undefined`, or `undefined` if the callback does
- *   not return a value or if the start index is out of range.
- *
- * #### Notes
- * It is not safe to modify the size of the array while iterating.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function logger(value: number): void {
- *   console.log(value);
- * }
- *
- * var data = [1, 2, 3, 4];
- * arrays.forEach(data, logger);           // logs 1, 2, 3, 4
- * arrays.forEach(data, logger, 2);        // logs 3, 4
- * arrays.forEach(data, logger, 2, true);  // logs 3, 4, 1, 2
- * arrays.forEach(data, (v, i) => {        // 2
- *   if (v === 3) return i;
- * });
- * ```
- *
- * **See also** [[rforEach]]
- */
-function forEach(array, callback, fromIndex, wrap) {
-    if (fromIndex === void 0) { fromIndex = 0; }
-    if (wrap === void 0) { wrap = false; }
-    var start = fromIndex | 0;
-    if (start < 0 || start >= array.length) {
-        return void 0;
-    }
-    if (wrap) {
-        for (var i = 0, n = array.length; i < n; ++i) {
-            var j = (start + i) % n;
-            var result = callback(array[j], j);
-            if (result !== void 0)
-                return result;
-        }
-    }
-    else {
-        for (var i = start, n = array.length; i < n; ++i) {
-            var result = callback(array[i], i);
-            if (result !== void 0)
-                return result;
-        }
-    }
-    return void 0;
-}
-exports.forEach = forEach;
-/**
- * Execute a callback for each element in an array, in reverse.
- *
- * @param array - The array of values to iterate.
- *
- * @param callback - The callback to invoke for the array elements.
- *
- * @param fromIndex - The starting index for iteration.
- *
- * @param wrap - Whether iteration wraps around at the end of the array.
- *
- * @returns The first value returned by `callback` which is not
- *   equal to `undefined`, or `undefined` if the callback does
- *   not return a value or if the start index is out of range.
- *
- * #### Notes
- * It is not safe to modify the size of the array while iterating.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function logger(value: number): void {
- *   console.log(value);
- * }
- *
- * var data = [1, 2, 3, 4];
- * arrays.rforEach(data, logger);           // logs 4, 3, 2, 1
- * arrays.rforEach(data, logger, 2);        // logs 3, 2, 1
- * arrays.rforEach(data, logger, 2, true);  // logs 3, 2, 1, 4
- * arrays.rforEach(data, (v, i) => {        // 2
- *   if (v === 3) return i;
- * });
- * ```
- * **See also** [[forEach]]
- */
-function rforEach(array, callback, fromIndex, wrap) {
-    if (fromIndex === void 0) { fromIndex = array.length - 1; }
-    if (wrap === void 0) { wrap = false; }
-    var start = fromIndex | 0;
-    if (start < 0 || start >= array.length) {
-        return void 0;
-    }
-    if (wrap) {
-        for (var i = 0, n = array.length; i < n; ++i) {
-            var j = (start - i + n) % n;
-            var result = callback(array[j], j);
-            if (result !== void 0)
-                return result;
-        }
-    }
-    else {
-        for (var i = start; i >= 0; --i) {
-            var result = callback(array[i], i);
-            if (result !== void 0)
-                return result;
-        }
-    }
-    return void 0;
-}
-exports.rforEach = rforEach;
-/**
- * Find the index of the first value which matches a predicate.
- *
- * @param array - The array of values to be searched.
- *
- * @param pred - The predicate function to apply to the values.
- *
- * @param fromIndex - The starting index of the search.
- *
- * @param wrap - Whether the search wraps around at the end of the array.
- *
- * @returns The index of the first matching value, or `-1` if no value
- *   matches the predicate or if the start index is out of range.
- *
- * #### Notes
- * It is not safe to modify the size of the array while iterating.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function isEven(value: number): boolean {
- *   return value % 2 === 0;
- * }
- *
- * var data = [1, 2, 3, 4, 3, 2, 1];
- * arrays.findIndex(data, isEven);           // 1
- * arrays.findIndex(data, isEven, 4);        // 5
- * arrays.findIndex(data, isEven, 6);        // -1
- * arrays.findIndex(data, isEven, 6, true);  // 1
- * ```
- *
- * **See also** [[rfindIndex]].
- */
-function findIndex(array, pred, fromIndex, wrap) {
-    if (fromIndex === void 0) { fromIndex = 0; }
-    if (wrap === void 0) { wrap = false; }
-    var start = fromIndex | 0;
-    if (start < 0 || start >= array.length) {
-        return -1;
-    }
-    if (wrap) {
-        for (var i = 0, n = array.length; i < n; ++i) {
-            var j = (start + i) % n;
-            if (pred(array[j], j))
-                return j;
-        }
-    }
-    else {
-        for (var i = start, n = array.length; i < n; ++i) {
-            if (pred(array[i], i))
-                return i;
-        }
-    }
-    return -1;
-}
-exports.findIndex = findIndex;
-/**
- * Find the index of the last value which matches a predicate.
- *
- * @param array - The array of values to be searched.
- *
- * @param pred - The predicate function to apply to the values.
- *
- * @param fromIndex - The starting index of the search.
- *
- * @param wrap - Whether the search wraps around at the front of the array.
- *
- * @returns The index of the last matching value, or `-1` if no value
- *   matches the predicate or if the start index is out of range.
- *
- * #### Notes
- * It is not safe to modify the size of the array while iterating.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function isEven(value: number): boolean {
- *   return value % 2 === 0;
- * }
- *
- * var data = [1, 2, 3, 4, 3, 2, 1];
- * arrays.rfindIndex(data, isEven);           // 5
- * arrays.rfindIndex(data, isEven, 4);        // 3
- * arrays.rfindIndex(data, isEven, 0);        // -1
- * arrays.rfindIndex(data, isEven, 0, true);  // 5
- * ```
- *
- * **See also** [[findIndex]].
- */
-function rfindIndex(array, pred, fromIndex, wrap) {
-    if (fromIndex === void 0) { fromIndex = array.length - 1; }
-    if (wrap === void 0) { wrap = false; }
-    var start = fromIndex | 0;
-    if (start < 0 || start >= array.length) {
-        return -1;
-    }
-    if (wrap) {
-        for (var i = 0, n = array.length; i < n; ++i) {
-            var j = (start - i + n) % n;
-            if (pred(array[j], j))
-                return j;
-        }
-    }
-    else {
-        for (var i = start; i >= 0; --i) {
-            if (pred(array[i], i))
-                return i;
-        }
-    }
-    return -1;
-}
-exports.rfindIndex = rfindIndex;
-/**
- * Find the first value which matches a predicate.
- *
- * @param array - The array of values to be searched.
- *
- * @param pred - The predicate function to apply to the values.
- *
- * @param fromIndex - The starting index of the search.
- *
- * @param wrap - Whether the search wraps around at the end of the array.
- *
- * @returns The first matching value, or `undefined` if no value matches
- *   the predicate or if the start index is out of range.
- *
- * #### Notes
- * It is not safe to modify the size of the array while iterating.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function isEven(value: number): boolean {
- *   return value % 2 === 0;
- * }
- *
- * var data = [1, 2, 3, 4, 3, 2, 1];
- * arrays.find(data, isEven);           // 2
- * arrays.find(data, isEven, 4);        // 2
- * arrays.find(data, isEven, 6);        // undefined
- * arrays.find(data, isEven, 6, true);  // 2
- * ```
- *
- * **See also** [[rfind]].
- */
-function find(array, pred, fromIndex, wrap) {
-    var i = findIndex(array, pred, fromIndex, wrap);
-    return i !== -1 ? array[i] : void 0;
-}
-exports.find = find;
-/**
- * Find the last value which matches a predicate.
- *
- * @param array - The array of values to be searched.
- *
- * @param pred - The predicate function to apply to the values.
- *
- * @param fromIndex - The starting index of the search.
- *
- * @param wrap - Whether the search wraps around at the front of the array.
- *
- * @returns The last matching value, or `undefined` if no value matches
- *   the predicate or if the start index is out of range.
- *
- * #### Notes
- * The range of visited indices is set before the first invocation of
- * `pred`. It is not safe for `pred` to change the length of `array`.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function isEven(value: number): boolean {
- *   return value % 2 === 0;
- * }
- *
- * var data = [1, 2, 3, 4, 3, 2, 1];
- * arrays.rfind(data, isEven);           // 2
- * arrays.rfind(data, isEven, 4);        // 4
- * arrays.rfind(data, isEven, 0);        // undefined
- * arrays.rfind(data, isEven, 0, true);  // 2
- * ```
- *
- * **See also** [[find]].
- */
-function rfind(array, pred, fromIndex, wrap) {
-    var i = rfindIndex(array, pred, fromIndex, wrap);
-    return i !== -1 ? array[i] : void 0;
-}
-exports.rfind = rfind;
-/**
- * Insert an element into an array at a specified index.
- *
- * @param array - The array of values to modify.
- *
- * @param index - The index at which to insert the value. This value
- *   is clamped to the bounds of the array.
- *
- * @param value - The value to insert into the array.
- *
- * @returns The index at which the value was inserted.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * var data = [0, 1, 2, 3, 4];
- * arrays.insert(data, 0, 12);  // 0
- * arrays.insert(data, 3, 42);  // 3
- * arrays.insert(data, -9, 9);  // 0
- * arrays.insert(data, 12, 8);  // 8
- * console.log(data);           // [9, 12, 0, 1, 42, 2, 3, 4, 8]
- * ```
- *
- * **See also** [[removeAt]] and [[remove]]
- */
-function insert(array, index, value) {
-    var j = Math.max(0, Math.min(index | 0, array.length));
-    for (var i = array.length; i > j; --i) {
-        array[i] = array[i - 1];
-    }
-    array[j] = value;
-    return j;
-}
-exports.insert = insert;
-/**
- * Move an element in an array from one index to another.
- *
- * @param array - The array of values to modify.
- *
- * @param fromIndex - The index of the element to move.
- *
- * @param toIndex - The target index of the element.
- *
- * @returns `true` if the element was moved, or `false` if either
- *   index is out of range.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * var data = [0, 1, 2, 3, 4];
- * arrays.move(data, 1, 2);   // true
- * arrays.move(data, -1, 0);  // false
- * arrays.move(data, 4, 2);   // true
- * arrays.move(data, 10, 0);  // false
- * console.log(data);         // [0, 2, 4, 1, 3]
- * ```
- */
-function move(array, fromIndex, toIndex) {
-    var j = fromIndex | 0;
-    if (j < 0 || j >= array.length) {
-        return false;
-    }
-    var k = toIndex | 0;
-    if (k < 0 || k >= array.length) {
-        return false;
-    }
-    var value = array[j];
-    if (j > k) {
-        for (var i = j; i > k; --i) {
-            array[i] = array[i - 1];
-        }
-    }
-    else if (j < k) {
-        for (var i = j; i < k; ++i) {
-            array[i] = array[i + 1];
-        }
-    }
-    array[k] = value;
-    return true;
-}
-exports.move = move;
-/**
- * Remove an element from an array at a specified index.
- *
- * @param array - The array of values to modify.
- *
- * @param index - The index of the element to remove.
- *
- * @returns The removed value, or `undefined` if the index is out
- *   of range.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * var data = [0, 1, 2, 3, 4];
- * arrays.removeAt(data, 1);   // 1
- * arrays.removeAt(data, 3);   // 4
- * arrays.removeAt(data, 10);  // undefined
- * console.log(data);          // [0, 2, 3]
- * ```
- *
- * **See also** [[remove]] and [[insert]]
- */
-function removeAt(array, index) {
-    var j = index | 0;
-    if (j < 0 || j >= array.length) {
-        return void 0;
-    }
-    var value = array[j];
-    for (var i = j + 1, n = array.length; i < n; ++i) {
-        array[i - 1] = array[i];
-    }
-    array.length -= 1;
-    return value;
-}
-exports.removeAt = removeAt;
-/**
- * Remove the first occurrence of a value from an array.
- *
- * @param array - The array of values to modify.
- *
- * @param value - The value to remove from the array.
- *
- * @returns The index where the value was located, or `-1` if the
- *   value is not the array.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * var data = [0, 1, 2, 3, 4];
- * arrays.remove(data, 1);  // 1
- * arrays.remove(data, 3);  // 2
- * arrays.remove(data, 7);  // -1
- * console.log(data);       // [0, 2, 4]
- * ```
- *
- * **See also** [[removeAt]] and [[insert]]
- */
-function remove(array, value) {
-    var j = -1;
-    for (var i = 0, n = array.length; i < n; ++i) {
-        if (array[i] === value) {
-            j = i;
-            break;
-        }
-    }
-    if (j === -1) {
-        return -1;
-    }
-    for (var i = j + 1, n = array.length; i < n; ++i) {
-        array[i - 1] = array[i];
-    }
-    array.length -= 1;
-    return j;
-}
-exports.remove = remove;
-/**
- * Reverse an array in-place subject to an optional range.
- *
- * @param array - The array to reverse.
- *
- * @param fromIndex - The index of the first element of the range.
- *   This value will be clamped to the array bounds.
- *
- * @param toIndex - The index of the last element of the range.
- *   This value will be clamped to the array bounds.
- *
- * @returns A reference to the original array.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * var data = [0, 1, 2, 3, 4];
- * arrays.reverse(data, 1, 3);    // [0, 3, 2, 1, 4]
- * arrays.reverse(data, 3);       // [0, 3, 2, 4, 1]
- * arrays.reverse(data);          // [1, 4, 2, 3, 0]
- * ```
- *
- * **See also** [[rotate]]
- */
-function reverse(array, fromIndex, toIndex) {
-    if (fromIndex === void 0) { fromIndex = 0; }
-    if (toIndex === void 0) { toIndex = array.length; }
-    var i = Math.max(0, Math.min(fromIndex | 0, array.length - 1));
-    var j = Math.max(0, Math.min(toIndex | 0, array.length - 1));
-    if (j < i)
-        i = j + (j = i, 0);
-    while (i < j) {
-        var tmpval = array[i];
-        array[i++] = array[j];
-        array[j--] = tmpval;
-    }
-    return array;
-}
-exports.reverse = reverse;
-/**
- * Rotate the elements of an array by a positive or negative delta.
- *
- * @param array - The array to rotate.
- *
- * @param delta - The amount of rotation to apply to the elements. A
- *   positive delta will shift the elements to the left. A negative
- *   delta will shift the elements to the right.
- *
- * @returns A reference to the original array.
- *
- * #### Notes
- * This executes in `O(n)` time and `O(1)` space.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * var data = [0, 1, 2, 3, 4];
- * arrays.rotate(data, 2);    // [2, 3, 4, 0, 1]
- * arrays.rotate(data, -2);   // [0, 1, 2, 3, 4]
- * arrays.rotate(data, 10);   // [0, 1, 2, 3, 4]
- * arrays.rotate(data, 9);    // [4, 0, 1, 2, 3]
- * ```
- *
- * **See also** [[reverse]]
- */
-function rotate(array, delta) {
-    var n = array.length;
-    if (n <= 1) {
-        return array;
-    }
-    var d = delta | 0;
-    if (d > 0) {
-        d = d % n;
-    }
-    else if (d < 0) {
-        d = ((d % n) + n) % n;
-    }
-    if (d === 0) {
-        return array;
-    }
-    reverse(array, 0, d - 1);
-    reverse(array, d, n - 1);
-    reverse(array, 0, n - 1);
-    return array;
-}
-exports.rotate = rotate;
-/**
- * Using a binary search, find the index of the first element in an
- * array which compares `>=` to a value.
- *
- * @param array - The array of values to be searched. It must be sorted
- *   in ascending order.
- *
- * @param value - The value to locate in the array.
- *
- * @param cmp - The comparison function which returns `true` if an
- *   array element is less than the given value.
- *
- * @returns The index of the first element in `array` which compares
- *   `>=` to `value`, or `array.length` if there is no such element.
- *
- * #### Notes
- * It is not safe for the comparison function to modify the array.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function numberCmp(a: number, b: number): boolean {
- *   return a < b;
- * }
- *
- * var data = [0, 3, 4, 7, 7, 9];
- * arrays.lowerBound(data, 0, numberCmp);   // 0
- * arrays.lowerBound(data, 6, numberCmp);   // 3
- * arrays.lowerBound(data, 7, numberCmp);   // 3
- * arrays.lowerBound(data, -1, numberCmp);  // 0
- * arrays.lowerBound(data, 10, numberCmp);  // 6
- * ```
- *
- * **See also** [[upperBound]]
- */
-function lowerBound(array, value, cmp) {
-    var begin = 0;
-    var half;
-    var middle;
-    var n = array.length;
-    while (n > 0) {
-        half = n >> 1;
-        middle = begin + half;
-        if (cmp(array[middle], value)) {
-            begin = middle + 1;
-            n -= half + 1;
-        }
-        else {
-            n = half;
-        }
-    }
-    return begin;
-}
-exports.lowerBound = lowerBound;
-/**
- * Using a binary search, find the index of the first element in an
- * array which compares `>` than a value.
- *
- * @param array - The array of values to be searched. It must be sorted
- *   in ascending order.
- *
- * @param value - The value to locate in the array.
- *
- * @param cmp - The comparison function which returns `true` if the
- *   the given value is less than an array element.
- *
- * @returns The index of the first element in `array` which compares
- *   `>` than `value`, or `array.length` if there is no such element.
- *
- * #### Notes
- * It is not safe for the comparison function to modify the array.
- *
- * #### Example
- * ```typescript
- * import * as arrays from 'phosphor-arrays';
- *
- * function numberCmp(a: number, b: number): number {
- *   return a < b;
- * }
- *
- * var data = [0, 3, 4, 7, 7, 9];
- * arrays.upperBound(data, 0, numberCmp);   // 1
- * arrays.upperBound(data, 6, numberCmp);   // 3
- * arrays.upperBound(data, 7, numberCmp);   // 5
- * arrays.upperBound(data, -1, numberCmp);  // 0
- * arrays.upperBound(data, 10, numberCmp);  // 6
- * ```
- *
- * **See also** [[lowerBound]]
- */
-function upperBound(array, value, cmp) {
-    var begin = 0;
-    var half;
-    var middle;
-    var n = array.length;
-    while (n > 0) {
-        half = n >> 1;
-        middle = begin + half;
-        if (cmp(value, array[middle])) {
-            n = half;
-        }
-        else {
-            begin = middle + 1;
-            n -= half + 1;
-        }
-    }
-    return begin;
-}
-exports.upperBound = upperBound;
-
-},{}],12:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-/**
- * A base class for creating objects which wrap a DOM node.
- */
-var NodeWrapper = (function () {
-    function NodeWrapper() {
-        this._node = this.constructor.createNode();
-    }
-    /**
-     * Create the DOM node for a new node wrapper instance.
-     *
-     * @returns The DOM node to use with the node wrapper instance.
-     *
-     * #### Notes
-     * The default implementation creates an empty `<div>`.
-     *
-     * This may be reimplemented by a subclass to create a custom node.
-     */
-    NodeWrapper.createNode = function () {
-        return document.createElement('div');
-    };
-    Object.defineProperty(NodeWrapper.prototype, "node", {
-        /**
-         * Get the DOM node managed by the wrapper.
-         *
-         * #### Notes
-         * This property is read-only.
-         */
-        get: function () {
-            return this._node;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(NodeWrapper.prototype, "id", {
-        /**
-         * Get the id of the wrapper's DOM node.
-         */
-        get: function () {
-            return this._node.id;
-        },
-        /**
-         * Set the id of the wrapper's DOM node.
-         */
-        set: function (value) {
-            this._node.id = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Test whether the wrapper's DOM node has the given class name.
-     *
-     * @param name - The class name of interest.
-     *
-     * @returns `true` if the node has the class, `false` otherwise.
-     */
-    NodeWrapper.prototype.hasClass = function (name) {
-        return this._node.classList.contains(name);
-    };
-    /**
-     * Add a class name to the wrapper's DOM node.
-     *
-     * @param name - The class name to add to the node.
-     *
-     * #### Notes
-     * If the class name is already added to the node, this is a no-op.
-     */
-    NodeWrapper.prototype.addClass = function (name) {
-        this._node.classList.add(name);
-    };
-    /**
-     * Remove a class name from the wrapper's DOM node.
-     *
-     * @param name - The class name to remove from the node.
-     *
-     * #### Notes
-     * If the class name is not yet added to the node, this is a no-op.
-     */
-    NodeWrapper.prototype.removeClass = function (name) {
-        this._node.classList.remove(name);
-    };
-    /**
-     * Toggle a class name on the wrapper's DOM node.
-     *
-     * @param name - The class name to toggle on the node.
-     *
-     * @param force - Whether to force add the class (`true`) or force
-     *   remove the class (`false`). If not provided, the presence of
-     *   the class will be toggled from its current state.
-     *
-     * @returns `true` if the class is now present, `false` otherwise.
-     */
-    NodeWrapper.prototype.toggleClass = function (name, force) {
-        var present;
-        if (force === true) {
-            this.addClass(name);
-            present = true;
-        }
-        else if (force === false) {
-            this.removeClass(name);
-            present = false;
-        }
-        else if (this.hasClass(name)) {
-            this.removeClass(name);
-            present = false;
-        }
-        else {
-            this.addClass(name);
-            present = true;
-        }
-        return present;
-    };
-    return NodeWrapper;
-})();
-exports.NodeWrapper = NodeWrapper;
-
-},{}],13:[function(require,module,exports){
-/*-----------------------------------------------------------------------------
-| Copyright (c) 2014-2015, PhosphorJS Contributors
-|
-| Distributed under the terms of the BSD 3-Clause License.
-|
-| The full license is in the file LICENSE, distributed with this software.
-|----------------------------------------------------------------------------*/
-'use strict';
-var phosphor_signaling_1 = require('phosphor-signaling');
-/**
- * A property descriptor for a property on an object.
- *
- * Properties descriptors can be used to expose a rich interface for an
- * object which encapsulates value creation, coercion, and notification.
- * They can also be used to extend the state of an object with semantic
- * data from another class.
- *
- * #### Example
- * ```typescript
- * import { Property } from 'phosphor-properties';
- *
- * class MyClass {
- *
- *   static myValueProperty = new Property<MyClass, number>({
- *      value: 0,
- *      coerce: (owner, value) => Math.max(0, value),
- *      changed: (owner, oldValue, newValue) => { console.log(newValue); },
- *   });
- *
- *   get myValue(): number {
- *     return MyClass.myValueProperty.get(this);
- *   }
- *
- *   set myValue(value: number) {
- *     MyClass.myValueProperty.set(this, value);
- *   }
- * }
- * ```
- */
-var Property = (function () {
-    /**
-     * Construct a new property descriptor.
-     *
-     * @param options - The options for initializing the property.
-     */
-    function Property(options) {
-        if (options === void 0) { options = {}; }
-        this._pid = nextPID();
-        this._changedSignal = new phosphor_signaling_1.Signal();
-        this._value = options.value;
-        this._create = options.create;
-        this._coerce = options.coerce;
-        this._compare = options.compare;
-        this._changed = options.changed;
-        this._silent = !!options.silent;
-        this._metadata = options.metadata || {};
-    }
-    /**
-     * Get the bound changed signal for a given property owner.
-     *
-     * @param owner - The object to bind to the changed signal.
-     *
-     * @returns The bound changed signal for the owner.
-     *
-     * #### Notes
-     * This signal will be emitted whenever **any** property value for
-     * the specified owner is changed.
-     *
-     * This signal is emitted **after** the instance changed signal.
-     *
-     * This signal will not be emmited for properties marked as silent.
-     */
-    Property.getChanged = function (owner) {
-        return Property.changedSignal.bind(owner);
-    };
-    Object.defineProperty(Property.prototype, "metadata", {
-        /**
-         * Get the metadata for the property.
-         *
-         * #### Notes
-         * This is a read-only property.
-         */
-        get: function () {
-            return this._metadata;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Property.prototype, "changedSignal", {
-        /**
-         * A signal emitted when the property value changes.
-         *
-         * #### Notes
-         * This is an attached signal which will be emitted using the owner
-         * of the property value as the sender.
-         *
-         * **See Also:** [[getChanged]]
-         */
-        get: function () {
-            return this._changedSignal;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Get the bound changed signal for a given property owner.
-     *
-     * @param owner - The object to bind to the changed signal.
-     *
-     * @returns The bound changed signal for the owner.
-     *
-     * #### Notes
-     * This signal will be emitted whenever **this** property value
-     * for the specified owner is changed.
-     *
-     * This signal is emitted **before** the static changed signal.
-     *
-     * This signal will not be emmited for properties marked as silent.
-     */
-    Property.prototype.getChanged = function (owner) {
-        return this._changedSignal.bind(owner);
-    };
-    /**
-     * Get the current value of the property for a given owner.
-     *
-     * @param owner - The property owner of interest.
-     *
-     * @returns The current value of the property.
-     *
-     * #### Notes
-     * If the value has not yet been set, the default value will be
-     * computed and assigned as the current value of the property.
-     */
-    Property.prototype.get = function (owner) {
-        var value;
-        var hash = lookupHash(owner);
-        if (this._pid in hash) {
-            value = hash[this._pid];
-        }
-        else {
-            value = hash[this._pid] = this._createValue(owner);
-        }
-        return value;
-    };
-    /**
-     * Set the current value of the property for a given owner.
-     *
-     * @param owner - The property owner of interest.
-     *
-     * @param value - The value for the property.
-     *
-     * #### Notes
-     * If this operation causes the property value to change, the
-     * changed signals will be emitted with the owner as sender.
-     *
-     * If the value has not yet been set, the default value will be
-     * computed and used as the previous value for the comparison.
-     */
-    Property.prototype.set = function (owner, value) {
-        var oldValue;
-        var hash = lookupHash(owner);
-        if (this._pid in hash) {
-            oldValue = hash[this._pid];
-        }
-        else {
-            oldValue = hash[this._pid] = this._createValue(owner);
-        }
-        var newValue = this._coerceValue(owner, value);
-        this._maybeNotify(owner, oldValue, hash[this._pid] = newValue);
-    };
-    /**
-     * Explicitly coerce the current property value for a given owner.
-     *
-     * @param owner - The property owner of interest.
-     *
-     * #### Notes
-     * If this operation causes the property value to change, the
-     * changed signals will be emitted with the owner as sender.
-     *
-     * If the value has not yet been set, the default value will be
-     * computed and used as the previous value for the comparison.
-     */
-    Property.prototype.coerce = function (owner) {
-        var oldValue;
-        var hash = lookupHash(owner);
-        if (this._pid in hash) {
-            oldValue = hash[this._pid];
-        }
-        else {
-            oldValue = hash[this._pid] = this._createValue(owner);
-        }
-        var newValue = this._coerceValue(owner, oldValue);
-        this._maybeNotify(owner, oldValue, hash[this._pid] = newValue);
-    };
-    /**
-     * Get or create the default value for the given owner.
-     */
-    Property.prototype._createValue = function (owner) {
-        var create = this._create;
-        return create ? create(owner) : this._value;
-    };
-    /**
-     * Coerce the value for the given owner.
-     */
-    Property.prototype._coerceValue = function (owner, value) {
-        var coerce = this._coerce;
-        return coerce ? coerce(owner, value) : value;
-    };
-    /**
-     * Compare the old value and new value for equality.
-     */
-    Property.prototype._compareValue = function (oldValue, newValue) {
-        var compare = this._compare;
-        return compare ? compare(oldValue, newValue) : oldValue === newValue;
-    };
-    /**
-     * Run the change notification if the given values are different.
-     */
-    Property.prototype._maybeNotify = function (owner, oldValue, newValue) {
-        if (this._compareValue(oldValue, newValue)) {
-            return;
-        }
-        var changed = this._changed;
-        if (changed) {
-            changed(owner, oldValue, newValue);
-        }
-        if (this._silent) {
-            return;
-        }
-        var args = { property: this, oldValue: oldValue, newValue: newValue };
-        this.getChanged(owner).emit(args);
-        Property.getChanged(owner).emit(args);
-    };
-    /**
-     * A signal emitted when a property value changes.
-     *
-     * #### Notes
-     * This is an attached signal which will be emitted using the owner
-     * of the property value as the sender.
-     *
-     * **See Also:** [[getChanged]]
-     */
-    Property.changedSignal = new phosphor_signaling_1.Signal();
-    return Property;
-})();
-exports.Property = Property;
-/**
- * Clear the stored property data for the given property owner.
- *
- * @param owner - The property owner of interest.
- *
- * #### Notes
- * This will clear all property values for the owner, but it will
- * **not** emit any change notifications.
- */
-function clearPropertyData(owner) {
-    ownerData.delete(owner);
-}
-exports.clearPropertyData = clearPropertyData;
-/**
- * A weak mapping of property owner to property hash.
- */
-var ownerData = new WeakMap();
-/**
- * A function which computes successive unique property ids.
- */
-var nextPID = (function () { var id = 0; return function () { return 'pid-' + id++; }; })();
-/**
- * Lookup the data hash for the property owner.
- *
- * This will create the hash if one does not already exist.
- */
-function lookupHash(owner) {
-    var hash = ownerData.get(owner);
-    if (hash !== void 0)
-        return hash;
-    hash = Object.create(null);
-    ownerData.set(owner, hash);
-    return hash;
-}
-
-},{"phosphor-signaling":6}]},{},[1]);