From 59df602f6bdbf6f3b9cf79b5aadb8ed34725ce66 Mon Sep 17 00:00:00 2001
From: Rasika Perera <rasikaperera@Rasikas-MacBook-Pro.local>
Date: Sun, 26 Jul 2015 09:21:34 +0530
Subject: [PATCH] adding policy creation

---
 .../jaggeryapps/iotserver/modules/device.js   |    1 +
 .../jaggeryapps/iotserver/modules/policy.js   |    4 +
 .../units/policy-create/policy-create.hbs     |  191 +-
 .../policy-create/public/css/codemirror.css   |  344 +
 .../public/images/RaspberryPi.png             |  Bin 0 -> 8006 bytes
 .../policy-create/public/images/android.png   |  Bin 0 -> 6472 bytes
 .../public/images/arduino-thumb.png           |  Bin 0 -> 9862 bytes
 .../public/images/banner-img-3.png            |  Bin 0 -> 17519 bytes
 .../public/images/beagleBone.png              |  Bin 0 -> 10433 bytes
 .../public/images/digitaldisplay-thumb.png    |  Bin 0 -> 8161 bytes
 .../public/images/firealarm-thumb.png         |  Bin 0 -> 10339 bytes
 .../policy-create/public/images/intel.png     |  Bin 0 -> 5068 bytes
 .../units/policy-create/public/images/ios.png |  Bin 0 -> 3963 bytes
 .../public/images/sensebot-thumb.png          |  Bin 0 -> 15059 bytes
 .../policy-create/public/images/windows.png   |  Bin 0 -> 1696 bytes
 .../policy-create/public/js/codemirror.js     | 8722 +++++++++++++++++
 .../policy-create/public/js/policy-create.js  |   54 +-
 .../units/policy-create/public/js/sql.js      |  312 +
 .../policy-create/public/js/store-listing.js  |   74 +
 .../public/templates/store-listing.hbs        |   19 +
 .../store-listing/public/js/store-listing.js  |    1 +
 21 files changed, 9562 insertions(+), 160 deletions(-)
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/css/codemirror.css
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/RaspberryPi.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/android.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/arduino-thumb.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/banner-img-3.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/beagleBone.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/digitaldisplay-thumb.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/firealarm-thumb.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/intel.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/ios.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/sensebot-thumb.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/windows.png
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/codemirror.js
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/sql.js
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/store-listing.js
 create mode 100644 modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/templates/store-listing.hbs

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/modules/device.js b/modules/distribution/src/repository/jaggeryapps/iotserver/modules/device.js
index 935d4071..845c2ea2 100644
--- a/modules/distribution/src/repository/jaggeryapps/iotserver/modules/device.js
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/modules/device.js
@@ -147,6 +147,7 @@ deviceModule = function () {
             if (deviceUnit.isExists()) {
                 deviceTypeObject = {};
                 deviceTypeObject["name"] = deviceType.getName();
+                deviceTypeObject["id"] = deviceType.getId();
                 var storeProperties = privateMethods.getStoreDefinition(deviceType.getName());
                 if (storeProperties) {
                     deviceTypeObject["storeTitle"] = storeProperties.title;
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/modules/policy.js b/modules/distribution/src/repository/jaggeryapps/iotserver/modules/policy.js
index 0e7d3f1e..c7501239 100644
--- a/modules/distribution/src/repository/jaggeryapps/iotserver/modules/policy.js
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/modules/policy.js
@@ -26,6 +26,10 @@ policyModule = function () {
     var publicMethods = {};
     var privateMethods = {};
 
+    publicMethods.addPolicy = function (name, deviceType, policyDefinition) {
+
+    };
+
     publicMethods.getPolicies = function () {
 
         //TODO-This method returns includes dummy policy data
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/policy-create.hbs b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/policy-create.hbs
index f6a93084..b7fb40b0 100644
--- a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/policy-create.hbs
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/policy-create.hbs
@@ -1,21 +1,63 @@
+
 {{#zone "main"}}
+
+    <link rel="stylesheet" href="{{self.publicURL}}/css/codemirror.css"/>
+
+    <style>
+        .CodeMirror {
+            border-top: 1px solid #cccccc;
+            border-bottom: 1px solid black;
+        }
+    </style>
+
+
+    <script>
+        var init = function () {
+            var mime = MIME_TYPE_SIDDHI_QL;
+
+            // get mime type
+            if (window.location.href.indexOf('mime=') > -1) {
+                mime = window.location.href.substr(window.location.href.indexOf('mime=') + 5);
+            }
+
+            window.queryEditor = CodeMirror.fromTextArea(document.getElementById('policy-definition-input'), {
+                mode: mime,
+                indentWithTabs: true,
+                smartIndent: true,
+                lineNumbers: true,
+                matchBrackets: true,
+                autofocus: true,
+                extraKeys: {
+                    "Shift-2": function(cm) {
+                        insertStr(cm, cm.getCursor(), '@');
+                        CodeMirror.showHint(cm, getAnnotationHints);
+                    },
+                    "Ctrl-Space": "autocomplete"
+                }
+            });
+
+        };
+    </script>
+
+    <script type="text/javascript">
+        jQuery(document).ready(function () {
+            init();
+        });
+    </script>
+
     <div class="row">
         <div class="col-md-12">
             <div class="hidden wr-steps">
-                <div class="col-md-3 col-xs-3">
-                    <div class="itm-wiz itm-wiz-current" data-step="policy-platform"><div class="wiz-no">1</div><div class="wiz-lbl hidden-xs"><span>Select Platform</span></div></div>
+                <div class="col-md-3 col-xs-4">
+                    <div class="itm-wiz itm-wiz-current" data-step="policy-devicetype"><div class="wiz-no">1</div><div class="wiz-lbl hidden-xs"><span>Select Platform</span></div></div>
                     <br class="c-both" />
                 </div>
-                <div class="col-md-3 col-xs-3">
+                <div class="col-md-3 col-xs-4">
                     <div class="itm-wiz" data-step="policy-profile"><div class="wiz-no">2</div><div class="wiz-lbl hidden-xs"><span>Configure Profile</span></div></div>
                     <br class="c-both" />
                 </div>
-                <div class="col-md-3 col-xs-3">
-                    <div class="itm-wiz" data-step="policy-criteria"><div class="wiz-no">3</div><div class="wiz-lbl hidden-xs"><span>Assign to a group</span></div></div>
-                    <br class="c-both" />
-                </div>
-                <div class="col-md-3 col-xs-3">
-                    <div class="itm-wiz" data-step="policy-content"><div class="wiz-no">4</div><div class="wiz-lbl hidden-xs"><span>Publish</span></div></div>
+                <div class="col-md-3 col-xs-4">
+                    <div class="itm-wiz" data-step="policy-content"><div class="wiz-no">3</div><div class="wiz-lbl hidden-xs"><span>Publish</span></div></div>
                     <br class="c-both" />
                 </div>
             </div>
@@ -67,7 +109,7 @@
                                 </div>
                             </div>
                             <div class="wr-input-control wr-btn-grp">
-                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-content" data-back="true" data-next="policy-criteria">Back</a>
+                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-content" data-back="true" data-next="policy-profile">Back</a>
                                 <a href="#" class="wr-btn wizard-stepper" data-current="policy-content" data-next="policy-message">Save</a>
                             </div>
                         </div>
@@ -75,7 +117,7 @@
 
                 </div>
             </div>
-            <div class="container col-centered wr-content policy-criteria hidden">
+            <div class="container col-centered wr-content policy-profile hidden">
 
                 <div class="wr-form">
 
@@ -85,133 +127,43 @@
 
                     <div class="row">
                         <div class="col-lg-12">
-                            <div>
-                                <label class="wr-input-label" title="">
-                                    Set Device Ownership Type
-                                    <span class="wr-help-tip glyphicon glyphicon-question-sign"></span>
-                                </label>
-                                <div class="wr-input-control">
-                                    <div class="cus-col-50">
-                                        <select id="ownership-input" class="form-control">
-                                            <option>COPE</option>
-                                            <option>BYOD</option>
-                                        </select>
-                                    </div>
-                                    <br class="c-both" />
-                                </div>
-                                <div class="wr-input-control">
-                                    <label class="wr-input-control radio light" rel="assetfilter">
-                                        <input id="userRadio" type="radio" name="user-select" value="userSelectField" class="user-select-radio" />
-                                        <span class="helper">User</span>
-                                    </label>
-                                    <label class="wr-input-control radio light">
-                                        <input id="userRoleRadio" type="radio" name="user-select" value="userRoleSelectField" class="user-select-radio" />
-                                        <span class="helper">User Role</span>
-                                    </label>
-                                </div>
-
-                                <div id="userSelectField" class="user-select">
-                                    <label class="wr-input-label" title="">
-                                        Set User(s)
-                                        <span class="wr-help-tip glyphicon glyphicon-question-sign"></span>
-                                    </label>
-                                    <div class="wr-input-control">
-                                        <div class="cus-col-50">
-                                            <select id="users-input" class="form-control select2" multiple="multiple">
-                                                {{#each users}}
-                                                    <option>{{username}}</option>
-                                                {{/each}}
-                                            </select>
-                                        </div>
-                                        <br class="c-both" />
-                                    </div>
-                                </div>
-
-                                <div id="userRoleSelectField" class="user-select" style="display:none">
-                                    <label class="wr-input-label" title="">
-                                        Set User Role(s)
-                                        <span class="wr-help-tip glyphicon glyphicon-question-sign"></span>
-                                    </label>
-                                    <div class="wr-input-control">
-                                        <div class="cus-col-50">
-                                            <select id="user-roles-input"  class="form-control select2" multiple="multiple">
-                                                {{#each roles}}
-                                                    <option>{{this}}</option>
-                                                {{/each}}
-                                            </select>
-                                        </div>
-                                        <br class="c-both" />
-                                    </div>
-                                </div>
-
+                            <div class="wr-advance-operations">
                                 <label class="wr-input-label" title="">
-                                    Set Action upon Non-compliance
+                                    Set Policy Definition
                                     <span class="wr-help-tip glyphicon glyphicon-question-sign"></span>
                                 </label>
                                 <div class="wr-input-control">
-                                    <div class="cus-col-50">
-                                        <select id="action-input" class="form-control">
-                                            <option data-action="enforce">Enforce</option>
-                                            <option data-action="warn">Warn</option>
-                                            <option data-action="monitor">Monitor</option>
-                                        </select>
+                                    <div class="cus-col-100">
+                                        <textarea id="policy-definition-input" placeholder="Enter the policy" style="width: 100%;"></textarea>
                                     </div>
                                     <br class="c-both" />
                                 </div>
                             </div>
                             <div class="wr-input-control wr-btn-grp">
-                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-criteria" data-back="true" data-next="policy-profile">Back</a>
-                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-criteria" data-next="policy-content">Continue</a>
+                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-profile" data-back="true" data-next="policy-devicetype">Back</a>
+                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-profile" data-next="policy-content">Continue</a>
                             </div>
                         </div>
                     </div>
                 </div>
             </div>
-            <div class="container col-centered wr-content policy-profile hidden">
-
-                <div class="wr-form">
-
-                    <h1 class="page-sub-title">Add Policy</h1>
-
-                    <div class="row wr-wizard"></div>
-
-                    <div class="row">
-                        <div class="col-lg-12">
-                            <div class="wr-advance-operations">
-                                <label class="wr-input-label col-sm-4" for="maxFailedAttempts">Policy</label>
-                                <div class="wr-input-control">
-                                    <input type="text" class="form-control" id="policyDefinition" data-key="policyDefinition" placeholder="Enter the policy">
-                                </div>
-                            </div>
-                            <div class="wr-input-control wr-btn-grp">
-                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-profile" data-back="true" data-next="policy-platform">Back</a>
-                                <a href="#" class="wr-btn wizard-stepper" data-current="policy-profile" data-next="policy-criteria">Continue</a>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-            <div class="container col-centered wr-content policy-platform">
+            <div class="container col-centered wr-content policy-devicetype">
 
                 <div class="wr-form">
 
                     <h1 class="page-sub-title">Add Policy</h1>
 
                     <div class="row wr-wizard">
-                        <div class="col-md-3 col-xs-3">
-                            <div class="itm-wiz itm-wiz-current" data-step="policy-platform"><div class="wiz-no">1</div><div class="wiz-lbl hidden-xs"><span>Select Platform</span></div></div>
+                        <div class="col-md-4 col-xs-4">
+                            <div class="itm-wiz itm-wiz-current" data-step="policy-devicetype"><div class="wiz-no">1</div><div class="wiz-lbl hidden-xs"><span>Select Platform</span></div></div>
                             <br class="c-both" />
                         </div>
-                        <div class="col-md-3 col-xs-3">
+                        <div class="col-md-4 col-xs-4">
                             <div class="itm-wiz" data-step="policy-profile"><div class="wiz-no">2</div><div class="wiz-lbl hidden-xs"><span>Configure Profile</span></div></div>
                             <br class="c-both" />
                         </div>
-                        <div class="col-md-3 col-xs-3">
-                            <div class="itm-wiz" data-step="policy-criteria"><div class="wiz-no">3</div><div class="wiz-lbl hidden-xs"><span>Assign to a group</span></div></div>
-                            <br class="c-both" />
-                        </div>
-                        <div class="col-md-3 col-xs-3">
-                            <div class="itm-wiz" data-step="policy-content"><div class="wiz-no">4</div><div class="wiz-lbl hidden-xs"><span>Publish</span></div></div>
+                        <div class="col-md-4 col-xs-4">
+                            <div class="itm-wiz" data-step="policy-content"><div class="wiz-no">3</div><div class="wiz-lbl hidden-xs"><span>Publish</span></div></div>
                             <br class="c-both" />
                         </div>
                     </div>
@@ -220,11 +172,9 @@
                         <div class="col-lg-12">
                             <div class="row wr-tile-buttons-list">
                                 <div class="wr-input-control">
-                                    <ul class="tile-buttons row">
-                                        <li class="col-lg-4"><a href="#" class="wizard-stepper" data-current="policy-platform" data-next="policy-profile" data-platform="android" data-platform-id="1"><i class="fw fw-android"></i>Android</a></li>
-                                        <li class="col-lg-4"><a href="#" class="wizard-stepper" data-current="policy-platform" data-next="policy-profile" data-platform="ios" data-platform-id="2"><i class="fw fw-apple"></i>iOS</a></li>
-                                        <li class="col-lg-4"><a href="#" class="wizard-stepper" data-current="policy-platform" data-next="policy-profile" data-platform="windows" data-platform-id="3"><i class="fw fw-windows"></i>Windows</a></li>
-                                    </ul>
+                                    <div id="ast-container" class="ast-container">
+                                        {{! All "Device Types" registered in CDMF will be listed here. please refer: public/js/store-listing.js }}
+                                    </div>
                                 </div>
                             </div>
                         </div>
@@ -238,4 +188,9 @@
 {{/zone}}
 {{#zone "bottomJs"}}
     <script src="{{self.publicURL}}/js/policy-create.js"></script>
+    <script src="{{self.publicURL}}/js/codemirror.js"></script>
+    <script src="{{self.publicURL}}/js/sql.js"></script>
+
+        <script id="store-listing" src="{{self.publicURL}}/templates/store-listing.hbs" type="text/x-handlebars-template" ></script>
+        <script src="{{self.publicURL}}/js/store-listing.js"></script>
 {{/zone}}
\ No newline at end of file
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/css/codemirror.css b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/css/codemirror.css
new file mode 100644
index 00000000..47c6f0b0
--- /dev/null
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/css/codemirror.css
@@ -0,0 +1,344 @@
+/*Copyright (C) 2015 by Marijn Haverbeke <marijnh@gmail.com> and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.*/
+
+/* 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;
+    white-space: nowrap;
+    left: -30px;
+}
+
+.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;
+}
+.CodeMirror-sizer {
+    position: relative;
+    border-right: 30px solid transparent;
+}
+
+/* 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%;
+    display: inline-block;
+    /* 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;
+    left: -30px;
+}
+.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;
+}
+
+/* Force content-box sizing for the elements where we expect it */
+.CodeMirror-scroll,
+.CodeMirror-sizer,
+.CodeMirror-gutter,
+.CodeMirror-gutters,
+.CodeMirror-linenumber {
+    -moz-box-sizing: content-box;
+    box-sizing: content-box;
+}
+
+.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; }
\ No newline at end of file
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/RaspberryPi.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/RaspberryPi.png
new file mode 100644
index 0000000000000000000000000000000000000000..eb0e28cb26fd12e71a6645a8f35be731e2e268a1
GIT binary patch
literal 8006
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
B<vaiY

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/android.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/android.png
new file mode 100644
index 0000000000000000000000000000000000000000..d38a8d7567c9f8903b59311fe4460c8924d5b000
GIT binary patch
literal 6472
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

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/arduino-thumb.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/arduino-thumb.png
new file mode 100644
index 0000000000000000000000000000000000000000..31cb9fa364acb9e8684c981be706980a187a9c8a
GIT binary patch
literal 9862
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

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/banner-img-3.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/banner-img-3.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce6d43d3b5a604e8df6ecfa24d4c90d5861a076a
GIT binary patch
literal 17519
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
Iol`;+0G@z{cK`qY

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/beagleBone.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/beagleBone.png
new file mode 100644
index 0000000000000000000000000000000000000000..8bb45023fe81f46240cbd2531b4995a95ba42006
GIT binary patch
literal 10433
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

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/digitaldisplay-thumb.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/digitaldisplay-thumb.png
new file mode 100644
index 0000000000000000000000000000000000000000..fb1f624c3f308505d4b3c5e5b730526d10252665
GIT binary patch
literal 8161
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

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/firealarm-thumb.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/firealarm-thumb.png
new file mode 100644
index 0000000000000000000000000000000000000000..aaf16925fd6c0cb486fb0101cf4117969de7ddb6
GIT binary patch
literal 10339
zcmaKS1yCK`x+THgU4pwG+=EMSIJm>X;ouhB3GNo$A!u-S53a$3ySokleeb@RnwmRZ
z)xG!b`quhnuj<;>^+hNvN~0hWB0@kwpvcNdsD6wxAGbC<?8h_9!o>4qAaIe?a!~`D
zySN)WfgnW9z$PFvSvzA3kSfU7%+qlMBnSZkMPsF|<)Wn^&u<F0V=?~6hQ-6q;R6i;
zAt>VEU~Fmwav?JTSy<T%QJlARQIJ`g2~lWrDX=Lxh=VMxWW1a}YF>)!rd~Ftd}b6P
z!eoLT{2v5%AQxjY4?A0XXMPVMihuF)f6V`R%}PP`FB2CVA&UPBN=reROdRY4BI9D=
zW;SJG=Op9dV`1mw=HcUEA_IJ^S=o450c^}{eEeJ-{A>WS|Gp?byg8Yf^Q%fo{kN}=
zl@Nuci;Dw4E33P^JBvF93)snmm7R}|kChF;3IH&FSTH+#+PfHgFxxv*{+mGp<ZS9>
z<=|okwkP|C(bxp+>LNt(5$S)WVCV2ZwD!*bU8awMv3eLgu(GqT{gcwa4HXpr|E6|!
z|6}d!q6+%o@%}%Foz*=ZK&+}DXRxc2>Bq*IQ~u-1fnVGSWb6WVQU`-=|6N68ORx*r
z*%ItPCNBQ3s*%xYTG^X{-JR+Gg;7x8m$i3xF}61a$w~-Oe6X-sS()*30=OmE`Pg{b
z*Z|_}?2=q!+){j^JOFV~Ne(G)UP<wPV<o_*u67`Mmw#i;{x_EIKVtupgPp^NX9<v#
zl^e)R$_Z>o_OG=0t^RW?-2aj9zp-ZjIToJ(h-Li<hV`G#{XaJQ->*It^w0Evr2Db>
zAMu0iKNRouA?*gricJUzs##eHQFV_$C*BAi`k;opwlI#IL{G(xV%bc^sffIB?9yCb
z2tc@p=+<K3CR10c;qK8Z%%u}6D&5lqQa%}g9-ab{f*D4Ke+rks#4e*)A;XiG?|Qk<
zXR%3%pALwPe*R8Hm_W0C($RHWd0Ta_Z{stqw>Z#06fbgvfF+M_+4}_xHiK;{IDiJ3
z(>NCaO2Jzm|KR+AZDS-8Y_oz(d~#m>XRWr4KDj9<W^dLx=G5I=xTCnSv81*x|GJP*
z+Py1rvh<a*L2J>*hB5Tsg%icyl?&PJ)JEp!USogzvbuOsik+V`+!he@(~dHGEPsP*
zYCl#GG$1Ffta&<aZ@1?C6lj`4D&lu`WTmF-{Jw!-`fVlU!eO#AwD#2pn4TAaD3Iwn
zSN)8E9JYxTY9zodzZg1MXH<eUH59sqd`mvR7WQ^#?}CD2y1j(2G2^kqB{Kd;mS}=+
zE7*cX`1z-yp~u!h#rqJU<$gtV3bOr%AfvdF<Ln_E7h#WliBU;HZv5uXm4hB!tFhSi
zbAU3u4llA0eyGjG#&Dl>P>2*(IO;9s@>+;y>z&Et6#iS9>(uGBEAh9RmxlM_zhBQ<
z%|{YS-iGikhyDP$)>v8elfWBmKa13Oj{7=lV4n_22>iF8ybw8kUG<t@f{odLGF4N#
zv&yI_Mbf5hV+=;>8r{+TM%SRuTIlbvUKq#cy;a%vFUD*^Vb`eq*W4(sCx2oM-L}>=
zSzGQ#{B)pP?X`4k_YY~;Q}vp>@-Rp{rAV&@Vfc_TB*DgX(+vI<@;zV@UczW9k<C~x
z_LMz3(-zK*ZLDg<UM7YhZ8fBhI^rskZks*yvr{owceFd?+rORhRA&lDHMS+&K^CmO
zJ4iWi<M)cfxAhZ#3{aIXXO*eQBF`)LL?aJf_%X0l3132ucXS-M5*71F1{pX-ItKUE
z1|iR@Fa5m9Ntmhy$9EUK6+7K?r?vPy5C;a>td9<W$x~3A>im&Lns7(qYOJ)F59WX{
zg+6Wh@-nZ>UpcLNF|59ChNK=tDD}>V=N6})2iaqlmAd9I#II1O?1OT&dCtZ$dV20a
zI?=Ttr1=AqR;hC~Bd2L8D&*+wzt$Q1vi(%j$mX-h08cH>gk(jiK;8CyqNr{|4aMB5
zkiqIIStX*+lE1U{hX>#;Pp6sAh{hp(3${liS)2DuMBbJc*V&;eA18RK@O|&foX5BF
z#=bN)g=5%fBV8XN+H#%MRS|Gvb_{M#9+0z$D~9N=hh|OoY@LrQ<C{BTbOe4bip)d4
z1#-B6^uiYF6CIm5I}>I4Fa<CRUVzCL5qT7n&~MO?-vm@RIQ^f8>K>Y^*sGWp9VgN)
z1f7RYMcS*1S_YoN2udx6_AFOoyRKVyGH__&u$JBTrG~H@AIceWHPy+LdzI<FcZW+I
zGQ&VQ_CQYAb0cNum0<Xt)N)?+QPxOHZ$(`svQDQz`P^Wpk{?{yxiEEZsITvuN0`c*
z_n1Ly&<x-`8>MJ;YbsG*R(xNW5K3EZ!ka8%X0jp;RFD^Vdw@Y(dn_O|^tn-SmR@&*
zIwhaBX*(?@YWSTgynRJ(2U(i~L6{+o6Y$5HCC(~?ykPoPpD<KZbZ+aG+EaE3U5OKt
z<H{3e95=d{dbTDkEbizqgo8~^z&v->--}7^B%-vYen1sjWGeHA8RmlJ4>ZLebq~(=
z61k0^&4FBcInnYKJUXrSCIzOOb$0s0ge-fL>5n^5T^<jA7Y;epz?lL3hPsB0w<)X}
zKfxPr(YQ)w>UP{sWZV{wh!{i3Ow|62HjCId_z5|7Xqt1lUsIeq#)}ZnWN5a}sXHPu
z^u1(!9nf3OUWZX)hJomGtmfQEjQ)7*{XE@!=S+lhKW0bc)t@0R=I47YZT+{9DCQSJ
zQ{L>`t)U%8Y_e9F@MxKTyl19r{A}B_<CyxTspmn&UG*5)+@eT<mm!3er_Es$-ozHI
z+ZznpKO}Fh`1TT-ZBjHd`UUpA@{GCy(^hqSh`N}UAqjafsn3Q0+9CRdMm%=Z?L@-Y
zGO0`$HYhVUUR~}W;HM7q0pc{a^YuC|t4T^S`I4YQ$o+6@>a-lIpD@^Dq)OQSOXIeX
zMNaL>$cBjfuC9G9DChY>(|IhL4=$pgK2#)dnBDo2Ozq&4%cFdZ)v`wJQFuJQo2NPM
zo|TCttUW_P6m@gHy^P+>p|)3eo))f}fc=9wL!xMVT$j5ivoUOMG^U+E+<GliaWFV|
z2^W>lbYJT4O@5Lb^o25FV=^$E#d~i0%T(;n5im`G&(}h(k4O5z$7hXX(V%UI)_wJI
z8{7$k)lrDyaJeU0Odr{?B5Y7|IU|11$!K;k34>r{@5LxMITwx5?l11?x2&5DJ=AR8
z#%-4j$=EJEpZ~3(CX4dPq9ARMfte;0MtzSE&QjaYdKTC0UUiNG`_@0_hO9IysRSA0
zJYIrK6I&yGY}WL#bty2!JB7-L$Y7v84$W{3_5waYsKZrv$mf3TdU}kd&HFKvdnyJm
zmFx6nrsV7b#U-ag%_ww#Jj722>xwgcWG!i&vk}DTBqZbwI727>EWdcwozJl9xcBoQ
zuE0UMGfbA{w*w%()i$)mjN3Cvmhw>s)(2Fi$F!04m2t|QpgdxcyRXR7HP{GH<9!o%
zd9vsAbIkPMMN@e47=|Kz!qDILUN~65eVWnd!Mgdg4MB#YlJqwQyN33|K<z~(-wUf>
ze(x=frW8}F{Yg3l$O&Sl?Zl4{bfKwT;oi>%UWj~32#@fWltXZeYVNyN+A{^j$x@%S
z0o%kVNwnR2_)=mJ1G9C=;sI`yI?#qz2%L4><9DYrcIz?*$yD3Lf0T+WwMgP+QTplB
zJR|T~C%-M-aHh2;uyYI1vl{=lAu>C+XNZ}*tK{^+k;(^^Qq4bXD)SKP62?y~JxSu_
zym#>Iie{d5IbXhIcHW)0|B*FUKoN5`FRdq{qZchNfV$)&GJ>XKG8F|SwaY+{^uNT~
z4BKNWTjA46uP2T%VA4DF=DHJn3PtUc<0)%smTuisq0Wk=hMrcd3$8(qda{-vqUjmY
z@y?2d21%NO(Ox){+Iui~ifCaNMjr{iFj469tkk@AMpB6hd6xc^XA88MA`w1z>SFYf
zMpjJU&LEMDWgB`89+og4J+vX;tcF;uo>m#Yvoq@jUrcl0bnpx-U=s0AHh_q{ZzwX^
zv&P~sFn(SqboA57?|MR(l8}n|Khf){O)hHml2Q&j+~T_P2`t5~zOk4+J=2Y(VT{?#
zi@ACQ4u%k67xg;-%rhQ-rR31X=4cxHE7NoufI}J(%Ue(<EW|1JjSw=CrsBw-agbKc
z9X5=;(O#&7H+E`V!-zMgF5dWrs%B%I7wx#Q{d?IhP|42Q_4wP{Uc&LhH@`-@CaW<f
zZRO_1P>NdE&IEiZjcRf06*uUk<B(tEL;9nLP17y|w!iwI52r<wNL-Oe@eHH?n#Sx0
z@g$BXV{kxPU*dL*7N`Aob)~Gm#i3eg4}SPM*>_4JRZ}dQEYN*1ClA;?vewc&ICx?X
zXW>QcsgrAN(53<)h@}*L(W{|tu%bmL_f6KM`<^HH!uC}TW5jV=quPId7VcL*rcgm2
zZxvM(jL+$k`y8>Ym+x}a(C2Tq>z?~rO<UlrTu^G)eaz}tRs$RCRPuHsVX<3R8QVWm
z55<-6bLwhxe8Z}Kj<Fpt{b6#L@CB~XmMv#q>YeW<UV1qCdQmb9jAm7F11@KEG<so3
z2}yP;NiiLFfG5&cIH=f-SO`3lQoB9iwVcg?FX;(JDAHw_<r@?JZjp@rs^Z|PtkN}O
z#NPx?*z$68A-7L`D`qL%lU7C}H3j`6<5g?$@;MU@lN3@5ofb?Xq@2HpTJ5Th&ywi7
zydHPC@VboS);nHe)zpZ1NT`j_e=_a&Eg0GEv#^*T1$x7?ONC}IOroP#CKq|hH=Tc(
z{k9&v?fc4^k*XI4APnO}^)=6f5M5?1OZV7H#GYhxvedJv!6Puy?rcIEa8{I>trY1=
zB7H?vRAa=emt}Vtk;~Xb>sUmFV{bp>G7FOmXZ-ygng51!U?u(T7ZjAt*{Q1FTmx|$
zGFKTsbcxdTJ^4D=e-PCq>BUsI;qT7?7WKx7{&JvA>{^Yn&oUAB)Kugc?qNjyY<Jo{
z0s%2e9uk-$yWfa|tK^pzP?|=yyVycY|J1VM%sI_@5{#bt=ey4iNv!u4q2SZ9&Gg+%
zq728`uXd^WDp=}hF1l>JeOXNN3^t)T>Fr&ww#}16iQV*lqdnG~(D%Stvf6L792mFR
zg-#>#oCzZM5+<iMatpyaC1T$h#Q3TE^>bouzX`am)tH=Afv|`olw9ZG<?X*zRV&qc
zbmU`?`=#NXOSh;q6ucF;op)YugO|Qg9&2Qma=3~2N}EXH``8tzZlHEGrDedx;T-OY
zgG#e?tJ_g4d3@kZU%hLBqg@Qq7S?V}ksHr@H}9CW-d=StR{eZ&l>A=5Ht)||*Iqqu
zNJafs4L9?yiES&V9IUxz=e!bF!T3uv-u!AGT>T~}b?@FCP3y^O58I;buiAT)8D6c2
zMB33k8P|B_IS__?Mah#)_HZwT7pDm7V4&`xVFLlq#UbS!79+n;^&RM=BN?fBLr^QI
zU5=CH2=Aj1Se}nD9-XWS6kETsy(H3-ces;AXo#qJva6L#+9zHE;IwT6)6~8_naDpb
zpv4i&F<`<m?AvvDLVRM5aw=XAS@cC<aj*ZG4_hG6Xmb92*W>a|_j2aGOZK9=uiz_7
z&*X$KRIJZaK@C2psJ&Q~AH=4Rh2N`g_{HnUYa4;N`a=?_wmDNGe&MY1c4i|6S_Qs=
zanU2TLLpD_o!S8anM)Ix(u_d}iE<0i%}vqPl}XfNtF00MsLBJ`V!tV4z&^u`W&8PR
z&l++mI}Pm>{D^<B^3p~q<WIA;p*2OVxRMm!w_?fbO_w0fOE8gtZPHEl9>q|4pcu#=
zE1BH-%ZOfTE@i^I=b3fXf~4Ye<Nf31k?5ifC{Xjb^;~ml@s37mx1!>=%3hlN>kGRT
zd9o_aNQqSZ#$r%9&non(xTcBABx+i}@JPApr#O@JH4*4<mhi&9tY>sY(ma95GUO`_
zhROESrcc8sA=wXvN4e}LC!C+M>M0f1xFdUT$s?P_yW8;$^?d()Bv9T_30wt^qCHj_
z7_e2yWR<#L<ku0QlFn?M6N=n82JcTwyD7mTeC9)7rXCd@&BViK6Mm@F#b99-Rb>mG
z6UiJVTW^5NvN7<_X<K?6{mN!}v#!4~?J>9<o(v>ob+rYy(^AHAJflRJ{8{WovUwAW
zI<=x*9tR-JXhKq@?Wz>EwW$|l&Xn<@N1GuQW5msh2SG$rM+qtcNelNM<;D*4FflOt
z#Z~GrJdZg{Ylf!{w7aagJ|b_es8}zwtx2@fTJ@BzRh`46VWj^PPlzgMU0Q`WzppQm
z`U^;-mOHG(QEHr<r5f-=J8+Wn-ML2_l7W<8g1**b08!9scYycMuq)K_y$)KE!(!WK
zqm_i*FUf;57n*J}ImW}e@adZ}VNBke-$oQWixlop>)9J<4nj3*tVnXEU7ez_;Fzz{
z63DYW5Rqiy=$M|OEmw0PQuc8Y0w74RGM^AAjHOV>&}oF<CUDRF284<~0OG4!$34s|
z06E-*NLUy|eNqWdL<b@w(J2Vz@6Ya`OD}Lb7bw^UX_Q2_^WEvQs3<tuSF4}&goq49
zuX_`xn=jNuEz<u$$3y&z6~V<((>Y)-7#+?Sg}Bg>NP;ybX;bz)I)vAEAV_F$l8Q^o
zPY<pqpvIQzkd-MIMw=H^4MA%Tat!66R^%^9YhcJr!uU!(t~%$L3_@HYl93!vV-o~u
z+{_@ca(<rv;$xRtplDJk!F67!+s#?c?}n*UzMboNO7JGoxCwnAs_&TLm`{%sd4Aq^
z;w%!*0e)dcc0bo7|Mjr9qRj7u%V04fef&r&cHAcHk8=M8jl0q0zKpo)vqoEc7y*Y7
zpK!?gZN9#@&q}TppHem{$DJ=>VD}=HdNY~1B_hus5{%&25D<c!(3g~>6jg>y7bTE0
z!XRp+`c%3H5pB)ZKQm1>T8T|jHOJC0`$ynUW-J}oi9~xixE<cRpeHRQAq2~P4#hUY
zIW)m;7oCYg%63o10bnpG7t-GxfAE*jnnXI8i+DiK;)jp0s{H<t{<T#@Y26^MdX8J`
zUsl@n3rX8=PkfS)x)Z)4^(t%E8uv!B8kC=-<7t7vg<xNIWG}<c19Hli@p2`pPQ*kl
zN0RQnJW&;(YhzWz31ZXd4Yjvi)nx>Wf+#YS1Xp&v0LYcCM(_izLH6q{B^G|aF;I5)
z?A9i*q{9U|Wy0~3ZvB<mWON2rl>{=yn(J@__{$KYJ&~qvp#;td#xA{#Gw!da&pH@%
z0;zFo#A$9-5z24*3!erZ7P?;XCZ5WpseVl_b=u<;mzNgn_4jdMA1#ynMrYOI2gR<(
zGB~lfA{3s``BzdG*2!d*<V^(yF^p?Ndua#d9LM)|DQx3YWtQ*m=*Yoq;&RO1-5JHD
zWsdE>NaI$-xH}eXV)UxcI|OJM%9X7;(q{WFvxQjw3g;9laXW^v$6j|YtyK@me!t;b
zD7YWkXS<r3G&Z{qXX5<~B7MV8a7;yR(!?2X=@A4z41L;e-qzPN;81Fh9M6bcx8lgV
zPxRz)7Mrg@Kv1nHE;&vBW%WKokK*fi9&!E(h2}ul*u|iqmVxo#f=H#Rt1E`gi+QaH
z9o)p3jWr^Jtb;Ft{JJoBugt9Vy_lOdn>I0}uH-ALcplS{XM>xOXqYeW>VSh97C-4L
zHMidZ<xz$NdeZteTe09fa(R~zTGWi3dH$z{W^t5CHW_M!YWEzF)ORlVz?^i}j>P<y
z(mBc?Rk3&t7r-$W1Cq9KNK1{aS1XqwY(XCUTRxrBO|HDRJdoQ?|H?mrLL1FcgqU`m
z7@;uQf9pVaOYlsThq=2LkaWhtqoF?uDHGFmavN3fIa`~d7EB6j-v#rl^G3GaeTaq0
z`;pqkz!fIj>jrJ<F*&vm;Snga9CE;Wqhn9rp0xGw4!;{%U5s$}gJ;J`rdHv8v?*g-
z=<GoaUp0_?KF;<?rmPW+o_;4J6OWrVGsk4fTgC#dey^z`<9QtpdnG9sc4Ks)ncpVZ
zG?kp;HZ+EfPIK&KXFB$ZwaS+^G6%WU6D|{W2U0Q}t3Tx367dZ$FZ<2wyCr*&RSSVO
znekmj@J;}k)dv=Kq-f9Ufy+KuJi1WKKrDF*t2`@MPfKj31dvFWcbQ&Z@poB8^S;rQ
z70UeE^PwY2c(s-+c_$&ETH9w-4|1Bp-Au@ty*(kh?_Z^2@J(=Lb)4;0M#8_|i+}Ql
z!DBLKnQw^`Zb6rp%_%$vGzID1-Qr{)Cr|&@gS7`ywi23~E+3^{tZaw`B*;MPrgZv$
zq6~D!E+6`77@;=d!83EA^V`7Za1)l8&`q^>e#DE!D}g+hsX9?<q}YV4WJ)Oh-Fp3Q
z#cY~Ibk&vKttiJ(Rjzq6Lr)iH)fU0@cVCMZRmMZ41iP{ZyAeHvv!Il<2kQmDQhTKc
zq)jf|*%#7Zq7Rd}4qBGOQTUDp_D)z6f`^=|S6SyK$DierWSN)NrUQDIb*HwG3X~pl
zL5$g4pNqB^v5^I^V>ySQG=|`v0wx{|=vWG^=U~tT@t<$dt!fT;zU=NY?0$`q8ndwm
zR>?Xsa$vUd4C6!&ywwHtHr(nrV&@T~{dAoz(KGZ2cEOcD(+kBGp6<lzwA^GXAWrE(
zRLV}S6<~N_BQ?@_HB(Q<$qS=@onfr%2j(<GD%K;b#qfos)1cyo5#1~GEfPgLs#~^X
zRP^q5Q$T-(Mn!E0*3!cd00|-^d3rIb6_~&4xVj^K#fwWlk1(aC28sLC(vV~ex?1Gy
z8pqI2k9#yAsfq#8N7jZ*=z6%T0-O(vj`G&T_B^tzS(qTrRO;a`wb*g9JTR+E%EWZH
z9bG+M-1+p}2Ds8Vz@HMJryYg4?9qoDQ72<Yd3~ul3i;{F4awU=p`f(3t$?+My+8aF
zE>xpsjaLDj<V57A+}>S<aCN9rQ$aqp2NSZ1gaYsR0VW(4U?=fB3(xrh)e$JySU58S
zW^J+GhQ!@Vqo5sX`QK)1_S~nRc8_%t2;MrYIzN%0ZEhNMC7^Y5bfhVn3+^9y4kuK=
zLut01MO9zs;*s=I9Ihq)jJfL@)|I1T1mmNDJ@SgGc1!2-Eu-rjK}QlHIR&9+>Px)E
z^^LM-zqD_ZtGVVD&jl{~vD)5E!nuApjCLCJ75Wek{6MC%?D1d3PV&VSQCOFN-njU4
zD^sN>2Q<tZC9b;j;ywM`9ZuZS9w^u9If|{Wp=o+lubn31_vs4RVoNh)55=*3I!%Oq
zJnzTo->Usq{>`S@a;iYc2#J6u`dEw!n!nnuL<tci-z2KSWs*szirlC$LnIPC(F=Cm
ze9}41n;PxC#HkmTR!tWRKTe}1Zh2z3`g_Tw>c8~3-fXK{-)rG;QWC%P@J`u@2=2!E
zm7DyC+P_2*6|O04mglcDU=-XlT9}Dhh1~N|n^V54$_mFU)nB=yiq0dwAX}!}avaU0
zzIlA9`ZSPh$EBtFh5t>jARzyxG0R3_DhQW_*L<D`pu9X1nX-%G6GC5+IvF=<bIxGU
zgI>Vr-LQM$`Bx>1#V4g1SOLu(Gvz;r8c)dp6qqnBe^pw(HufGB8h$C9Og^y;YS_hj
zNQ*Xuq7I@{VNTomT-bnVF6L$YB$!d*8LCoB^)PNm$#qM{-17AYIsTEB%P2i-CplC@
z`|&FCbjsn%&$%>)B&!`^SeU$6!a-$-gSgabJ9^u;E<dEJnG|}4z%7qdXEX#X_CemI
z&xBsvc{e5NZgl!nIB3^0Ip|`BRxnbUmHyQ>)z-%{$1+|<Cdk0^_&CaH47*}RA9LbO
z9-V+?JbNi&ELB6bWn=>qf}Z*oXSZyp(c`9ELwAq7m+|`-VGL3O+U4FU?@^LhXnxX>
zyqhH-z1-?5Sn;np;*<CGqPfMZ$3tV#L*!mc-$>-IvL7c0P9N^q_qSqqk%rLE&n2Jk
z(I_zyDW(6Wj!~(H(<=<@t7AP2_b~?G8w?AClqiGrJg%hx5CK~FlAKRf0ir)i6#w>-
zdThM<&AJS&PU^igcGUUiWPPm=br8Z-<rp)Ugdxtmg<P<9_@(EmvVqklRa$h(7PvPb
zb|Yfi&&$+)vpAylS*v1$@wX8<TiNHe*fk`(ZT^FSU4v20KFmO77%M8RVo&8weW;KV
zj|ZXT3^W*((c`M6MYy(~PWwYFEjQU+o-aj5t4N<ohz@jVLD1r(2)!a{It3^wxnQS)
zaLE8R4l#)5sxH(%R%UUBKV~qC8G8y&&4dO+Uvxg11}`@Ig{l~=sduIZYJc7;wp!{k
zMwxMcg{Ylz`ZzBql7%WM<c+Weql@5JADxEYuV1#)7*!(gZzXH%6@LdEPLm5Rx1iza
zxlB{470WlgnM090`*pr?bo^``qKJ(jB_kj`3HZcyM)Wfinl?)X2{{gav{Y`0i?pZv
zml7qvE5MO#Tz=>tyZ3aehF=B}jqqzUB3?Nx1(Etz6d~Ij8_Z?A!HxIhEW8Dl104YL
zV-Pe<1S;AwO0l+<^N3YLS*$?)mg6P568*0Dr7a&C)IM}od3q3@Y}<PHbPRrJgDbTb
zd6~{BdG_KSR*?Us1UUAdgb;Hs>C3Gc`-Bt3FAbY(M$x(bXRPMF>bxgSFG$%HivZlY
ziPNe%yMQSE7tUeuo0E8vqk=4K2qOitu7y#3HPUlc3-;E88$J-l0h8bg3h6CWmdX!f
zhgd0|F~)2qB(P(<_5kurK`z6bP-H>PcN2JI)a~p>eUemz>$2w(1*?gUGJ=7U4fm(X
z+le(zXlTE{anvAFw&RM;>aw1tR?T=)0&}_x@{v{_auFx&I!TKTqQuS%6limWu=$)o
zq18zu?eeSr5y&BdJY}N>>m;3POP}02Snd|h#hH!#`@L$idOwkI+4=T!x)F8U&O!d*
zl13w!ZMXCBu%qHa;M&mD6M;dGQeCcmVMJ(>3L)P$yZdKr#?gy5!_~+(@1n^@yFX7=
zJU&#;PpROy(a;K(jIFWVSWQ4NZ=kIv8YiUw$r6mrxwR(Rfhqh^QBnBeb-Y#^=8AAT
zJ_yej83#{4aB8j~*%q*kuryOlo_%QlNn)fH*?icDElN<xzR-^2>GKm`C}}fMyd|`h
z4abjcgLwmP8wOdkeToKW+V`vgTxOL@n%G*eK}Sw(u||iNo*SB56@%}ag;IqEo&;zo
zB$n@k+g<IK%tTNI&!ij8`OjfZKDDJSo-vB(^<`6)W`yy$e-&WVya5GbwAK8G$U`#f
zx3{y^l_9$7--mnEFofRBf{Q1&ju~^uma31rpnoz6+2+EfH=g2acMxChPLjvTPzai~
z5{3g{VoUETe?(u@<675ZP#G*kSLWk;ex>tN#MuI^>)@OMeTL|2e8q1&p<%sCSftdx
z3`O&-ElgjWH+k<j64^JuR+3P4z2vU|7*kokb8)i9jVAFQCy(^;lqp7UM=Zpvg&ft#
zuy(IS(;1k!x{?1f6{stNuE$3J$?|ouib0Kp6XHp&rBc#Z78JmT2Eof`e$ORV#pr{F
zj~u2lf*WNxB<KFisLAmosQmju;q1{){=joNW~>W~gkJ=tic?^EiqxFN_+Zj@Opkce
z>wYT<ZT9sX>si}5BX~?Zns$Q!&A6cLI^S}hY6p3x;;{H?s^Tl1o{jn+^nsI7isUky
z?S@=5{@YaQUKfw>b$~>yOhw(tr^r8#dLOWwK!<{@0UY-Z931!BA7BEQV+_+o3$=Q6
zP=uiSq>Yvy`f^>6ZGo^$1A=k8?r|<A3h@?xw7}c=-VSfG29JjMKAx<wS^4EYx0;6e
z?S^eU3m7`tIu@2^SB;nM2d#K(B}Q@{A3bm(Gh29CbQj8tb>_poSa-`#6w6^K0^_Lq
zB`lBD55;+Cp$_PaYWvj+LAFy;UfLL4lVqLtK|g#0a3km@<7+p5xae?JUu~E2M{Gr?
z=M=Lkww5GEDoU=50=u-1LsdmQjt(m}?zWY`8R{F}jRI2z@#UhJQ5Sf;Ug=t$V#pXw
z+XMb$p1)|aZBF|dZwb#5A(xOxiB-tVo2zfhO$>NYDI%U%;V)jPw~jCD6drV%#{LC3
zdH2Zf&Iw(&YpionS6g6n_bU_a;T3~}mAzL5>rdBTXMF~^gx>G>!Gb^6ZvtA^nKKJ)
zQuKVQ*VfkcR+j)nD%)+U`Xd#->Gaa*X{V6MK$lC*ft)!{_C=yib(lNIwv=f?g)GE6
zA!GTIn!ogBVfZon&+!C=uwqWaLBve^^Rdw9S7Jm-E(_#P0Zt0(s4Ay4qyslQBTJdG
zs|5VkTjfgLuf+lz@s#OG`VMzWGd3F8=r-1ZqdSo5O)}qKSB<4fw6=Ql$$|AVWdZVD
z$xrFXQux`bsdo)Gzd=_9#YfbXIzi$!@PFjQ;uM?tRs`s_WwfF{e%|I3dXa7Ov{pP_
z$~|6pjwI9>8V%l@{<g?|-XYlcaaa@ZDs_Ln&3P1C401Qr)-Z5W&n;9}D5kq(IAbYG
zMN(@JaTQ*_5t9W(ZS2p3chZ_qNjmCP3AmEYFWdt)v(aw>1&K|-9_Di|=P!+C^L?P)
zu_RBcH}7EC?kwTw39EfWulICKgWFY+-(~xYA6iec+jt#})|p%nO?VpA28b2lAdVkB
zBql&L0)h$QU4>Lj`ir*X1@zOZJaSx^Y&Bhl=Rfhg7LVV?tVY(VXG-12RO1WJ*A6RF
zqVBGx+Dvxs^k7wW-i7_H1h3^(d3=4Z=_VC<9wGAj?Dz1u=9npbe!;_lGLOvVOLRZB
z&Pb>RFN!{09L}FLdr|M^aw6l3R9+Zu6PqfNZ3EEkHm~+fz*f(+>og3~!tbYkSN9(;
zZ`V98v+uhh`jbM7?WZLoPdnY;i!5NTmtoki;{0EtQ7e_ZF&mj-8O^wMsn_`wfyWxm
zM7|AFK5f}0;f~m3cxK|(R3X!~(<oc?vn%F$zVrGPOxjn->&3B6r(pMb=2!9Kvkl?5
zfUQ(b=JB&NzIpJ{b#ESptCRBYTkIn)w>+$Ju?mNyuXXKeyoxL-iDKSzF-%cW@l=D^
zj9Gpse~M?7{N8RVL>{Tu_hS8qbB45EH=$^6stsIwmll5i`t{78@pF1>z$s&Bh%FvL
zo8E{XO^pPr$FBIYT^gEMc1?0uX`q<1Ns~kf{F)?ruH$y2U2@(pav=UJ{m#57bfszh
z$E^|d%sMk;X>mD?;4?$R%t)#EN)&(Jhzfj|$-t$NBoJKq(ct6a<or$YII3~aQ#y8&
z<Y9{DZRs?VH-Ybx{a<}T|99(9L@WZ-s}Jcrb2mgdJm#ab#i!|i+WurE6(y>~i~|1`
DKFpV%

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/intel.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/intel.png
new file mode 100644
index 0000000000000000000000000000000000000000..185fed1b830709dd199f561e2f347013f96a6401
GIT binary patch
literal 5068
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
B2e|+M

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/ios.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/ios.png
new file mode 100644
index 0000000000000000000000000000000000000000..22be2fa39d513670230622369bfc0e53d1fc6125
GIT binary patch
literal 3963
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
V){5*jdDs8|002ovPDHLkV1j4&YIXns

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/sensebot-thumb.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/sensebot-thumb.png
new file mode 100644
index 0000000000000000000000000000000000000000..04e5752a3f8c0b6c818450d8c1d190fde4d097f5
GIT binary patch
literal 15059
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

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/windows.png b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/images/windows.png
new file mode 100644
index 0000000000000000000000000000000000000000..3b66825670143611a64c66e9b725af91b19711d5
GIT binary patch
literal 1696
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

literal 0
HcmV?d00001

diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/codemirror.js b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/codemirror.js
new file mode 100644
index 00000000..d7bb9c02
--- /dev/null
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/codemirror.js
@@ -0,0 +1,8722 @@
+/*Copyright (C) 2015 by Marijn Haverbeke <marijnh@gmail.com> and others
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+// 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,
+            delayingBlurEvent: 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
+            specialChars: null
+        };
+
+        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) + 1;
+            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 if (!cm.options.lineWiseCopyCut) {
+                    return;
+                } 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 (cm.doc.sel == cm.display.selForContextMenu) {
+                var first = text.charCodeAt(0);
+                if (first == 0x200b && !prevInput) prevInput = "\u200b";
+                if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo"); }
+            }
+            // 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 = "\u200b" + (selected ? te.value : "");
+                    te.value = "\u21da"; // Used to catch context-menu undo
+                    te.value = extval;
+                    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 &&
+                            te.selectionEnd > 0 && input.prevInput == "\u200b")
+                            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();
+        this.gracePeriod = false;
+    }
+
+    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 if (!cm.options.lineWiseCopyCut) {
+                    return;
+                } 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);
+                else if (gecko) this.startGracePeriod();
+            }
+            this.rememberSelection();
+        },
+
+        startGracePeriod: function() {
+            var input = this;
+            clearTimeout(this.gracePeriod);
+            this.gracePeriod = setTimeout(function() {
+                input.gracePeriod = false;
+                if (input.selectionChanged())
+                    input.cm.operation(function() { input.cm.curOp.selectionChanged = true; });
+            }, 20);
+        },
+
+        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);
+        },
+
+        selectionChanged: function() {
+            var sel = window.getSelection();
+            return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
+                sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset;
+        },
+
+        pollSelection: function() {
+            if (!this.composing && !this.gracePeriod && this.selectionChanged()) {
+                var sel = window.getSelection(), cm = this.cm;
+                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
+            focus: false,
+            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);
+        if (op.focus && op.focus == activeElt()) ensureFocus(op.cm);
+    }
+
+    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; });
+
+        d.dragFunctions = {
+            simple: function(e) {if (!signalDOMEvent(cm, e)) e_stop(e);},
+            start: function(e){onDragStart(cm, e);},
+            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));
+    }
+
+    function dragDropChanged(cm, value, old) {
+        var wasOn = old && old != CodeMirror.Init;
+        if (!value != !wasOn) {
+            var funcs = cm.display.dragFunctions;
+            var toggle = value ? on : off;
+            toggle(cm.display.scroller, "dragstart", funcs.start);
+            toggle(cm.display.scroller, "dragenter", funcs.simple);
+            toggle(cm.display.scroller, "dragover", funcs.simple);
+            toggle(cm.display.scroller, "drop", funcs.drop);
+        }
+    }
+
+    // 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);
+                else delayBlurEvent(cm);
+                break;
+        }
+    }
+
+    var lastClick, lastDoubleClick;
+    function leftButtonDown(cm, e, start) {
+        if (ie) setTimeout(bind(ensureFocus, cm), 0);
+        else cm.curOp.focus = activeElt();
+
+        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);
+                // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
+                if (webkit || ie && ie_version == 9)
+                    setTimeout(function() {document.body.focus(); display.input.focus();}, 20);
+                else
+                    display.input.focus();
+            }
+        });
+        // 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();
+            ourIndex = doc.sel.primIndex;
+        }
+
+        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" && !e.shiftKey) {
+            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) {
+                cm.curOp.focus = activeElt();
+                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.altKey : 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;
+        cm.curOp.focus = activeElt();
+        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 delayBlurEvent(cm) {
+        cm.state.delayingBlurEvent = true;
+        setTimeout(function() {
+            if (cm.state.delayingBlurEvent) {
+                cm.state.delayingBlurEvent = false;
+                onBlur(cm);
+            }
+        }, 100);
+    }
+
+    function onFocus(cm) {
+        if (cm.state.delayingBlurEvent) cm.state.delayingBlurEvent = false;
+
+        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.delayingBlurEvent) return;
+
+        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 found;
+            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, lineObj;
+            if (typeof line == "number") {
+                var 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; }
+                lineObj = getLine(this.doc, line);
+            } else {
+                lineObj = 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;
+            });
+        }),
+
+        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, old) {
+        cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g");
+        if (old != CodeMirror.Init) cm.refresh();
+    });
+    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("lineWiseCopyCut", 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, dragDropChanged);
+
+    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(doc, node, options) {
+        if (options) for (var opt in options) if (options.hasOwnProperty(opt))
+            this[opt] = options[opt];
+        this.doc = doc;
+        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.doc.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);
+        updateLineHeight(line, Math.max(0, line.height - height));
+        if (cm) runInOp(cm, function() {
+            adjustScrollWhenAboveVisible(cm, line, -height);
+            regLineChange(cm, no, "widget");
+        });
+    };
+    LineWidget.prototype.changed = function() {
+        var oldH = this.height, cm = this.doc.cm, line = this.line;
+        this.height = null;
+        var diff = widgetHeight(this) - oldH;
+        if (!diff) return;
+        updateLineHeight(line, line.height + diff);
+        if (cm) runInOp(cm, function() {
+            cm.curOp.forceUpdate = true;
+            adjustScrollWhenAboveVisible(cm, line, diff);
+        });
+    };
+
+    function widgetHeight(widget) {
+        if (widget.height != null) return widget.height;
+        var cm = widget.doc.cm;
+        if (!cm) return 0;
+        if (!contains(document.body, widget.node)) {
+            var parentStyle = "position: relative;";
+            if (widget.coverGutter)
+                parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;";
+            if (widget.noHScroll)
+                parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;";
+            removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle));
+        }
+        return widget.height = widget.node.offsetHeight;
+    }
+
+    function addLineWidget(doc, handle, node, options) {
+        var widget = new LineWidget(doc, node, options);
+        var cm = doc.cm;
+        if (cm && widget.noHScroll) cm.display.alignWidgets = true;
+        changeLine(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 (cm && !lineIsHidden(doc, line)) {
+                var aboveVisible = heightAtLine(line) < 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,
+            splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")};
+        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 (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 displayText = builder.splitSpaces ? text.replace(/ {3,}/g, splitSpaces) : text;
+        var special = builder.cm.state.specialChars, mustWrap = false;
+        if (!special.test(text)) {
+            builder.col += text.length;
+            var content = document.createTextNode(displayText);
+            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(displayText.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 splitSpaces(old) {
+        var out = " ";
+        for (var i = 0; i < old.length - 2; ++i) out += i % 2 ? " " : "\u00a0";
+        out += " ";
+        return out;
+    }
+
+    // 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, css) {
+            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, css);
+                inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css);
+                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;
+            });
+        }),
+
+        addLineWidget: docMethodOp(function(handle, node, options) {
+            return addLineWidget(this, handle, node, options);
+        }),
+        removeLineWidget: function(widget) { widget.clear(); },
+
+        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,
+                handleMouseEvents: options && options.handleMouseEvents};
+            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\u0587\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.1.1";
+
+    return CodeMirror;
+});
\ No newline at end of file
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/policy-create.js b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/policy-create.js
index f6ae0e5a..f4e75296 100644
--- a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/policy-create.js
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/policy-create.js
@@ -49,16 +49,7 @@ var policy = {};
 var configuredProfiles = [];
 
 function savePolicy(){
-    var profilePayloads = [];
-    for (var key in policy.profile) {
-        if (policy.profile.hasOwnProperty(key)) {
-           profilePayloads.push({
-               featureCode: key,
-               deviceTypeId: policy.platformId,
-               content: policy.profile[key]
-           });
-        }
-    }
+
     var payload = {
         policyName: policy.policyName,
         compliance: policy.selectedAction,
@@ -66,19 +57,15 @@ function savePolicy(){
         profile: {
             profileName: policy.policyName,
             deviceType: {
-                id: policy.platformId
+                id: policy.devicetypeId
             },
-            profileFeaturesList: profilePayloads
+            policyDefinition: policy.policyDefinition
         }
     };
-    payload.users = [];
-    payload.roles = [];
-    if (policy.selectedUsers){
-        payload.users = policy.selectedUsers;
-    }else if (policy.selectedUserRoles){
-        payload.roles = policy.selectedUserRoles;
-    }
-    //invokerUtil.post("/mdm-admin/policies", payload, function(){
+
+    console.log(payload);
+
+    //invokerUtil.post("/iotserver/policy-api/policy/add", payload, function(){
     //    $(".policy-message").removeClass("hidden");
     //    $(".add-policy").addClass("hidden");
     //}, function(){
@@ -116,30 +103,13 @@ $(document).ready(function(){
         //All data is collected. Policy can now be created.
         savePolicy();
     };
-    stepperRegistry['policy-criteria']  = function (actionButton){
-        $( "input[type='radio'].user-select-radio").each(function(){
-           if ( $(this).is(':radio')){
-               if ($(this).is(":checked")){
-                   if($(this).val() == "userSelectField"){
-                       policy.selectedUsers = $("#users-input").val();
-                   }else if($(this).val() == "userRoleSelectField"){
-                       policy.selectedUserRoles = $("#user-roles-input").val();
-                   }
-               }
-           }
-        });
-        policy.selectedAction = $("#action-input").find(":selected").data("action");
-        policy.selectedOwnership = $("#ownership-input").val();
-
-    };
     stepperRegistry['policy-profile']  = function (actionButton){
-        var deviceType = policy.platform;
-        var generatedProfile = operationModule.generateProfile(deviceType, configuredProfiles);
-        policy.profile = generatedProfile;
+        var deviceType = policy.devicetype;
+        policy.policyDefinition = $("#policy-definition-input").val();
     };
-    stepperRegistry['policy-platform'] = function (actionButton){
-        policy.platform = $(actionButton).data("platform");
-        policy.platformId = $(actionButton).data("platform-id");
+    stepperRegistry['policy-devicetype'] = function (actionButton){
+        policy.devicetype = $(actionButton).data("devicetype");
+        policy.devicetypeId = $(actionButton).data("devicetype-id");
 
     };
     $(".uu").click(function(){
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/sql.js b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/sql.js
new file mode 100644
index 00000000..9097d107
--- /dev/null
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/sql.js
@@ -0,0 +1,312 @@
+/*Copyright (C) 2015 by Marijn Haverbeke <marijnh@gmail.com> and others
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+/*Annotations, Annotation Names and relevant tokens*/
+var ANNOTATION_IMPORT = "Import";
+var ANNOTATION_EXPORT = "Export";
+
+var ANNOTATION_TOKEN_AT = "@";
+var ANNOTATION_TOKEN_OPENING_BRACKET = "(";
+var ANNOTATION_TOKEN_CLOSING_BRACKET = ")";
+
+var REGEX_LINE_STARTING_WITH_PLAN = /^@Plan.*/g;
+var REGEX_LINE_STARTING_WITH_SINGLE_LINE_COMMENT = /^--.*/g;
+var REGEX_LINE_STARTING_WITH_MULTI_LINE_COMMENT = /^\/\*.*\*\//g;
+var REGEX_LINE_STARTING_WITH_IMPORT_STATEMENT = /^@Import.*/g;
+
+var SIDDHI_STATEMENT_DELIMETER = ";";
+var SIDDHI_LINE_BREAK = "\n";
+var SIDDHI_LINE_BREAK_CHARACTER = '\n';
+var SIDDHI_SINGLE_QUOTE = "'";
+var SIDDHI_SPACE_LITERAL = " ";
+
+var SIDDHI_LITERAL_DEFINE_STREAM = "define stream";
+
+var MIME_TYPE_SIDDHI_QL = "text/siddhi-ql";
+
+
+CodeMirror.defineMode("sql", function (config, parserConfig) {
+    "use strict";
+
+    var client = parserConfig.client || {},
+        atoms = parserConfig.atoms || {"false":true, "true":true, "null":true},
+        builtin = parserConfig.builtin || {},
+        keywords = parserConfig.keywords || {},
+        operatorChars = parserConfig.operatorChars || /^[*+\-%<>!=&|~^]/,
+        support = parserConfig.support || {},
+        hooks = parserConfig.hooks || {},
+        dateSQL = parserConfig.dateSQL || {"date":true, "time":true, "timestamp":true};
+
+    function tokenBase(stream, state) {
+        var ch = stream.next();
+
+        // call hooks from the mime type
+        if (hooks[ch]) {
+            var result = hooks[ch](stream, state);
+            if (result !== false) return result;
+        }
+
+        if (ch.charCodeAt(0) > 47 && ch.charCodeAt(0) < 58) {
+            // numbers
+            // ref: http://dev.mysql.com/doc/refman/5.5/en/number-literals.html
+            stream.match(/^[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/);
+            support.decimallessFloat == true && stream.eat('.');
+            return "number";
+        } else if (ch == "'" || (ch == '"' && support.doubleQuote)) {
+            // strings
+            // ref: http://dev.mysql.com/doc/refman/5.5/en/string-literals.html
+            state.tokenize = tokenLiteral(ch);
+            return state.tokenize(stream, state);
+        } else if (/^[\(\),\;\[\]]/.test(ch)) {
+            // no highlightning
+            return null;
+        } else if ((ch == "-" && stream.eat("-") && (!support.commentSpaceRequired || stream.eat(" ")))) {
+            // 1-line comments
+            // ref: https://kb.askmonty.org/en/comment-syntax/
+            stream.skipToEnd();
+            return "comment";
+        } else if (ch == "/" && stream.eat("*")) {
+            // multi-line comments
+            // ref: https://kb.askmonty.org/en/comment-syntax/
+            state.tokenize = tokenComment;
+            return state.tokenize(stream, state);
+        } else if (ch == ".") {
+            // .1 for 0.1
+            if (support.zerolessFloat == true && stream.match(/^(?:\d+(?:e[+-]?\d+)?)/i)) {
+                return "number";
+            }
+        } else {
+            stream.eatWhile(/^[_\-\w\d]/);    /* Character '-' will also be eaten, to prevent the highlight happening in keywords being embedded in non-keyword strings. For example, 'all' in 'all-nonkeyword' */
+            var word = stream.current().toLowerCase();         // Added toLowerCase() to highlight keywords in a case insensitive manner.
+            // dates (standard SQL syntax)
+            // ref: http://dev.mysql.com/doc/refman/5.5/en/date-and-time-literals.html
+            if (dateSQL.hasOwnProperty(word) && (stream.match(/^( )+'[^']*'/) || stream.match(/^( )+"[^"]*"/)))
+                return "number";
+            if (atoms.hasOwnProperty(word)) return "atom";
+            if (builtin.hasOwnProperty(word)) return "builtin";
+            if (keywords.hasOwnProperty(word)) return "keyword";
+            if (client.hasOwnProperty(word)) return "string-2";
+            return null;
+        }
+    }
+
+    // 'string', with char specified in quote escaped by '\'
+    function tokenLiteral(quote) {
+        return function (stream, state) {
+            var escaped = false, ch;
+            while ((ch = stream.next()) != null) {
+                if (ch == quote && !escaped) {
+                    state.tokenize = tokenBase;
+                    break;
+                }
+                escaped = !escaped && ch == "\\";
+            }
+            return "string";
+        };
+    }
+
+    function tokenComment(stream, state) {
+        while (true) {
+            if (stream.skipTo("*")) {
+                stream.next();
+                if (stream.eat("/")) {
+                    state.tokenize = tokenBase;
+                    break;
+                }
+            } else {
+                stream.skipToEnd();
+                break;
+            }
+        }
+        return "comment";
+    }
+
+    function pushContext(stream, state, type) {
+        state.context = {
+            prev:state.context,
+            indent:stream.indentation(),
+            col:stream.column(),
+            type:type
+        };
+    }
+
+    function popContext(state) {
+        state.indent = state.context.indent;
+        state.context = state.context.prev;
+    }
+
+    return {
+        startState:function () {
+            return {tokenize:tokenBase, context:null};
+        },
+
+        token:function (stream, state) {
+            if (stream.sol()) {
+                if (state.context && state.context.align == null)
+                    state.context.align = false;
+            }
+            if (stream.eatSpace()) return null;
+
+            var style = state.tokenize(stream, state);
+            if (style == "comment") return style;
+
+            if (state.context && state.context.align == null)
+                state.context.align = true;
+
+            var tok = stream.current();
+            if (tok == "(")
+                pushContext(stream, state, ")");
+            else if (tok == "[")
+                pushContext(stream, state, "]");
+            else if (state.context && state.context.type == tok)
+                popContext(state);
+            return style;
+        },
+
+        indent:function (state, textAfter) {
+            var cx = state.context;
+            if (!cx) return CodeMirror.Pass;
+            var closing = textAfter.charAt(0) == cx.type;
+            if (cx.align) return cx.col + (closing ? 0 : 1);
+            else return cx.indent + (closing ? 0 : config.indentUnit);
+        },
+
+        blockCommentStart: "/*",
+        blockCommentEnd: "*/",
+        lineComment: "--"
+    };
+});
+
+(function () {
+    "use strict";
+
+    // `identifier`
+    function hookIdentifier(stream) {
+        // MySQL/MariaDB identifiers
+        // ref: http://dev.mysql.com/doc/refman/5.6/en/identifier-qualifiers.html
+        var ch;
+        while ((ch = stream.next()) != null) {
+            if (ch == "`" && !stream.eat("`")) return "variable-2";
+        }
+        stream.backUp(stream.current().length - 1);
+        return stream.eatWhile(/\w/) ? "variable-2" : null;
+    }
+
+    // variable token
+    function hookVar(stream) {
+        // variables
+        // @@prefix.varName @varName
+        // varName can be quoted with ` or ' or "
+        // ref: http://dev.mysql.com/doc/refman/5.5/en/user-variables.html
+        if (stream.eat("@")) {
+            stream.match(/^session\./);
+            stream.match(/^local\./);
+            stream.match(/^global\./);
+        }
+
+        if (stream.eat("'")) {
+            stream.match(/^.*'/);
+            return "variable-2";
+        } else if (stream.eat('"')) {
+            stream.match(/^.*"/);
+            return "variable-2";
+        } else if (stream.eat("`")) {
+            stream.match(/^.*`/);
+            return "variable-2";
+        } else if (stream.match(/^[0-9a-zA-Z$\.\_]+/)) {
+            return "variable-2";
+        }
+        return null;
+    }
+
+    ;
+
+    // short client keyword token
+    function hookClient(stream) {
+        // \N means NULL
+        // ref: http://dev.mysql.com/doc/refman/5.5/en/null-values.html
+        if (stream.eat("N")) {
+            return "atom";
+        }
+        // \g, etc
+        // ref: http://dev.mysql.com/doc/refman/5.5/en/mysql-commands.html
+        return stream.match(/^[a-zA-Z.#!?]/) ? "variable-2" : null;
+    }
+
+    // these keywords are used by all SQL dialects (however, a mode can still overwrite it)
+    var sqlKeywordsWithoutSymbols = "all and as begin by contains define delete end events " +
+        "every first for from full group having inner insert into join last " +
+        "left not of on or outer output partition raw return right select snapshot stream table ";
+    var sqlKeywords = ", : ? # ( ) " + sqlKeywordsWithoutSymbols;
+    var builtIn = "bool double float int long object string ";
+    var atoms = "false true null ";
+    var dateSQL = "days hours milliseconds minutes months seconds ";
+    var allSqlSuggestions = sqlKeywordsWithoutSymbols + builtIn + atoms + dateSQL;
+
+    // turn a space-separated list into an array
+    function set(str) {
+        var obj = {}, words = str.split(" ");
+        for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+        return obj;
+    }
+
+    // A generic SQL Mode. It's not a standard, it just try to support what is generally supported
+    CodeMirror.defineMIME(MIME_TYPE_SIDDHI_QL, {
+        name:"sql",
+        keywords:set(sqlKeywords),
+        builtin:set(builtIn),
+        atoms:set(atoms),
+        operatorChars:/^[*+%<>!=/]/,
+        dateSQL:set(dateSQL),
+        support:set("doubleQuote "),
+        allSqlSuggestions:set(allSqlSuggestions)
+    });
+}());
+
+/*
+ How Properties of Mime Types are used by SQL Mode
+ =================================================
+
+ keywords:
+ A list of keywords you want to be highlighted.
+ functions:
+ A list of function names you want to be highlighted.
+ builtin:
+ A list of builtin types you want to be highlighted (if you want types to be of class "builtin" instead of "keyword").
+ operatorChars:
+ All characters that must be handled as operators.
+ client:
+ Commands parsed and executed by the client (not the server).
+ support:
+ A list of supported syntaxes which are not common, but are supported by more than 1 DBMS.
+ * ODBCdotTable: .tableName
+ * zerolessFloat: .1
+ * doubleQuote
+ * nCharCast: N'string'
+ * charsetCast: _utf8'string'
+ * commentHash: use # char for comments
+ * commentSlashSlash: use // for comments
+ * commentSpaceRequired: require a space after -- for comments
+ atoms:
+ Keywords that must be highlighted as atoms,. Some DBMS's support more atoms than others:
+ UNKNOWN, INFINITY, UNDERFLOW, NaN...
+ dateSQL:
+ Used for date/time SQL standard syntax, because not all DBMS's support same temporal types.
+ */
\ No newline at end of file
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/store-listing.js b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/store-listing.js
new file mode 100644
index 00000000..37c03ca9
--- /dev/null
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/js/store-listing.js
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Setting-up global variables.
+ */
+var assetContainer = "#ast-container";
+
+function loadDeviceTypes() {
+    var deviceListing = $("#store-listing");
+    var deviceListingSrc = deviceListing.attr("src");
+
+    $.template("store-listing", deviceListingSrc, function (template) {
+        var serviceURL = "/iotserver/api/devices/types";
+
+        var successCallback = function (data) {
+            var viewModel = {};
+            var deviceTypes = JSON.parse(data);
+            if (!deviceTypes) return;
+
+            for (var i = 0; i < deviceTypes.length; i++) {
+                var deviceType = deviceTypes[i];
+
+                //setting defaults
+                var storeTitle = deviceType.name;
+                var storeDescription = "Connect your " + deviceType.name + " into the WSO2 Device Cloud Platform.";
+
+                if (deviceType.storeTitle != null) {
+                    storeTitle = deviceType.storeTitle;
+                }
+
+                if (deviceType.storeDescription != null) {
+                    storeDescription = deviceType.storeDescription;
+                }
+
+                deviceTypes[i].storeTitle = storeTitle;
+                deviceTypes[i].storeDescription = storeDescription;
+            }
+
+            viewModel.deviceTypes = deviceTypes;
+
+            if (data.length == 0) {
+                $("#ast-container").html("No Devices found");
+            } else {
+                var content = template(viewModel);
+                $("#ast-container").html(content);
+                initStepper(".wizard-stepper");
+            }
+        };
+        invokerUtil.get(serviceURL,
+            successCallback, function (message) {
+                console.log(message);
+            });
+    });
+}
+
+$(document).ready(function () {
+    loadDeviceTypes();
+});
\ No newline at end of file
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/templates/store-listing.hbs b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/templates/store-listing.hbs
new file mode 100644
index 00000000..8f1c7958
--- /dev/null
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/policy-create/public/templates/store-listing.hbs
@@ -0,0 +1,19 @@
+{{#each deviceTypes}}
+<div class="col-xs-12 col-sm-6 col-md-3 col-lg-3">
+    <div class="ctrl-device-type">
+        <div class="d01"><img src="/iotserver/public/{{name}}/images/{{name}}-thumb.png" /></div>
+        <div class="d02"><h2 class="white center">{{storeTitle}}</h2></div>
+        <div class="d03">{{storeDescription}}</div>
+        <div class="d04">
+            <a href="#" class="cu-btn wizard-stepper" data-current="policy-devicetype" data-next="policy-profile" data-devicetype="{{name}}" data-devicetype-id="{{id}}">
+                    <span class="fw-stack">
+                        <i class="fw fw-ring fw-stack-2x"></i>
+                        <i class="fw fw-add fw-stack-1x"></i>
+                    </span>
+                Select
+            </a>
+        </div>
+    </div>
+</div>
+{{/each}}
+<br class="c-both"/>
diff --git a/modules/distribution/src/repository/jaggeryapps/iotserver/units/store-listing/public/js/store-listing.js b/modules/distribution/src/repository/jaggeryapps/iotserver/units/store-listing/public/js/store-listing.js
index 38cef474..29e152a3 100644
--- a/modules/distribution/src/repository/jaggeryapps/iotserver/units/store-listing/public/js/store-listing.js
+++ b/modules/distribution/src/repository/jaggeryapps/iotserver/units/store-listing/public/js/store-listing.js
@@ -24,6 +24,7 @@ var assetContainer = "#ast-container";
 function loadDeviceTypes() {
     var deviceListing = $("#store-listing");
     var deviceListingSrc = deviceListing.attr("src");
+
     $.template("store-listing", deviceListingSrc, function (template) {
         var serviceURL = "/iotserver/api/devices/types";