├── .gitignore
├── CNAME
├── README.md
├── assets
    ├── axe.png
    ├── backbone.localStorage.js
    ├── codemirror-addons
    │   ├── comment
    │   │   ├── comment.js
    │   │   └── continuecomment.js
    │   ├── dialog
    │   │   ├── dialog.css
    │   │   └── dialog.js
    │   ├── display
    │   │   ├── fullscreen.css
    │   │   ├── fullscreen.js
    │   │   └── placeholder.js
    │   ├── edit
    │   │   ├── closebrackets.js
    │   │   ├── closetag.js
    │   │   ├── continuelist.js
    │   │   ├── matchbrackets.js
    │   │   ├── matchtags.js
    │   │   └── trailingspace.js
    │   ├── fold
    │   │   ├── brace-fold.js
    │   │   ├── comment-fold.js
    │   │   ├── foldcode.js
    │   │   ├── foldgutter.css
    │   │   ├── foldgutter.js
    │   │   ├── indent-fold.js
    │   │   └── xml-fold.js
    │   ├── hint
    │   │   ├── anyword-hint.js
    │   │   ├── css-hint.js
    │   │   ├── html-hint.js
    │   │   ├── javascript-hint.js
    │   │   ├── pig-hint.js
    │   │   ├── python-hint.js
    │   │   ├── show-hint.css
    │   │   ├── show-hint.js
    │   │   ├── sql-hint.js
    │   │   └── xml-hint.js
    │   ├── lint
    │   │   ├── coffeescript-lint.js
    │   │   ├── css-lint.js
    │   │   ├── javascript-lint.js
    │   │   ├── json-lint.js
    │   │   ├── lint.css
    │   │   └── lint.js
    │   ├── merge
    │   │   ├── dep
    │   │   │   └── diff_match_patch.js
    │   │   ├── merge.css
    │   │   └── merge.js
    │   ├── mode
    │   │   ├── loadmode.js
    │   │   ├── multiplex.js
    │   │   ├── multiplex_test.js
    │   │   └── overlay.js
    │   ├── runmode
    │   │   ├── colorize.js
    │   │   ├── runmode-standalone.js
    │   │   ├── runmode.js
    │   │   └── runmode.node.js
    │   ├── scroll
    │   │   └── scrollpastend.js
    │   ├── search
    │   │   ├── match-highlighter.js
    │   │   ├── search.js
    │   │   └── searchcursor.js
    │   ├── selection
    │   │   ├── active-line.js
    │   │   └── mark-selection.js
    │   ├── tern
    │   │   ├── tern.css
    │   │   ├── tern.js
    │   │   └── worker.js
    │   └── wrap
    │   │   └── hardwrap.js
    ├── codemirror.css
    ├── codemirror.js
    ├── jquery.js
    ├── jshint.js
    ├── json2.js
    ├── jsonlint.js
    ├── knockback.js
    ├── main.js
    ├── style.css
    └── tiny_grid.png
└── index.html


/.gitignore:
--------------------------------------------------------------------------------
 1 | _site/*
 2 | _theme_packages/*
 3 | 
 4 | Thumbs.db
 5 | .DS_Store
 6 | 
 7 | !.gitkeep
 8 | 
 9 | .rbenv-version
10 | .rvmrc
11 | 
12 | *~
13 | \#*#
14 | .\#*#
15 | .#*


--------------------------------------------------------------------------------
/CNAME:
--------------------------------------------------------------------------------
1 | elastichammer.exploringelasticsearch.com


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Elastic-Hammer
 2 | ## Elastic-search Front-End
 3 | 
 4 | A web front-end for elasticsearch. Runs directly in the browser using localstorage. To use, install it as a plugin
 5 | 
 6 | `./plugin -install andrewvc/elastic-hammer`
 7 | 
 8 | ### Features
 9 | 
10 | * Auto-checks JSON as you type
11 | * Compact, auto-sizing layout, for maximum information density
12 | * Displays image URLs as actual images, URLs in search results as links
13 | * Path based API detection enabling automatic smart settings during use
14 | * Cross Platform
15 | * Uses HTML5 localstorage to keep your request history
16 | 
17 | ### Installing as an ElasticSearch plugin
18 | 
19 | Simply run (in your elasticsearch bin folder)
20 | 
21 | `./plugin -install andrewvc/elastic-hammer`
22 | 
23 | To use it visit `http://yourelasticsearchserver/_plugin/elastic-hammer/`
24 | 
25 | To upgrade the plugin run:
26 | 
27 | `./plugin -remove elastic-hammer; ./plugin -install andrewvc/elastic-hammer`
28 | 
29 | ### Screenshot
30 | 
31 | ![Screenshot](https://www.evernote.com/shard/s46/sh/691eda2f-ef89-4578-8a8a-eb73efd439c4/4efdcec6693f6bc84b47913bdf47d046/deep/0/Elastic-Hammer.png)
32 | 
33 | ### In Development
34 | 
35 | * Improved output formatting
36 | * Custom output formatters
37 | * Automatic index detection
38 | 


--------------------------------------------------------------------------------
/assets/axe.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewvc/elastic-hammer/16a05e66af902b8d76d8985b29a81e73a3b03eac/assets/axe.png


--------------------------------------------------------------------------------
/assets/backbone.localStorage.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Backbone localStorage Adapter
  3 |  * Version 1.1.5
  4 |  *
  5 |  * https://github.com/jeromegn/Backbone.localStorage
  6 |  */
  7 | (function (root, factory) {
  8 |    if (typeof exports === 'object') {
  9 |      module.exports = factory(require("underscore"), require("backbone"));
 10 |    } else if (typeof define === "function" && define.amd) {
 11 |       // AMD. Register as an anonymous module.
 12 |       define(["underscore","backbone"], function(_, Backbone) {
 13 |         // Use global variables if the locals are undefined.
 14 |         return factory(_ || root._, Backbone || root.Backbone);
 15 |       });
 16 |    } else {
 17 |       // RequireJS isn't being used. Assume underscore and backbone are loaded in <script> tags
 18 |       factory(_, Backbone);
 19 |    }
 20 | }(this, function(_, Backbone) {
 21 | // A simple module to replace `Backbone.sync` with *localStorage*-based
 22 | // persistence. Models are given GUIDS, and saved into a JSON object. Simple
 23 | // as that.
 24 | 
 25 | // Hold reference to Underscore.js and Backbone.js in the closure in order
 26 | // to make things work even if they are removed from the global namespace
 27 | 
 28 | // Generate four random hex digits.
 29 | function S4() {
 30 |    return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
 31 | };
 32 | 
 33 | // Generate a pseudo-GUID by concatenating random hexadecimal.
 34 | function guid() {
 35 |    return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
 36 | };
 37 | 
 38 | // Our Store is represented by a single JS object in *localStorage*. Create it
 39 | // with a meaningful name, like the name you'd give a table.
 40 | // window.Store is deprectated, use Backbone.LocalStorage instead
 41 | Backbone.LocalStorage = window.Store = function(name) {
 42 |   if( !this.localStorage ) {
 43 |     throw "Backbone.localStorage: Environment does not support localStorage."
 44 |   }
 45 |   this.name = name;
 46 |   var store = this.localStorage().getItem(this.name);
 47 |   this.records = (store && store.split(",")) || [];
 48 | };
 49 | 
 50 | _.extend(Backbone.LocalStorage.prototype, {
 51 | 
 52 |   // Save the current state of the **Store** to *localStorage*.
 53 |   save: function() {
 54 |     this.localStorage().setItem(this.name, this.records.join(","));
 55 |   },
 56 | 
 57 |   // Add a model, giving it a (hopefully)-unique GUID, if it doesn't already
 58 |   // have an id of it's own.
 59 |   create: function(model) {
 60 |     if (!model.id) {
 61 |       model.id = guid();
 62 |       model.set(model.idAttribute, model.id);
 63 |     }
 64 |     this.localStorage().setItem(this.name+"-"+model.id, JSON.stringify(model));
 65 |     this.records.push(model.id.toString());
 66 |     this.save();
 67 |     return this.find(model);
 68 |   },
 69 | 
 70 |   // Update a model by replacing its copy in `this.data`.
 71 |   update: function(model) {
 72 |     this.localStorage().setItem(this.name+"-"+model.id, JSON.stringify(model));
 73 |     if (!_.include(this.records, model.id.toString()))
 74 |       this.records.push(model.id.toString()); this.save();
 75 |     return this.find(model);
 76 |   },
 77 | 
 78 |   // Retrieve a model from `this.data` by id.
 79 |   find: function(model) {
 80 |     return this.jsonData(this.localStorage().getItem(this.name+"-"+model.id));
 81 |   },
 82 | 
 83 |   // Return the array of all models currently in storage.
 84 |   findAll: function() {
 85 |     // Lodash removed _#chain in v1.0.0-rc.1
 86 |     return (_.chain || _)(this.records)
 87 |       .map(function(id){
 88 |         return this.jsonData(this.localStorage().getItem(this.name+"-"+id));
 89 |       }, this)
 90 |       .compact()
 91 |       .value();
 92 |   },
 93 | 
 94 |   // Delete a model from `this.data`, returning it.
 95 |   destroy: function(model) {
 96 |     if (model.isNew())
 97 |       return false
 98 |     this.localStorage().removeItem(this.name+"-"+model.id);
 99 |     this.records = _.reject(this.records, function(id){
100 |       return id === model.id.toString();
101 |     });
102 |     this.save();
103 |     return model;
104 |   },
105 | 
106 |   localStorage: function() {
107 |     return localStorage;
108 |   },
109 | 
110 |   // fix for "illegal access" error on Android when JSON.parse is passed null
111 |   jsonData: function (data) {
112 |       return data && JSON.parse(data);
113 |   },
114 | 
115 |   // Clear localStorage for specific collection.
116 |   _clear: function() {
117 |     var local = this.localStorage(),
118 |       itemRe = new RegExp("^" + this.name + "-");
119 | 
120 |     // Remove id-tracking item (e.g., "foo").
121 |     local.removeItem(this.name);
122 | 
123 |     // Lodash removed _#chain in v1.0.0-rc.1
124 |     // Match all data items (e.g., "foo-ID") and remove.
125 |     (_.chain || _)(local).keys()
126 |       .filter(function (k) { return itemRe.test(k); })
127 |       .each(function (k) { local.removeItem(k); });
128 | 
129 |     this.records.length = 0;
130 |   },
131 | 
132 |   // Size of localStorage.
133 |   _storageSize: function() {
134 |     return this.localStorage().length;
135 |   }
136 | 
137 | });
138 | 
139 | // localSync delegate to the model or collection's
140 | // *localStorage* property, which should be an instance of `Store`.
141 | // window.Store.sync and Backbone.localSync is deprecated, use Backbone.LocalStorage.sync instead
142 | Backbone.LocalStorage.sync = window.Store.sync = Backbone.localSync = function(method, model, options) {
143 |   var store = model.localStorage || model.collection.localStorage;
144 | 
145 |   var resp, errorMessage, syncDfd = Backbone.$.Deferred && Backbone.$.Deferred(); //If $ is having Deferred - use it.
146 | 
147 |   try {
148 | 
149 |     switch (method) {
150 |       case "read":
151 |         resp = model.id != undefined ? store.find(model) : store.findAll();
152 |         break;
153 |       case "create":
154 |         resp = store.create(model);
155 |         break;
156 |       case "update":
157 |         resp = store.update(model);
158 |         break;
159 |       case "delete":
160 |         resp = store.destroy(model);
161 |         break;
162 |     }
163 | 
164 |   } catch(error) {
165 |     if (error.code === 22 && store._storageSize() === 0)
166 |       errorMessage = "Private browsing is unsupported";
167 |     else
168 |       errorMessage = error.message;
169 |   }
170 | 
171 |   if (resp) {
172 |     if (options && options.success) {
173 |       if (Backbone.VERSION === "0.9.10") {
174 |         options.success(model, resp, options);
175 |       } else {
176 |         options.success(resp);
177 |       }
178 |     }
179 |     if (syncDfd) {
180 |       syncDfd.resolve(resp);
181 |     }
182 | 
183 |   } else {
184 |     errorMessage = errorMessage ? errorMessage
185 |                                 : "Record Not Found";
186 | 
187 |     if (options && options.error)
188 |       if (Backbone.VERSION === "0.9.10") {
189 |         options.error(model, errorMessage, options);
190 |       } else {
191 |         options.error(errorMessage);
192 |       }
193 | 
194 |     if (syncDfd)
195 |       syncDfd.reject(errorMessage);
196 |   }
197 | 
198 |   // add compatibility with $.ajax
199 |   // always execute callback for success and error
200 |   if (options && options.complete) options.complete(resp);
201 | 
202 |   return syncDfd && syncDfd.promise();
203 | };
204 | 
205 | Backbone.ajaxSync = Backbone.sync;
206 | 
207 | Backbone.getSyncMethod = function(model) {
208 |   if(model.localStorage || (model.collection && model.collection.localStorage)) {
209 |     return Backbone.localSync;
210 |   }
211 | 
212 |   return Backbone.ajaxSync;
213 | };
214 | 
215 | // Override 'Backbone.sync' to default to localSync,
216 | // the original 'Backbone.sync' is still available in 'Backbone.ajaxSync'
217 | Backbone.sync = function(method, model, options) {
218 |   return Backbone.getSyncMethod(model).apply(this, [method, model, options]);
219 | };
220 | 
221 | return Backbone.LocalStorage;
222 | }));
223 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/comment/comment.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   "use strict";
  3 | 
  4 |   var noOptions = {};
  5 |   var nonWS = /[^\s\u00a0]/;
  6 |   var Pos = CodeMirror.Pos;
  7 | 
  8 |   function firstNonWS(str) {
  9 |     var found = str.search(nonWS);
 10 |     return found == -1 ? 0 : found;
 11 |   }
 12 | 
 13 |   CodeMirror.commands.toggleComment = function(cm) {
 14 |     var from = cm.getCursor("start"), to = cm.getCursor("end");
 15 |     cm.uncomment(from, to) || cm.lineComment(from, to);
 16 |   };
 17 | 
 18 |   CodeMirror.defineExtension("lineComment", function(from, to, options) {
 19 |     if (!options) options = noOptions;
 20 |     var self = this, mode = self.getModeAt(from);
 21 |     var commentString = options.lineComment || mode.lineComment;
 22 |     if (!commentString) {
 23 |       if (options.blockCommentStart || mode.blockCommentStart) {
 24 |         options.fullLines = true;
 25 |         self.blockComment(from, to, options);
 26 |       }
 27 |       return;
 28 |     }
 29 |     var firstLine = self.getLine(from.line);
 30 |     if (firstLine == null) return;
 31 |     var end = Math.min(to.ch != 0 || to.line == from.line ? to.line + 1 : to.line, self.lastLine() + 1);
 32 |     var pad = options.padding == null ? " " : options.padding;
 33 |     var blankLines = options.commentBlankLines || from.line == to.line;
 34 | 
 35 |     self.operation(function() {
 36 |       if (options.indent) {
 37 |         var baseString = firstLine.slice(0, firstNonWS(firstLine));
 38 |         for (var i = from.line; i < end; ++i) {
 39 |           var line = self.getLine(i), cut = baseString.length;
 40 |           if (!blankLines && !nonWS.test(line)) continue;
 41 |           if (line.slice(0, cut) != baseString) cut = firstNonWS(line);
 42 |           self.replaceRange(baseString + commentString + pad, Pos(i, 0), Pos(i, cut));
 43 |         }
 44 |       } else {
 45 |         for (var i = from.line; i < end; ++i) {
 46 |           if (blankLines || nonWS.test(self.getLine(i)))
 47 |             self.replaceRange(commentString + pad, Pos(i, 0));
 48 |         }
 49 |       }
 50 |     });
 51 |   });
 52 | 
 53 |   CodeMirror.defineExtension("blockComment", function(from, to, options) {
 54 |     if (!options) options = noOptions;
 55 |     var self = this, mode = self.getModeAt(from);
 56 |     var startString = options.blockCommentStart || mode.blockCommentStart;
 57 |     var endString = options.blockCommentEnd || mode.blockCommentEnd;
 58 |     if (!startString || !endString) {
 59 |       if ((options.lineComment || mode.lineComment) && options.fullLines != false)
 60 |         self.lineComment(from, to, options);
 61 |       return;
 62 |     }
 63 | 
 64 |     var end = Math.min(to.line, self.lastLine());
 65 |     if (end != from.line && to.ch == 0 && nonWS.test(self.getLine(end))) --end;
 66 | 
 67 |     var pad = options.padding == null ? " " : options.padding;
 68 |     if (from.line > end) return;
 69 | 
 70 |     self.operation(function() {
 71 |       if (options.fullLines != false) {
 72 |         var lastLineHasText = nonWS.test(self.getLine(end));
 73 |         self.replaceRange(pad + endString, Pos(end));
 74 |         self.replaceRange(startString + pad, Pos(from.line, 0));
 75 |         var lead = options.blockCommentLead || mode.blockCommentLead;
 76 |         if (lead != null) for (var i = from.line + 1; i <= end; ++i)
 77 |           if (i != end || lastLineHasText)
 78 |             self.replaceRange(lead + pad, Pos(i, 0));
 79 |       } else {
 80 |         self.replaceRange(endString, to);
 81 |         self.replaceRange(startString, from);
 82 |       }
 83 |     });
 84 |   });
 85 | 
 86 |   CodeMirror.defineExtension("uncomment", function(from, to, options) {
 87 |     if (!options) options = noOptions;
 88 |     var self = this, mode = self.getModeAt(from);
 89 |     var end = Math.min(to.line, self.lastLine()), start = Math.min(from.line, end);
 90 | 
 91 |     // Try finding line comments
 92 |     var lineString = options.lineComment || mode.lineComment, lines = [];
 93 |     var pad = options.padding == null ? " " : options.padding, didSomething;
 94 |     lineComment: {
 95 |       if (!lineString) break lineComment;
 96 |       for (var i = start; i <= end; ++i) {
 97 |         var line = self.getLine(i);
 98 |         var found = line.indexOf(lineString);
 99 |         if (found == -1 && (i != end || i == start) && nonWS.test(line)) break lineComment;
100 |         if (i != start && found > -1 && nonWS.test(line.slice(0, found))) break lineComment;
101 |         lines.push(line);
102 |       }
103 |       self.operation(function() {
104 |         for (var i = start; i <= end; ++i) {
105 |           var line = lines[i - start];
106 |           var pos = line.indexOf(lineString), endPos = pos + lineString.length;
107 |           if (pos < 0) continue;
108 |           if (line.slice(endPos, endPos + pad.length) == pad) endPos += pad.length;
109 |           didSomething = true;
110 |           self.replaceRange("", Pos(i, pos), Pos(i, endPos));
111 |         }
112 |       });
113 |       if (didSomething) return true;
114 |     }
115 | 
116 |     // Try block comments
117 |     var startString = options.blockCommentStart || mode.blockCommentStart;
118 |     var endString = options.blockCommentEnd || mode.blockCommentEnd;
119 |     if (!startString || !endString) return false;
120 |     var lead = options.blockCommentLead || mode.blockCommentLead;
121 |     var startLine = self.getLine(start), endLine = end == start ? startLine : self.getLine(end);
122 |     var open = startLine.indexOf(startString), close = endLine.lastIndexOf(endString);
123 |     if (close == -1 && start != end) {
124 |       endLine = self.getLine(--end);
125 |       close = endLine.lastIndexOf(endString);
126 |     }
127 |     if (open == -1 || close == -1) return false;
128 | 
129 |     self.operation(function() {
130 |       self.replaceRange("", Pos(end, close - (pad && endLine.slice(close - pad.length, close) == pad ? pad.length : 0)),
131 |                         Pos(end, close + endString.length));
132 |       var openEnd = open + startString.length;
133 |       if (pad && startLine.slice(openEnd, openEnd + pad.length) == pad) openEnd += pad.length;
134 |       self.replaceRange("", Pos(start, open), Pos(start, openEnd));
135 |       if (lead) for (var i = start + 1; i <= end; ++i) {
136 |         var line = self.getLine(i), found = line.indexOf(lead);
137 |         if (found == -1 || nonWS.test(line.slice(0, found))) continue;
138 |         var foundEnd = found + lead.length;
139 |         if (pad && line.slice(foundEnd, foundEnd + pad.length) == pad) foundEnd += pad.length;
140 |         self.replaceRange("", Pos(i, found), Pos(i, foundEnd));
141 |       }
142 |     });
143 |     return true;
144 |   });
145 | })();
146 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/comment/continuecomment.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   var modes = ["clike", "css", "javascript"];
 3 |   for (var i = 0; i < modes.length; ++i)
 4 |     CodeMirror.extendMode(modes[i], {blockCommentContinue: " * "});
 5 | 
 6 |   function continueComment(cm) {
 7 |     var pos = cm.getCursor(), token = cm.getTokenAt(pos);
 8 |     if (token.type != "comment") return CodeMirror.Pass;
 9 |     var mode = CodeMirror.innerMode(cm.getMode(), token.state).mode;
10 | 
11 |     var insert;
12 |     if (mode.blockCommentStart && mode.blockCommentContinue) {
13 |       var end = token.string.indexOf(mode.blockCommentEnd);
14 |       var full = cm.getRange(CodeMirror.Pos(pos.line, 0), CodeMirror.Pos(pos.line, token.end)), found;
15 |       if (end != -1 && end == token.string.length - mode.blockCommentEnd.length) {
16 |         // Comment ended, don't continue it
17 |       } else if (token.string.indexOf(mode.blockCommentStart) == 0) {
18 |         insert = full.slice(0, token.start);
19 |         if (!/^\s*$/.test(insert)) {
20 |           insert = "";
21 |           for (var i = 0; i < token.start; ++i) insert += " ";
22 |         }
23 |       } else if ((found = full.indexOf(mode.blockCommentContinue)) != -1 &&
24 |                  found + mode.blockCommentContinue.length > token.start &&
25 |                  /^\s*$/.test(full.slice(0, found))) {
26 |         insert = full.slice(0, found);
27 |       }
28 |       if (insert != null) insert += mode.blockCommentContinue;
29 |     }
30 |     if (insert == null && mode.lineComment) {
31 |       var line = cm.getLine(pos.line), found = line.indexOf(mode.lineComment);
32 |       if (found > -1) {
33 |         insert = line.slice(0, found);
34 |         if (/\S/.test(insert)) insert = null;
35 |         else insert += mode.lineComment + line.slice(found + mode.lineComment.length).match(/^\s*/)[0];
36 |       }
37 |     }
38 | 
39 |     if (insert != null)
40 |       cm.replaceSelection("\n" + insert, "end");
41 |     else
42 |       return CodeMirror.Pass;
43 |   }
44 | 
45 |   CodeMirror.defineOption("continueComments", null, function(cm, val, prev) {
46 |     if (prev && prev != CodeMirror.Init)
47 |       cm.removeKeyMap("continueComment");
48 |     if (val) {
49 |       var map = {name: "continueComment"};
50 |       map[typeof val == "string" ? val : "Enter"] = continueComment;
51 |       cm.addKeyMap(map);
52 |     }
53 |   });
54 | })();
55 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/dialog/dialog.css:
--------------------------------------------------------------------------------
 1 | .CodeMirror-dialog {
 2 |   position: absolute;
 3 |   left: 0; right: 0;
 4 |   background: white;
 5 |   z-index: 15;
 6 |   padding: .1em .8em;
 7 |   overflow: hidden;
 8 |   color: #333;
 9 | }
10 | 
11 | .CodeMirror-dialog-top {
12 |   border-bottom: 1px solid #eee;
13 |   top: 0;
14 | }
15 | 
16 | .CodeMirror-dialog-bottom {
17 |   border-top: 1px solid #eee;
18 |   bottom: 0;
19 | }
20 | 
21 | .CodeMirror-dialog input {
22 |   border: none;
23 |   outline: none;
24 |   background: transparent;
25 |   width: 20em;
26 |   color: inherit;
27 |   font-family: monospace;
28 | }
29 | 
30 | .CodeMirror-dialog button {
31 |   font-size: 70%;
32 | }
33 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/dialog/dialog.js:
--------------------------------------------------------------------------------
 1 | // Open simple dialogs on top of an editor. Relies on dialog.css.
 2 | 
 3 | (function() {
 4 |   function dialogDiv(cm, template, bottom) {
 5 |     var wrap = cm.getWrapperElement();
 6 |     var dialog;
 7 |     dialog = wrap.appendChild(document.createElement("div"));
 8 |     if (bottom) {
 9 |       dialog.className = "CodeMirror-dialog CodeMirror-dialog-bottom";
10 |     } else {
11 |       dialog.className = "CodeMirror-dialog CodeMirror-dialog-top";
12 |     }
13 |     dialog.innerHTML = template;
14 |     return dialog;
15 |   }
16 | 
17 |   CodeMirror.defineExtension("openDialog", function(template, callback, options) {
18 |     var dialog = dialogDiv(this, template, options && options.bottom);
19 |     var closed = false, me = this;
20 |     function close() {
21 |       if (closed) return;
22 |       closed = true;
23 |       dialog.parentNode.removeChild(dialog);
24 |     }
25 |     var inp = dialog.getElementsByTagName("input")[0], button;
26 |     if (inp) {
27 |       CodeMirror.on(inp, "keydown", function(e) {
28 |         if (options && options.onKeyDown && options.onKeyDown(e, inp.value, close)) { return; }
29 |         if (e.keyCode == 13 || e.keyCode == 27) {
30 |           CodeMirror.e_stop(e);
31 |           close();
32 |           me.focus();
33 |           if (e.keyCode == 13) callback(inp.value);
34 |         }
35 |       });
36 |       if (options && options.onKeyUp) {
37 |         CodeMirror.on(inp, "keyup", function(e) {options.onKeyUp(e, inp.value, close);});
38 |       }
39 |       if (options && options.value) inp.value = options.value;
40 |       inp.focus();
41 |       CodeMirror.on(inp, "blur", close);
42 |     } else if (button = dialog.getElementsByTagName("button")[0]) {
43 |       CodeMirror.on(button, "click", function() {
44 |         close();
45 |         me.focus();
46 |       });
47 |       button.focus();
48 |       CodeMirror.on(button, "blur", close);
49 |     }
50 |     return close;
51 |   });
52 | 
53 |   CodeMirror.defineExtension("openConfirm", function(template, callbacks, options) {
54 |     var dialog = dialogDiv(this, template, options && options.bottom);
55 |     var buttons = dialog.getElementsByTagName("button");
56 |     var closed = false, me = this, blurring = 1;
57 |     function close() {
58 |       if (closed) return;
59 |       closed = true;
60 |       dialog.parentNode.removeChild(dialog);
61 |       me.focus();
62 |     }
63 |     buttons[0].focus();
64 |     for (var i = 0; i < buttons.length; ++i) {
65 |       var b = buttons[i];
66 |       (function(callback) {
67 |         CodeMirror.on(b, "click", function(e) {
68 |           CodeMirror.e_preventDefault(e);
69 |           close();
70 |           if (callback) callback(me);
71 |         });
72 |       })(callbacks[i]);
73 |       CodeMirror.on(b, "blur", function() {
74 |         --blurring;
75 |         setTimeout(function() { if (blurring <= 0) close(); }, 200);
76 |       });
77 |       CodeMirror.on(b, "focus", function() { ++blurring; });
78 |     }
79 |   });
80 | })();
81 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/display/fullscreen.css:
--------------------------------------------------------------------------------
1 | .CodeMirror-fullscreen {
2 |   position: fixed;
3 |   top: 0; left: 0; right: 0; bottom: 0;
4 |   height: auto;
5 |   z-index: 9;
6 | }
7 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/display/fullscreen.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   "use strict";
 3 | 
 4 |   CodeMirror.defineOption("fullScreen", false, function(cm, val, old) {
 5 |     if (old == CodeMirror.Init) old = false;
 6 |     if (!old == !val) return;
 7 |     if (val) setFullscreen(cm);
 8 |     else setNormal(cm);
 9 |   });
10 | 
11 |   function setFullscreen(cm) {
12 |     var wrap = cm.getWrapperElement();
13 |     cm.state.fullScreenRestore = {scrollTop: window.pageYOffset, scrollLeft: window.pageXOffset,
14 |                                   width: wrap.style.width, height: wrap.style.height};
15 |     wrap.style.width = wrap.style.height = "";
16 |     wrap.className += " CodeMirror-fullscreen";
17 |     document.documentElement.style.overflow = "hidden";
18 |     cm.refresh();
19 |   }
20 | 
21 |   function setNormal(cm) {
22 |     var wrap = cm.getWrapperElement();
23 |     wrap.className = wrap.className.replace(/\s*CodeMirror-fullscreen\b/, "");
24 |     document.documentElement.style.overflow = "";
25 |     var info = cm.state.fullScreenRestore;
26 |     wrap.style.width = info.width; wrap.style.height = info.height;
27 |     window.scrollTo(info.scrollLeft, info.scrollTop);
28 |     cm.refresh();
29 |   }
30 | })();
31 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/display/placeholder.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   CodeMirror.defineOption("placeholder", "", function(cm, val, old) {
 3 |     var prev = old && old != CodeMirror.Init;
 4 |     if (val && !prev) {
 5 |       cm.on("focus", onFocus);
 6 |       cm.on("blur", onBlur);
 7 |       cm.on("change", onChange);
 8 |       onChange(cm);
 9 |     } else if (!val && prev) {
10 |       cm.off("focus", onFocus);
11 |       cm.off("blur", onBlur);
12 |       cm.off("change", onChange);
13 |       clearPlaceholder(cm);
14 |       var wrapper = cm.getWrapperElement();
15 |       wrapper.className = wrapper.className.replace(" CodeMirror-empty", "");
16 |     }
17 | 
18 |     if (val && !cm.hasFocus()) onBlur(cm);
19 |   });
20 | 
21 |   function clearPlaceholder(cm) {
22 |     if (cm.state.placeholder) {
23 |       cm.state.placeholder.parentNode.removeChild(cm.state.placeholder);
24 |       cm.state.placeholder = null;
25 |     }
26 |   }
27 |   function setPlaceholder(cm) {
28 |     clearPlaceholder(cm);
29 |     var elt = cm.state.placeholder = document.createElement("pre");
30 |     elt.style.cssText = "height: 0; overflow: visible";
31 |     elt.className = "CodeMirror-placeholder";
32 |     elt.appendChild(document.createTextNode(cm.getOption("placeholder")));
33 |     cm.display.lineSpace.insertBefore(elt, cm.display.lineSpace.firstChild);
34 |   }
35 | 
36 |   function onFocus(cm) {
37 |     clearPlaceholder(cm);
38 |   }
39 |   function onBlur(cm) {
40 |     if (isEmpty(cm)) setPlaceholder(cm);
41 |   }
42 |   function onChange(cm) {
43 |     var wrapper = cm.getWrapperElement(), empty = isEmpty(cm);
44 |     wrapper.className = wrapper.className.replace(" CodeMirror-empty", "") + (empty ? " CodeMirror-empty" : "");
45 | 
46 |     if (cm.hasFocus()) return;
47 |     if (empty) setPlaceholder(cm);
48 |     else clearPlaceholder(cm);
49 |   }
50 | 
51 |   function isEmpty(cm) {
52 |     return (cm.lineCount() === 1) && (cm.getLine(0) === "");
53 |   }
54 | })();
55 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/edit/closebrackets.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   var DEFAULT_BRACKETS = "()[]{}''\"\"";
 3 |   var DEFAULT_EXPLODE_ON_ENTER = "[]{}";
 4 |   var SPACE_CHAR_REGEX = /\s/;
 5 | 
 6 |   CodeMirror.defineOption("autoCloseBrackets", false, function(cm, val, old) {
 7 |     if (old != CodeMirror.Init && old)
 8 |       cm.removeKeyMap("autoCloseBrackets");
 9 |     if (!val) return;
10 |     var pairs = DEFAULT_BRACKETS, explode = DEFAULT_EXPLODE_ON_ENTER;
11 |     if (typeof val == "string") pairs = val;
12 |     else if (typeof val == "object") {
13 |       if (val.pairs != null) pairs = val.pairs;
14 |       if (val.explode != null) explode = val.explode;
15 |     }
16 |     var map = buildKeymap(pairs);
17 |     if (explode) map.Enter = buildExplodeHandler(explode);
18 |     cm.addKeyMap(map);
19 |   });
20 | 
21 |   function charsAround(cm, pos) {
22 |     var str = cm.getRange(CodeMirror.Pos(pos.line, pos.ch - 1),
23 |                           CodeMirror.Pos(pos.line, pos.ch + 1));
24 |     return str.length == 2 ? str : null;
25 |   }
26 | 
27 |   function buildKeymap(pairs) {
28 |     var map = {
29 |       name : "autoCloseBrackets",
30 |       Backspace: function(cm) {
31 |         if (cm.somethingSelected()) return CodeMirror.Pass;
32 |         var cur = cm.getCursor(), around = charsAround(cm, cur);
33 |         if (around && pairs.indexOf(around) % 2 == 0)
34 |           cm.replaceRange("", CodeMirror.Pos(cur.line, cur.ch - 1), CodeMirror.Pos(cur.line, cur.ch + 1));
35 |         else
36 |           return CodeMirror.Pass;
37 |       }
38 |     };
39 |     var closingBrackets = "";
40 |     for (var i = 0; i < pairs.length; i += 2) (function(left, right) {
41 |       if (left != right) closingBrackets += right;
42 |       function surround(cm) {
43 |         var selection = cm.getSelection();
44 |         cm.replaceSelection(left + selection + right);
45 |       }
46 |       function maybeOverwrite(cm) {
47 |         var cur = cm.getCursor(), ahead = cm.getRange(cur, CodeMirror.Pos(cur.line, cur.ch + 1));
48 |         if (ahead != right || cm.somethingSelected()) return CodeMirror.Pass;
49 |         else cm.execCommand("goCharRight");
50 |       }
51 |       map["'" + left + "'"] = function(cm) {
52 |         if (left == "'" && cm.getTokenAt(cm.getCursor()).type == "comment")
53 |           return CodeMirror.Pass;
54 |         if (cm.somethingSelected()) return surround(cm);
55 |         if (left == right && maybeOverwrite(cm) != CodeMirror.Pass) return;
56 |         var cur = cm.getCursor(), ahead = CodeMirror.Pos(cur.line, cur.ch + 1);
57 |         var line = cm.getLine(cur.line), nextChar = line.charAt(cur.ch), curChar = cur.ch > 0 ? line.charAt(cur.ch - 1) : "";
58 |         if (left == right && CodeMirror.isWordChar(curChar))
59 |           return CodeMirror.Pass;
60 |         if (line.length == cur.ch || closingBrackets.indexOf(nextChar) >= 0 || SPACE_CHAR_REGEX.test(nextChar))
61 |           cm.replaceSelection(left + right, {head: ahead, anchor: ahead});
62 |         else
63 |           return CodeMirror.Pass;
64 |       };
65 |       if (left != right) map["'" + right + "'"] = maybeOverwrite;
66 |     })(pairs.charAt(i), pairs.charAt(i + 1));
67 |     return map;
68 |   }
69 | 
70 |   function buildExplodeHandler(pairs) {
71 |     return function(cm) {
72 |       var cur = cm.getCursor(), around = charsAround(cm, cur);
73 |       if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;
74 |       cm.operation(function() {
75 |         var newPos = CodeMirror.Pos(cur.line + 1, 0);
76 |         cm.replaceSelection("\n\n", {anchor: newPos, head: newPos}, "+input");
77 |         cm.indentLine(cur.line + 1, null, true);
78 |         cm.indentLine(cur.line + 2, null, true);
79 |       });
80 |     };
81 |   }
82 | })();
83 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/edit/closetag.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Tag-closer extension for CodeMirror.
 3 |  *
 4 |  * This extension adds an "autoCloseTags" option that can be set to
 5 |  * either true to get the default behavior, or an object to further
 6 |  * configure its behavior.
 7 |  *
 8 |  * These are supported options:
 9 |  *
10 |  * `whenClosing` (default true)
11 |  *   Whether to autoclose when the '/' of a closing tag is typed.
12 |  * `whenOpening` (default true)
13 |  *   Whether to autoclose the tag when the final '>' of an opening
14 |  *   tag is typed.
15 |  * `dontCloseTags` (default is empty tags for HTML, none for XML)
16 |  *   An array of tag names that should not be autoclosed.
17 |  * `indentTags` (default is block tags for HTML, none for XML)
18 |  *   An array of tag names that should, when opened, cause a
19 |  *   blank line to be added inside the tag, and the blank line and
20 |  *   closing line to be indented.
21 |  *
22 |  * See demos/closetag.html for a usage example.
23 |  */
24 | 
25 | (function() {
26 |   CodeMirror.defineOption("autoCloseTags", false, function(cm, val, old) {
27 |     if (val && (old == CodeMirror.Init || !old)) {
28 |       var map = {name: "autoCloseTags"};
29 |       if (typeof val != "object" || val.whenClosing)
30 |         map["'/'"] = function(cm) { return autoCloseSlash(cm); };
31 |       if (typeof val != "object" || val.whenOpening)
32 |         map["'>'"] = function(cm) { return autoCloseGT(cm); };
33 |       cm.addKeyMap(map);
34 |     } else if (!val && (old != CodeMirror.Init && old)) {
35 |       cm.removeKeyMap("autoCloseTags");
36 |     }
37 |   });
38 | 
39 |   var htmlDontClose = ["area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param",
40 |                        "source", "track", "wbr"];
41 |   var htmlIndent = ["applet", "blockquote", "body", "button", "div", "dl", "fieldset", "form", "frameset", "h1", "h2", "h3", "h4",
42 |                     "h5", "h6", "head", "html", "iframe", "layer", "legend", "object", "ol", "p", "select", "table", "ul"];
43 | 
44 |   function autoCloseGT(cm) {
45 |     var pos = cm.getCursor(), tok = cm.getTokenAt(pos);
46 |     var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;
47 |     if (inner.mode.name != "xml" || !state.tagName) return CodeMirror.Pass;
48 | 
49 |     var opt = cm.getOption("autoCloseTags"), html = inner.mode.configuration == "html";
50 |     var dontCloseTags = (typeof opt == "object" && opt.dontCloseTags) || (html && htmlDontClose);
51 |     var indentTags = (typeof opt == "object" && opt.indentTags) || (html && htmlIndent);
52 | 
53 |     var tagName = state.tagName;
54 |     if (tok.end > pos.ch) tagName = tagName.slice(0, tagName.length - tok.end + pos.ch);
55 |     var lowerTagName = tagName.toLowerCase();
56 |     // Don't process the '>' at the end of an end-tag or self-closing tag
57 |     if (tok.type == "tag" && state.type == "closeTag" ||
58 |         tok.string.indexOf("/") == (tok.string.length - 1) || // match something like <someTagName />
59 |         dontCloseTags && indexOf(dontCloseTags, lowerTagName) > -1)
60 |       return CodeMirror.Pass;
61 | 
62 |     var doIndent = indentTags && indexOf(indentTags, lowerTagName) > -1;
63 |     var curPos = doIndent ? CodeMirror.Pos(pos.line + 1, 0) : CodeMirror.Pos(pos.line, pos.ch + 1);
64 |     cm.replaceSelection(">" + (doIndent ? "\n\n" : "") + "</" + tagName + ">",
65 |                         {head: curPos, anchor: curPos});
66 |     if (doIndent) {
67 |       cm.indentLine(pos.line + 1);
68 |       cm.indentLine(pos.line + 2);
69 |     }
70 |   }
71 | 
72 |   function autoCloseSlash(cm) {
73 |     var pos = cm.getCursor(), tok = cm.getTokenAt(pos);
74 |     var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;
75 |     if (tok.string.charAt(0) != "<" || tok.start != pos.ch - 1 || inner.mode.name != "xml") return CodeMirror.Pass;
76 | 
77 |     var tagName = state.context && state.context.tagName;
78 |     if (tagName) cm.replaceSelection("/" + tagName + ">", "end");
79 |   }
80 | 
81 |   function indexOf(collection, elt) {
82 |     if (collection.indexOf) return collection.indexOf(elt);
83 |     for (var i = 0, e = collection.length; i < e; ++i)
84 |       if (collection[i] == elt) return i;
85 |     return -1;
86 |   }
87 | })();
88 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/edit/continuelist.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   'use strict';
 3 | 
 4 |   var listRE = /^(\s*)([*+-]|(\d+)\.)(\s*)/,
 5 |       unorderedBullets = '*+-';
 6 | 
 7 |   CodeMirror.commands.newlineAndIndentContinueMarkdownList = function(cm) {
 8 |     var pos = cm.getCursor(),
 9 |         inList = cm.getStateAfter(pos.line).list !== false,
10 |         match;
11 | 
12 |     if (!inList || !(match = cm.getLine(pos.line).match(listRE))) {
13 |       cm.execCommand('newlineAndIndent');
14 |       return;
15 |     }
16 | 
17 |     var indent = match[1], after = match[4];
18 |     var bullet = unorderedBullets.indexOf(match[2]) >= 0
19 |       ? match[2]
20 |       : (parseInt(match[3], 10) + 1) + '.';
21 | 
22 |     cm.replaceSelection('\n' + indent + bullet + after, 'end');
23 |   };
24 | 
25 | }());
26 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/edit/matchbrackets.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   var ie_lt8 = /MSIE \d/.test(navigator.userAgent) &&
 3 |     (document.documentMode == null || document.documentMode < 8);
 4 | 
 5 |   var Pos = CodeMirror.Pos;
 6 | 
 7 |   var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
 8 |   function findMatchingBracket(cm, where, strict) {
 9 |     var state = cm.state.matchBrackets;
10 |     var maxScanLen = (state && state.maxScanLineLength) || 10000;
11 | 
12 |     var cur = where || cm.getCursor(), line = cm.getLineHandle(cur.line), pos = cur.ch - 1;
13 |     var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
14 |     if (!match) return null;
15 |     var forward = match.charAt(1) == ">", d = forward ? 1 : -1;
16 |     if (strict && forward != (pos == cur.ch)) return null;
17 |     var style = cm.getTokenTypeAt(Pos(cur.line, pos + 1));
18 | 
19 |     var stack = [line.text.charAt(pos)], re = /[(){}[\]]/;
20 |     function scan(line, lineNo, start) {
21 |       if (!line.text) return;
22 |       var pos = forward ? 0 : line.text.length - 1, end = forward ? line.text.length : -1;
23 |       if (line.text.length > maxScanLen) return null;
24 |       if (start != null) pos = start + d;
25 |       for (; pos != end; pos += d) {
26 |         var ch = line.text.charAt(pos);
27 |         if (re.test(ch) && cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style) {
28 |           var match = matching[ch];
29 |           if (match.charAt(1) == ">" == forward) stack.push(ch);
30 |           else if (stack.pop() != match.charAt(0)) return {pos: pos, match: false};
31 |           else if (!stack.length) return {pos: pos, match: true};
32 |         }
33 |       }
34 |     }
35 |     for (var i = cur.line, found, e = forward ? Math.min(i + 100, cm.lineCount()) : Math.max(-1, i - 100); i != e; i+=d) {
36 |       if (i == cur.line) found = scan(line, i, pos);
37 |       else found = scan(cm.getLineHandle(i), i);
38 |       if (found) break;
39 |     }
40 |     return {from: Pos(cur.line, pos), to: found && Pos(i, found.pos),
41 |             match: found && found.match, forward: forward};
42 |   }
43 | 
44 |   function matchBrackets(cm, autoclear) {
45 |     // Disable brace matching in long lines, since it'll cause hugely slow updates
46 |     var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;
47 |     var found = findMatchingBracket(cm);
48 |     if (!found || cm.getLine(found.from.line).length > maxHighlightLen ||
49 |        found.to && cm.getLine(found.to.line).length > maxHighlightLen)
50 |       return;
51 | 
52 |     var style = found.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
53 |     var one = cm.markText(found.from, Pos(found.from.line, found.from.ch + 1), {className: style});
54 |     var two = found.to && cm.markText(found.to, Pos(found.to.line, found.to.ch + 1), {className: style});
55 |     // Kludge to work around the IE bug from issue #1193, where text
56 |     // input stops going to the textare whever this fires.
57 |     if (ie_lt8 && cm.state.focused) cm.display.input.focus();
58 |     var clear = function() {
59 |       cm.operation(function() { one.clear(); two && two.clear(); });
60 |     };
61 |     if (autoclear) setTimeout(clear, 800);
62 |     else return clear;
63 |   }
64 | 
65 |   var currentlyHighlighted = null;
66 |   function doMatchBrackets(cm) {
67 |     cm.operation(function() {
68 |       if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
69 |       if (!cm.somethingSelected()) currentlyHighlighted = matchBrackets(cm, false);
70 |     });
71 |   }
72 | 
73 |   CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) {
74 |     if (old && old != CodeMirror.Init)
75 |       cm.off("cursorActivity", doMatchBrackets);
76 |     if (val) {
77 |       cm.state.matchBrackets = typeof val == "object" ? val : {};
78 |       cm.on("cursorActivity", doMatchBrackets);
79 |     }
80 |   });
81 | 
82 |   CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);});
83 |   CodeMirror.defineExtension("findMatchingBracket", function(pos, strict){
84 |     return findMatchingBracket(this, pos, strict);
85 |   });
86 | })();
87 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/edit/matchtags.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   "use strict";
 3 | 
 4 |   CodeMirror.defineOption("matchTags", false, function(cm, val, old) {
 5 |     if (old && old != CodeMirror.Init) {
 6 |       cm.off("cursorActivity", doMatchTags);
 7 |       cm.off("viewportChange", maybeUpdateMatch);
 8 |       clear(cm);
 9 |     }
10 |     if (val) {
11 |       cm.state.matchBothTags = typeof val == "object" && val.bothTags;
12 |       cm.on("cursorActivity", doMatchTags);
13 |       cm.on("viewportChange", maybeUpdateMatch);
14 |       doMatchTags(cm);
15 |     }
16 |   });
17 | 
18 |   function clear(cm) {
19 |     if (cm.state.tagHit) cm.state.tagHit.clear();
20 |     if (cm.state.tagOther) cm.state.tagOther.clear();
21 |     cm.state.tagHit = cm.state.tagOther = null;
22 |   }
23 | 
24 |   function doMatchTags(cm) {
25 |     cm.state.failedTagMatch = false;
26 |     cm.operation(function() {
27 |       clear(cm);
28 |       if (cm.somethingSelected()) return;
29 |       var cur = cm.getCursor(), range = cm.getViewport();
30 |       range.from = Math.min(range.from, cur.line); range.to = Math.max(cur.line + 1, range.to);
31 |       var match = CodeMirror.findMatchingTag(cm, cur, range);
32 |       if (!match) return;
33 |       if (cm.state.matchBothTags) {
34 |         var hit = match.at == "open" ? match.open : match.close;
35 |         if (hit) cm.state.tagHit = cm.markText(hit.from, hit.to, {className: "CodeMirror-matchingtag"});
36 |       }
37 |       var other = match.at == "close" ? match.open : match.close;
38 |       if (other)
39 |         cm.state.tagOther = cm.markText(other.from, other.to, {className: "CodeMirror-matchingtag"});
40 |       else
41 |         cm.state.failedTagMatch = true;
42 |     });
43 |   }
44 | 
45 |   function maybeUpdateMatch(cm) {
46 |     if (cm.state.failedTagMatch) doMatchTags(cm);
47 |   }
48 | 
49 |   CodeMirror.commands.toMatchingTag = function(cm) {
50 |     var found = CodeMirror.findMatchingTag(cm, cm.getCursor());
51 |     if (found) {
52 |       var other = found.at == "close" ? found.open : found.close;
53 |       if (other) cm.setSelection(other.to, other.from);
54 |     }
55 |   };
56 | })();
57 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/edit/trailingspace.js:
--------------------------------------------------------------------------------
 1 | CodeMirror.defineOption("showTrailingSpace", false, function(cm, val, prev) {
 2 |   if (prev == CodeMirror.Init) prev = false;
 3 |   if (prev && !val)
 4 |     cm.removeOverlay("trailingspace");
 5 |   else if (!prev && val)
 6 |     cm.addOverlay({
 7 |       token: function(stream) {
 8 |         for (var l = stream.string.length, i = l; i && /\s/.test(stream.string.charAt(i - 1)); --i) {}
 9 |         if (i > stream.pos) { stream.pos = i; return null; }
10 |         stream.pos = l;
11 |         return "trailingspace";
12 |       },
13 |       name: "trailingspace"
14 |     });
15 | });
16 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/fold/brace-fold.js:
--------------------------------------------------------------------------------
 1 | CodeMirror.registerHelper("fold", "brace", function(cm, start) {
 2 |   var line = start.line, lineText = cm.getLine(line);
 3 |   var startCh, tokenType;
 4 | 
 5 |   function findOpening(openCh) {
 6 |     for (var at = start.ch, pass = 0;;) {
 7 |       var found = at <= 0 ? -1 : lineText.lastIndexOf(openCh, at - 1);
 8 |       if (found == -1) {
 9 |         if (pass == 1) break;
10 |         pass = 1;
11 |         at = lineText.length;
12 |         continue;
13 |       }
14 |       if (pass == 1 && found < start.ch) break;
15 |       tokenType = cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1));
16 |       if (!/^(comment|string)/.test(tokenType)) return found + 1;
17 |       at = found - 1;
18 |     }
19 |   }
20 | 
21 |   var startToken = "{", endToken = "}", startCh = findOpening("{");
22 |   if (startCh == null) {
23 |     startToken = "[", endToken = "]";
24 |     startCh = findOpening("[");
25 |   }
26 | 
27 |   if (startCh == null) return;
28 |   var count = 1, lastLine = cm.lastLine(), end, endCh;
29 |   outer: for (var i = line; i <= lastLine; ++i) {
30 |     var text = cm.getLine(i), pos = i == line ? startCh : 0;
31 |     for (;;) {
32 |       var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos);
33 |       if (nextOpen < 0) nextOpen = text.length;
34 |       if (nextClose < 0) nextClose = text.length;
35 |       pos = Math.min(nextOpen, nextClose);
36 |       if (pos == text.length) break;
37 |       if (cm.getTokenTypeAt(CodeMirror.Pos(i, pos + 1)) == tokenType) {
38 |         if (pos == nextOpen) ++count;
39 |         else if (!--count) { end = i; endCh = pos; break outer; }
40 |       }
41 |       ++pos;
42 |     }
43 |   }
44 |   if (end == null || line == end && endCh == startCh) return;
45 |   return {from: CodeMirror.Pos(line, startCh),
46 |           to: CodeMirror.Pos(end, endCh)};
47 | });
48 | CodeMirror.braceRangeFinder = CodeMirror.fold.brace; // deprecated
49 | 
50 | CodeMirror.registerHelper("fold", "import", function(cm, start) {
51 |   function hasImport(line) {
52 |     if (line < cm.firstLine() || line > cm.lastLine()) return null;
53 |     var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
54 |     if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
55 |     if (start.type != "keyword" || start.string != "import") return null;
56 |     // Now find closing semicolon, return its position
57 |     for (var i = line, e = Math.min(cm.lastLine(), line + 10); i <= e; ++i) {
58 |       var text = cm.getLine(i), semi = text.indexOf(";");
59 |       if (semi != -1) return {startCh: start.end, end: CodeMirror.Pos(i, semi)};
60 |     }
61 |   }
62 | 
63 |   var start = start.line, has = hasImport(start), prev;
64 |   if (!has || hasImport(start - 1) || ((prev = hasImport(start - 2)) && prev.end.line == start - 1))
65 |     return null;
66 |   for (var end = has.end;;) {
67 |     var next = hasImport(end.line + 1);
68 |     if (next == null) break;
69 |     end = next.end;
70 |   }
71 |   return {from: cm.clipPos(CodeMirror.Pos(start, has.startCh + 1)), to: end};
72 | });
73 | CodeMirror.importRangeFinder = CodeMirror.fold["import"]; // deprecated
74 | 
75 | CodeMirror.registerHelper("fold", "include", function(cm, start) {
76 |   function hasInclude(line) {
77 |     if (line < cm.firstLine() || line > cm.lastLine()) return null;
78 |     var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
79 |     if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
80 |     if (start.type == "meta" && start.string.slice(0, 8) == "#include") return start.start + 8;
81 |   }
82 | 
83 |   var start = start.line, has = hasInclude(start);
84 |   if (has == null || hasInclude(start - 1) != null) return null;
85 |   for (var end = start;;) {
86 |     var next = hasInclude(end + 1);
87 |     if (next == null) break;
88 |     ++end;
89 |   }
90 |   return {from: CodeMirror.Pos(start, has + 1),
91 |           to: cm.clipPos(CodeMirror.Pos(end))};
92 | });
93 | CodeMirror.includeRangeFinder = CodeMirror.fold.include; // deprecated
94 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/fold/comment-fold.js:
--------------------------------------------------------------------------------
 1 | CodeMirror.registerHelper("fold", "comment", function(cm, start) {
 2 |   var mode = cm.getModeAt(start), startToken = mode.blockCommentStart, endToken = mode.blockCommentEnd;
 3 |   if (!startToken || !endToken) return;
 4 |   var line = start.line, lineText = cm.getLine(line);
 5 | 
 6 |   var startCh;
 7 |   for (var at = start.ch, pass = 0;;) {
 8 |     var found = at <= 0 ? -1 : lineText.lastIndexOf(startToken, at - 1);
 9 |     if (found == -1) {
10 |       if (pass == 1) return;
11 |       pass = 1;
12 |       at = lineText.length;
13 |       continue;
14 |     }
15 |     if (pass == 1 && found < start.ch) return;
16 |     if (/comment/.test(cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1)))) {
17 |       startCh = found + startToken.length;
18 |       break;
19 |     }
20 |     at = found - 1;
21 |   }
22 | 
23 |   var depth = 1, lastLine = cm.lastLine(), end, endCh;
24 |   outer: for (var i = line; i <= lastLine; ++i) {
25 |     var text = cm.getLine(i), pos = i == line ? startCh : 0;
26 |     for (;;) {
27 |       var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos);
28 |       if (nextOpen < 0) nextOpen = text.length;
29 |       if (nextClose < 0) nextClose = text.length;
30 |       pos = Math.min(nextOpen, nextClose);
31 |       if (pos == text.length) break;
32 |       if (pos == nextOpen) ++depth;
33 |       else if (!--depth) { end = i; endCh = pos; break outer; }
34 |       ++pos;
35 |     }
36 |   }
37 |   if (end == null || line == end && endCh == startCh) return;
38 |   return {from: CodeMirror.Pos(line, startCh),
39 |           to: CodeMirror.Pos(end, endCh)};
40 | });
41 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/fold/foldcode.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   "use strict";
 3 | 
 4 |   function doFold(cm, pos, options, force) {
 5 |     var finder = options && (options.call ? options : options.rangeFinder);
 6 |     if (!finder) finder = cm.getHelper(pos, "fold");
 7 |     if (!finder) return;
 8 |     if (typeof pos == "number") pos = CodeMirror.Pos(pos, 0);
 9 |     var minSize = options && options.minFoldSize || 0;
10 | 
11 |     function getRange(allowFolded) {
12 |       var range = finder(cm, pos);
13 |       if (!range || range.to.line - range.from.line < minSize) return null;
14 |       var marks = cm.findMarksAt(range.from);
15 |       for (var i = 0; i < marks.length; ++i) {
16 |         if (marks[i].__isFold && force !== "fold") {
17 |           if (!allowFolded) return null;
18 |           range.cleared = true;
19 |           marks[i].clear();
20 |         }
21 |       }
22 |       return range;
23 |     }
24 | 
25 |     var range = getRange(true);
26 |     if (options && options.scanUp) while (!range && pos.line > cm.firstLine()) {
27 |       pos = CodeMirror.Pos(pos.line - 1, 0);
28 |       range = getRange(false);
29 |     }
30 |     if (!range || range.cleared || force === "unfold") return;
31 | 
32 |     var myWidget = makeWidget(options);
33 |     CodeMirror.on(myWidget, "mousedown", function() { myRange.clear(); });
34 |     var myRange = cm.markText(range.from, range.to, {
35 |       replacedWith: myWidget,
36 |       clearOnEnter: true,
37 |       __isFold: true
38 |     });
39 |     myRange.on("clear", function(from, to) {
40 |       CodeMirror.signal(cm, "unfold", cm, from, to);
41 |     });
42 |     CodeMirror.signal(cm, "fold", cm, range.from, range.to);
43 |   }
44 | 
45 |   function makeWidget(options) {
46 |     var widget = (options && options.widget) || "\u2194";
47 |     if (typeof widget == "string") {
48 |       var text = document.createTextNode(widget);
49 |       widget = document.createElement("span");
50 |       widget.appendChild(text);
51 |       widget.className = "CodeMirror-foldmarker";
52 |     }
53 |     return widget;
54 |   }
55 | 
56 |   // Clumsy backwards-compatible interface
57 |   CodeMirror.newFoldFunction = function(rangeFinder, widget) {
58 |     return function(cm, pos) { doFold(cm, pos, {rangeFinder: rangeFinder, widget: widget}); };
59 |   };
60 | 
61 |   // New-style interface
62 |   CodeMirror.defineExtension("foldCode", function(pos, options, force) {
63 |     doFold(this, pos, options, force);
64 |   });
65 | 
66 |   CodeMirror.registerHelper("fold", "combine", function() {
67 |     var funcs = Array.prototype.slice.call(arguments, 0);
68 |     return function(cm, start) {
69 |       for (var i = 0; i < funcs.length; ++i) {
70 |         var found = funcs[i](cm, start);
71 |         if (found) return found;
72 |       }
73 |     };
74 |   });
75 | })();
76 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/fold/foldgutter.css:
--------------------------------------------------------------------------------
 1 | .CodeMirror-foldmarker {
 2 |   color: blue;
 3 |   text-shadow: #b9f 1px 1px 2px, #b9f -1px -1px 2px, #b9f 1px -1px 2px, #b9f -1px 1px 2px;
 4 |   font-family: arial;
 5 |   line-height: .3;
 6 |   cursor: pointer;
 7 | }
 8 | .CodeMirror-foldgutter {
 9 |   width: .7em;
10 | }
11 | .CodeMirror-foldgutter-open,
12 | .CodeMirror-foldgutter-folded {
13 |   color: #555;
14 |   cursor: pointer;
15 | }
16 | .CodeMirror-foldgutter-open:after {
17 |   content: "\25BE";
18 | }
19 | .CodeMirror-foldgutter-folded:after {
20 |   content: "\25B8";
21 | }
22 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/fold/foldgutter.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   "use strict";
  3 | 
  4 |   CodeMirror.defineOption("foldGutter", false, function(cm, val, old) {
  5 |     if (old && old != CodeMirror.Init) {
  6 |       cm.clearGutter(cm.state.foldGutter.options.gutter);
  7 |       cm.state.foldGutter = null;
  8 |       cm.off("gutterClick", onGutterClick);
  9 |       cm.off("change", onChange);
 10 |       cm.off("viewportChange", onViewportChange);
 11 |       cm.off("fold", onFold);
 12 |       cm.off("unfold", onFold);
 13 |       cm.off("swapDoc", updateInViewport);
 14 |     }
 15 |     if (val) {
 16 |       cm.state.foldGutter = new State(parseOptions(val));
 17 |       updateInViewport(cm);
 18 |       cm.on("gutterClick", onGutterClick);
 19 |       cm.on("change", onChange);
 20 |       cm.on("viewportChange", onViewportChange);
 21 |       cm.on("fold", onFold);
 22 |       cm.on("unfold", onFold);
 23 |       cm.on("swapDoc", updateInViewport);
 24 |     }
 25 |   });
 26 | 
 27 |   var Pos = CodeMirror.Pos;
 28 | 
 29 |   function State(options) {
 30 |     this.options = options;
 31 |     this.from = this.to = 0;
 32 |   }
 33 | 
 34 |   function parseOptions(opts) {
 35 |     if (opts === true) opts = {};
 36 |     if (opts.gutter == null) opts.gutter = "CodeMirror-foldgutter";
 37 |     if (opts.indicatorOpen == null) opts.indicatorOpen = "CodeMirror-foldgutter-open";
 38 |     if (opts.indicatorFolded == null) opts.indicatorFolded = "CodeMirror-foldgutter-folded";
 39 |     return opts;
 40 |   }
 41 | 
 42 |   function isFolded(cm, line) {
 43 |     var marks = cm.findMarksAt(Pos(line));
 44 |     for (var i = 0; i < marks.length; ++i)
 45 |       if (marks[i].__isFold && marks[i].find().from.line == line) return true;
 46 |   }
 47 | 
 48 |   function marker(spec) {
 49 |     if (typeof spec == "string") {
 50 |       var elt = document.createElement("div");
 51 |       elt.className = spec;
 52 |       return elt;
 53 |     } else {
 54 |       return spec.cloneNode(true);
 55 |     }
 56 |   }
 57 | 
 58 |   function updateFoldInfo(cm, from, to) {
 59 |     var opts = cm.state.foldGutter.options, cur = from;
 60 |     cm.eachLine(from, to, function(line) {
 61 |       var mark = null;
 62 |       if (isFolded(cm, cur)) {
 63 |         mark = marker(opts.indicatorFolded);
 64 |       } else {
 65 |         var pos = Pos(cur, 0), func = opts.rangeFinder || cm.getHelper(pos, "fold");
 66 |         var range = func && func(cm, pos);
 67 |         if (range && range.from.line + 1 < range.to.line)
 68 |           mark = marker(opts.indicatorOpen);
 69 |       }
 70 |       cm.setGutterMarker(line, opts.gutter, mark);
 71 |       ++cur;
 72 |     });
 73 |   }
 74 | 
 75 |   function updateInViewport(cm) {
 76 |     var vp = cm.getViewport(), state = cm.state.foldGutter;
 77 |     if (!state) return;
 78 |     cm.operation(function() {
 79 |       updateFoldInfo(cm, vp.from, vp.to);
 80 |     });
 81 |     state.from = vp.from; state.to = vp.to;
 82 |   }
 83 | 
 84 |   function onGutterClick(cm, line, gutter) {
 85 |     var opts = cm.state.foldGutter.options;
 86 |     if (gutter != opts.gutter) return;
 87 |     cm.foldCode(Pos(line, 0), opts.rangeFinder);
 88 |   }
 89 | 
 90 |   function onChange(cm) {
 91 |     var state = cm.state.foldGutter;
 92 |     state.from = state.to = 0;
 93 |     clearTimeout(state.changeUpdate);
 94 |     state.changeUpdate = setTimeout(function() { updateInViewport(cm); }, 600);
 95 |   }
 96 | 
 97 |   function onViewportChange(cm) {
 98 |     var state = cm.state.foldGutter;
 99 |     clearTimeout(state.changeUpdate);
100 |     state.changeUpdate = setTimeout(function() {
101 |       var vp = cm.getViewport();
102 |       if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {
103 |         updateInViewport(cm);
104 |       } else {
105 |         cm.operation(function() {
106 |           if (vp.from < state.from) {
107 |             updateFoldInfo(cm, vp.from, state.from);
108 |             state.from = vp.from;
109 |           }
110 |           if (vp.to > state.to) {
111 |             updateFoldInfo(cm, state.to, vp.to);
112 |             state.to = vp.to;
113 |           }
114 |         });
115 |       }
116 |     }, 400);
117 |   }
118 | 
119 |   function onFold(cm, from) {
120 |     var state = cm.state.foldGutter, line = from.line;
121 |     if (line >= state.from && line < state.to)
122 |       updateFoldInfo(cm, line, line + 1);
123 |   }
124 | })();
125 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/fold/indent-fold.js:
--------------------------------------------------------------------------------
 1 | CodeMirror.registerHelper("fold", "indent", function(cm, start) {
 2 |   var lastLine = cm.lastLine(),
 3 |       tabSize = cm.getOption("tabSize"),
 4 |       firstLine = cm.getLine(start.line),
 5 |       myIndent = CodeMirror.countColumn(firstLine, null, tabSize);
 6 | 
 7 |   function foldEnded(curColumn, prevColumn) {
 8 |     return curColumn < myIndent ||
 9 |       (curColumn == myIndent && prevColumn >= myIndent) ||
10 |       (curColumn > myIndent && i == lastLine);
11 |   }
12 | 
13 |   for (var i = start.line + 1; i <= lastLine; i++) {
14 |     var curColumn = CodeMirror.countColumn(cm.getLine(i), null, tabSize);
15 |     var prevColumn = CodeMirror.countColumn(cm.getLine(i-1), null, tabSize);
16 | 
17 |     if (foldEnded(curColumn, prevColumn)) {
18 |       var lastFoldLineNumber = curColumn > myIndent && i == lastLine ? i : i-1;
19 |       var lastFoldLine = cm.getLine(lastFoldLineNumber);
20 |       return {from: CodeMirror.Pos(start.line, firstLine.length),
21 |               to: CodeMirror.Pos(lastFoldLineNumber, lastFoldLine.length)};
22 |     }
23 |   }
24 | });
25 | 
26 | CodeMirror.indentRangeFinder = CodeMirror.fold.indent; // deprecated
27 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/fold/xml-fold.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   "use strict";
  3 | 
  4 |   var Pos = CodeMirror.Pos;
  5 |   function cmp(a, b) { return a.line - b.line || a.ch - b.ch; }
  6 | 
  7 |   var nameStartChar = "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
  8 |   var nameChar = nameStartChar + "\-\:\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
  9 |   var xmlTagStart = new RegExp("<(/?)([" + nameStartChar + "][" + nameChar + "]*)", "g");
 10 | 
 11 |   function Iter(cm, line, ch, range) {
 12 |     this.line = line; this.ch = ch;
 13 |     this.cm = cm; this.text = cm.getLine(line);
 14 |     this.min = range ? range.from : cm.firstLine();
 15 |     this.max = range ? range.to - 1 : cm.lastLine();
 16 |   }
 17 | 
 18 |   function tagAt(iter, ch) {
 19 |     var type = iter.cm.getTokenTypeAt(Pos(iter.line, ch));
 20 |     return type && /\btag\b/.test(type);
 21 |   }
 22 | 
 23 |   function nextLine(iter) {
 24 |     if (iter.line >= iter.max) return;
 25 |     iter.ch = 0;
 26 |     iter.text = iter.cm.getLine(++iter.line);
 27 |     return true;
 28 |   }
 29 |   function prevLine(iter) {
 30 |     if (iter.line <= iter.min) return;
 31 |     iter.text = iter.cm.getLine(--iter.line);
 32 |     iter.ch = iter.text.length;
 33 |     return true;
 34 |   }
 35 | 
 36 |   function toTagEnd(iter) {
 37 |     for (;;) {
 38 |       var gt = iter.text.indexOf(">", iter.ch);
 39 |       if (gt == -1) { if (nextLine(iter)) continue; else return; }
 40 |       if (!tagAt(iter, gt + 1)) { iter.ch = gt + 1; continue; }
 41 |       var lastSlash = iter.text.lastIndexOf("/", gt);
 42 |       var selfClose = lastSlash > -1 && !/\S/.test(iter.text.slice(lastSlash + 1, gt));
 43 |       iter.ch = gt + 1;
 44 |       return selfClose ? "selfClose" : "regular";
 45 |     }
 46 |   }
 47 |   function toTagStart(iter) {
 48 |     for (;;) {
 49 |       var lt = iter.ch ? iter.text.lastIndexOf("<", iter.ch - 1) : -1;
 50 |       if (lt == -1) { if (prevLine(iter)) continue; else return; }
 51 |       if (!tagAt(iter, lt + 1)) { iter.ch = lt; continue; }
 52 |       xmlTagStart.lastIndex = lt;
 53 |       iter.ch = lt;
 54 |       var match = xmlTagStart.exec(iter.text);
 55 |       if (match && match.index == lt) return match;
 56 |     }
 57 |   }
 58 | 
 59 |   function toNextTag(iter) {
 60 |     for (;;) {
 61 |       xmlTagStart.lastIndex = iter.ch;
 62 |       var found = xmlTagStart.exec(iter.text);
 63 |       if (!found) { if (nextLine(iter)) continue; else return; }
 64 |       if (!tagAt(iter, found.index + 1)) { iter.ch = found.index + 1; continue; }
 65 |       iter.ch = found.index + found[0].length;
 66 |       return found;
 67 |     }
 68 |   }
 69 |   function toPrevTag(iter) {
 70 |     for (;;) {
 71 |       var gt = iter.ch ? iter.text.lastIndexOf(">", iter.ch - 1) : -1;
 72 |       if (gt == -1) { if (prevLine(iter)) continue; else return; }
 73 |       if (!tagAt(iter, gt + 1)) { iter.ch = gt; continue; }
 74 |       var lastSlash = iter.text.lastIndexOf("/", gt);
 75 |       var selfClose = lastSlash > -1 && !/\S/.test(iter.text.slice(lastSlash + 1, gt));
 76 |       iter.ch = gt + 1;
 77 |       return selfClose ? "selfClose" : "regular";
 78 |     }
 79 |   }
 80 | 
 81 |   function findMatchingClose(iter, tag) {
 82 |     var stack = [];
 83 |     for (;;) {
 84 |       var next = toNextTag(iter), end, startLine = iter.line, startCh = iter.ch - (next ? next[0].length : 0);
 85 |       if (!next || !(end = toTagEnd(iter))) return;
 86 |       if (end == "selfClose") continue;
 87 |       if (next[1]) { // closing tag
 88 |         for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == next[2]) {
 89 |           stack.length = i;
 90 |           break;
 91 |         }
 92 |         if (i < 0 && (!tag || tag == next[2])) return {
 93 |           tag: next[2],
 94 |           from: Pos(startLine, startCh),
 95 |           to: Pos(iter.line, iter.ch)
 96 |         };
 97 |       } else { // opening tag
 98 |         stack.push(next[2]);
 99 |       }
100 |     }
101 |   }
102 |   function findMatchingOpen(iter, tag) {
103 |     var stack = [];
104 |     for (;;) {
105 |       var prev = toPrevTag(iter);
106 |       if (!prev) return;
107 |       if (prev == "selfClose") { toTagStart(iter); continue; }
108 |       var endLine = iter.line, endCh = iter.ch;
109 |       var start = toTagStart(iter);
110 |       if (!start) return;
111 |       if (start[1]) { // closing tag
112 |         stack.push(start[2]);
113 |       } else { // opening tag
114 |         for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == start[2]) {
115 |           stack.length = i;
116 |           break;
117 |         }
118 |         if (i < 0 && (!tag || tag == start[2])) return {
119 |           tag: start[2],
120 |           from: Pos(iter.line, iter.ch),
121 |           to: Pos(endLine, endCh)
122 |         };
123 |       }
124 |     }
125 |   }
126 | 
127 |   CodeMirror.registerHelper("fold", "xml", function(cm, start) {
128 |     var iter = new Iter(cm, start.line, 0);
129 |     for (;;) {
130 |       var openTag = toNextTag(iter), end;
131 |       if (!openTag || iter.line != start.line || !(end = toTagEnd(iter))) return;
132 |       if (!openTag[1] && end != "selfClose") {
133 |         var start = Pos(iter.line, iter.ch);
134 |         var close = findMatchingClose(iter, openTag[2]);
135 |         return close && {from: start, to: close.from};
136 |       }
137 |     }
138 |   });
139 |   CodeMirror.tagRangeFinder = CodeMirror.fold.xml; // deprecated
140 | 
141 |   CodeMirror.findMatchingTag = function(cm, pos, range) {
142 |     var iter = new Iter(cm, pos.line, pos.ch, range);
143 |     if (iter.text.indexOf(">") == -1 && iter.text.indexOf("<") == -1) return;
144 |     var end = toTagEnd(iter), to = end && Pos(iter.line, iter.ch);
145 |     var start = end && toTagStart(iter);
146 |     if (!end || end == "selfClose" || !start || cmp(iter, pos) > 0) return;
147 |     var here = {from: Pos(iter.line, iter.ch), to: to, tag: start[2]};
148 | 
149 |     if (start[1]) { // closing tag
150 |       return {open: findMatchingOpen(iter, start[2]), close: here, at: "close"};
151 |     } else { // opening tag
152 |       iter = new Iter(cm, to.line, to.ch, range);
153 |       return {open: here, close: findMatchingClose(iter, start[2]), at: "open"};
154 |     }
155 |   };
156 | 
157 |   CodeMirror.findEnclosingTag = function(cm, pos, range) {
158 |     var iter = new Iter(cm, pos.line, pos.ch, range);
159 |     for (;;) {
160 |       var open = findMatchingOpen(iter);
161 |       if (!open) break;
162 |       var forward = new Iter(cm, pos.line, pos.ch, range);
163 |       var close = findMatchingClose(forward, open.tag);
164 |       if (close) return {open: open, close: close};
165 |     }
166 |   };
167 | })();
168 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/anyword-hint.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   "use strict";
 3 | 
 4 |   var WORD = /[\w$]+/, RANGE = 500;
 5 | 
 6 |   CodeMirror.registerHelper("hint", "anyword", function(editor, options) {
 7 |     var word = options && options.word || WORD;
 8 |     var range = options && options.range || RANGE;
 9 |     var cur = editor.getCursor(), curLine = editor.getLine(cur.line);
10 |     var start = cur.ch, end = start;
11 |     while (end < curLine.length && word.test(curLine.charAt(end))) ++end;
12 |     while (start && word.test(curLine.charAt(start - 1))) --start;
13 |     var curWord = start != end && curLine.slice(start, end);
14 | 
15 |     var list = [], seen = {};
16 |     function scan(dir) {
17 |       var line = cur.line, end = Math.min(Math.max(line + dir * range, editor.firstLine()), editor.lastLine()) + dir;
18 |       for (; line != end; line += dir) {
19 |         var text = editor.getLine(line), m;
20 |         var re = new RegExp(word.source, "g");
21 |         while (m = re.exec(text)) {
22 |           if (line == cur.line && m[0] === curWord) continue;
23 |           if ((!curWord || m[0].indexOf(curWord) == 0) && !seen.hasOwnProperty(m[0])) {
24 |             seen[m[0]] = true;
25 |             list.push(m[0]);
26 |           }
27 |         }
28 |       }
29 |     }
30 |     scan(-1);
31 |     scan(1);
32 |     return {list: list, from: CodeMirror.Pos(cur.line, start), to: CodeMirror.Pos(cur.line, end)};
33 |   });
34 | })();
35 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/css-hint.js:
--------------------------------------------------------------------------------
 1 | (function () {
 2 |   "use strict";
 3 | 
 4 |   function getHints(cm) {
 5 |     var cur = cm.getCursor(), token = cm.getTokenAt(cur);
 6 |     var inner = CodeMirror.innerMode(cm.getMode(), token.state);
 7 |     if (inner.mode.name != "css") return;
 8 | 
 9 |     // If it's not a 'word-style' token, ignore the token.
10 |     if (!/^[\w$_-]*$/.test(token.string)) {
11 |       token = {
12 |         start: cur.ch, end: cur.ch, string: "", state: token.state,
13 |         type: null
14 |       };
15 |       var stack = token.state.stack;
16 |       var lastToken = stack && stack.length > 0 ? stack[stack.length - 1] : "";
17 |       if (token.string == ":" || lastToken.indexOf("property") == 0)
18 |         token.type = "variable";
19 |       else if (token.string == "{" || lastToken.indexOf("rule") == 0)
20 |         token.type = "property";
21 |     }
22 | 
23 |     if (!token.type)
24 |       return;
25 | 
26 |     var spec = CodeMirror.resolveMode("text/css");
27 |     var keywords = null;
28 |     if (token.type.indexOf("property") == 0)
29 |       keywords = spec.propertyKeywords;
30 |     else if (token.type.indexOf("variable") == 0)
31 |       keywords = spec.valueKeywords;
32 | 
33 |     if (!keywords)
34 |       return;
35 | 
36 |     var result = [];
37 |     for (var name in keywords) {
38 |       if (name.indexOf(token.string) == 0 /* > -1 */)
39 |         result.push(name);
40 |     }
41 | 
42 |     return {
43 |       list: result,
44 |       from: CodeMirror.Pos(cur.line, token.start),
45 |       to: CodeMirror.Pos(cur.line, token.end)
46 |     };
47 |   }
48 | 
49 |   CodeMirror.registerHelper("hint", "css", getHints);
50 | })();
51 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/html-hint.js:
--------------------------------------------------------------------------------
  1 | (function () {
  2 |   var langs = "ab aa af ak sq am ar an hy as av ae ay az bm ba eu be bn bh bi bs br bg my ca ch ce ny zh cv kw co cr hr cs da dv nl dz en eo et ee fo fj fi fr ff gl ka de el gn gu ht ha he hz hi ho hu ia id ie ga ig ik io is it iu ja jv kl kn kr ks kk km ki rw ky kv kg ko ku kj la lb lg li ln lo lt lu lv gv mk mg ms ml mt mi mr mh mn na nv nb nd ne ng nn no ii nr oc oj cu om or os pa pi fa pl ps pt qu rm rn ro ru sa sc sd se sm sg sr gd sn si sk sl so st es su sw ss sv ta te tg th ti bo tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo wa cy wo fy xh yi yo za zu".split(" ");
  3 |   var targets = ["_blank", "_self", "_top", "_parent"];
  4 |   var charsets = ["ascii", "utf-8", "utf-16", "latin1", "latin1"];
  5 |   var methods = ["get", "post", "put", "delete"];
  6 |   var encs = ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"];
  7 |   var media = ["all", "screen", "print", "embossed", "braille", "handheld", "print", "projection", "screen", "tty", "tv", "speech",
  8 |                "3d-glasses", "resolution [>][<][=] [X]", "device-aspect-ratio: X/Y", "orientation:portrait",
  9 |                "orientation:landscape", "device-height: [X]", "device-width: [X]"];
 10 |   var s = { attrs: {} }; // Simple tag, reused for a whole lot of tags
 11 | 
 12 |   var data = {
 13 |     a: {
 14 |       attrs: {
 15 |         href: null, ping: null, type: null,
 16 |         media: media,
 17 |         target: targets,
 18 |         hreflang: langs
 19 |       }
 20 |     },
 21 |     abbr: s,
 22 |     acronym: s,
 23 |     address: s,
 24 |     applet: s,
 25 |     area: {
 26 |       attrs: {
 27 |         alt: null, coords: null, href: null, target: null, ping: null,
 28 |         media: media, hreflang: langs, type: null,
 29 |         shape: ["default", "rect", "circle", "poly"]
 30 |       }
 31 |     },
 32 |     article: s,
 33 |     aside: s,
 34 |     audio: {
 35 |       attrs: {
 36 |         src: null, mediagroup: null,
 37 |         crossorigin: ["anonymous", "use-credentials"],
 38 |         preload: ["none", "metadata", "auto"],
 39 |         autoplay: ["", "autoplay"],
 40 |         loop: ["", "loop"],
 41 |         controls: ["", "controls"]
 42 |       }
 43 |     },
 44 |     b: s,
 45 |     base: { attrs: { href: null, target: targets } },
 46 |     basefont: s,
 47 |     bdi: s,
 48 |     bdo: s,
 49 |     big: s,
 50 |     blockquote: { attrs: { cite: null } },
 51 |     body: s,
 52 |     br: s,
 53 |     button: {
 54 |       attrs: {
 55 |         form: null, formaction: null, name: null, value: null,
 56 |         autofocus: ["", "autofocus"],
 57 |         disabled: ["", "autofocus"],
 58 |         formenctype: encs,
 59 |         formmethod: methods,
 60 |         formnovalidate: ["", "novalidate"],
 61 |         formtarget: targets,
 62 |         type: ["submit", "reset", "button"]
 63 |       }
 64 |     },
 65 |     canvas: { attrs: { width: null, height: null } },
 66 |     caption: s,
 67 |     center: s,
 68 |     cite: s,
 69 |     code: s,
 70 |     col: { attrs: { span: null } },
 71 |     colgroup: { attrs: { span: null } },
 72 |     command: {
 73 |       attrs: {
 74 |         type: ["command", "checkbox", "radio"],
 75 |         label: null, icon: null, radiogroup: null, command: null, title: null,
 76 |         disabled: ["", "disabled"],
 77 |         checked: ["", "checked"]
 78 |       }
 79 |     },
 80 |     data: { attrs: { value: null } },
 81 |     datagrid: { attrs: { disabled: ["", "disabled"], multiple: ["", "multiple"] } },
 82 |     datalist: { attrs: { data: null } },
 83 |     dd: s,
 84 |     del: { attrs: { cite: null, datetime: null } },
 85 |     details: { attrs: { open: ["", "open"] } },
 86 |     dfn: s,
 87 |     dir: s,
 88 |     div: s,
 89 |     dl: s,
 90 |     dt: s,
 91 |     em: s,
 92 |     embed: { attrs: { src: null, type: null, width: null, height: null } },
 93 |     eventsource: { attrs: { src: null } },
 94 |     fieldset: { attrs: { disabled: ["", "disabled"], form: null, name: null } },
 95 |     figcaption: s,
 96 |     figure: s,
 97 |     font: s,
 98 |     footer: s,
 99 |     form: {
100 |       attrs: {
101 |         action: null, name: null,
102 |         "accept-charset": charsets,
103 |         autocomplete: ["on", "off"],
104 |         enctype: encs,
105 |         method: methods,
106 |         novalidate: ["", "novalidate"],
107 |         target: targets
108 |       }
109 |     },
110 |     frame: s,
111 |     frameset: s,
112 |     h1: s, h2: s, h3: s, h4: s, h5: s, h6: s,
113 |     head: {
114 |       attrs: {},
115 |       children: ["title", "base", "link", "style", "meta", "script", "noscript", "command"]
116 |     },
117 |     header: s,
118 |     hgroup: s,
119 |     hr: s,
120 |     html: {
121 |       attrs: { manifest: null },
122 |       children: ["head", "body"]
123 |     },
124 |     i: s,
125 |     iframe: {
126 |       attrs: {
127 |         src: null, srcdoc: null, name: null, width: null, height: null,
128 |         sandbox: ["allow-top-navigation", "allow-same-origin", "allow-forms", "allow-scripts"],
129 |         seamless: ["", "seamless"]
130 |       }
131 |     },
132 |     img: {
133 |       attrs: {
134 |         alt: null, src: null, ismap: null, usemap: null, width: null, height: null,
135 |         crossorigin: ["anonymous", "use-credentials"]
136 |       }
137 |     },
138 |     input: {
139 |       attrs: {
140 |         alt: null, dirname: null, form: null, formaction: null,
141 |         height: null, list: null, max: null, maxlength: null, min: null,
142 |         name: null, pattern: null, placeholder: null, size: null, src: null,
143 |         step: null, value: null, width: null,
144 |         accept: ["audio/*", "video/*", "image/*"],
145 |         autocomplete: ["on", "off"],
146 |         autofocus: ["", "autofocus"],
147 |         checked: ["", "checked"],
148 |         disabled: ["", "disabled"],
149 |         formenctype: encs,
150 |         formmethod: methods,
151 |         formnovalidate: ["", "novalidate"],
152 |         formtarget: targets,
153 |         multiple: ["", "multiple"],
154 |         readonly: ["", "readonly"],
155 |         required: ["", "required"],
156 |         type: ["hidden", "text", "search", "tel", "url", "email", "password", "datetime", "date", "month",
157 |                "week", "time", "datetime-local", "number", "range", "color", "checkbox", "radio",
158 |                "file", "submit", "image", "reset", "button"]
159 |       }
160 |     },
161 |     ins: { attrs: { cite: null, datetime: null } },
162 |     kbd: s,
163 |     keygen: {
164 |       attrs: {
165 |         challenge: null, form: null, name: null,
166 |         autofocus: ["", "autofocus"],
167 |         disabled: ["", "disabled"],
168 |         keytype: ["RSA"]
169 |       }
170 |     },
171 |     label: { attrs: { "for": null, form: null } },
172 |     legend: s,
173 |     li: { attrs: { value: null } },
174 |     link: {
175 |       attrs: {
176 |         href: null, type: null,
177 |         hreflang: langs,
178 |         media: media,
179 |         sizes: ["all", "16x16", "16x16 32x32", "16x16 32x32 64x64"]
180 |       }
181 |     },
182 |     map: { attrs: { name: null } },
183 |     mark: s,
184 |     menu: { attrs: { label: null, type: ["list", "context", "toolbar"] } },
185 |     meta: {
186 |       attrs: {
187 |         content: null,
188 |         charset: charsets,
189 |         name: ["viewport", "application-name", "author", "description", "generator", "keywords"],
190 |         "http-equiv": ["content-language", "content-type", "default-style", "refresh"]
191 |       }
192 |     },
193 |     meter: { attrs: { value: null, min: null, low: null, high: null, max: null, optimum: null } },
194 |     nav: s,
195 |     noframes: s,
196 |     noscript: s,
197 |     object: {
198 |       attrs: {
199 |         data: null, type: null, name: null, usemap: null, form: null, width: null, height: null,
200 |         typemustmatch: ["", "typemustmatch"]
201 |       }
202 |     },
203 |     ol: { attrs: { reversed: ["", "reversed"], start: null, type: ["1", "a", "A", "i", "I"] } },
204 |     optgroup: { attrs: { disabled: ["", "disabled"], label: null } },
205 |     option: { attrs: { disabled: ["", "disabled"], label: null, selected: ["", "selected"], value: null } },
206 |     output: { attrs: { "for": null, form: null, name: null } },
207 |     p: s,
208 |     param: { attrs: { name: null, value: null } },
209 |     pre: s,
210 |     progress: { attrs: { value: null, max: null } },
211 |     q: { attrs: { cite: null } },
212 |     rp: s,
213 |     rt: s,
214 |     ruby: s,
215 |     s: s,
216 |     samp: s,
217 |     script: {
218 |       attrs: {
219 |         type: ["text/javascript"],
220 |         src: null,
221 |         async: ["", "async"],
222 |         defer: ["", "defer"],
223 |         charset: charsets
224 |       }
225 |     },
226 |     section: s,
227 |     select: {
228 |       attrs: {
229 |         form: null, name: null, size: null,
230 |         autofocus: ["", "autofocus"],
231 |         disabled: ["", "disabled"],
232 |         multiple: ["", "multiple"]
233 |       }
234 |     },
235 |     small: s,
236 |     source: { attrs: { src: null, type: null, media: null } },
237 |     span: s,
238 |     strike: s,
239 |     strong: s,
240 |     style: {
241 |       attrs: {
242 |         type: ["text/css"],
243 |         media: media,
244 |         scoped: null
245 |       }
246 |     },
247 |     sub: s,
248 |     summary: s,
249 |     sup: s,
250 |     table: s,
251 |     tbody: s,
252 |     td: { attrs: { colspan: null, rowspan: null, headers: null } },
253 |     textarea: {
254 |       attrs: {
255 |         dirname: null, form: null, maxlength: null, name: null, placeholder: null,
256 |         rows: null, cols: null,
257 |         autofocus: ["", "autofocus"],
258 |         disabled: ["", "disabled"],
259 |         readonly: ["", "readonly"],
260 |         required: ["", "required"],
261 |         wrap: ["soft", "hard"]
262 |       }
263 |     },
264 |     tfoot: s,
265 |     th: { attrs: { colspan: null, rowspan: null, headers: null, scope: ["row", "col", "rowgroup", "colgroup"] } },
266 |     thead: s,
267 |     time: { attrs: { datetime: null } },
268 |     title: s,
269 |     tr: s,
270 |     track: {
271 |       attrs: {
272 |         src: null, label: null, "default": null,
273 |         kind: ["subtitles", "captions", "descriptions", "chapters", "metadata"],
274 |         srclang: langs
275 |       }
276 |     },
277 |     tt: s,
278 |     u: s,
279 |     ul: s,
280 |     "var": s,
281 |     video: {
282 |       attrs: {
283 |         src: null, poster: null, width: null, height: null,
284 |         crossorigin: ["anonymous", "use-credentials"],
285 |         preload: ["auto", "metadata", "none"],
286 |         autoplay: ["", "autoplay"],
287 |         mediagroup: ["movie"],
288 |         muted: ["", "muted"],
289 |         controls: ["", "controls"]
290 |       }
291 |     },
292 |     wbr: s
293 |   };
294 | 
295 |   var globalAttrs = {
296 |     accesskey: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
297 |     "class": null,
298 |     contenteditable: ["true", "false"],
299 |     contextmenu: null,
300 |     dir: ["ltr", "rtl", "auto"],
301 |     draggable: ["true", "false", "auto"],
302 |     dropzone: ["copy", "move", "link", "string:", "file:"],
303 |     hidden: ["hidden"],
304 |     id: null,
305 |     inert: ["inert"],
306 |     itemid: null,
307 |     itemprop: null,
308 |     itemref: null,
309 |     itemscope: ["itemscope"],
310 |     itemtype: null,
311 |     lang: ["en", "es"],
312 |     spellcheck: ["true", "false"],
313 |     style: null,
314 |     tabindex: ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
315 |     title: null,
316 |     translate: ["yes", "no"],
317 |     onclick: null,
318 |     rel: ["stylesheet", "alternate", "author", "bookmark", "help", "license", "next", "nofollow", "noreferrer", "prefetch", "prev", "search", "tag"]
319 |   };
320 |   function populate(obj) {
321 |     for (var attr in globalAttrs) if (globalAttrs.hasOwnProperty(attr))
322 |       obj.attrs[attr] = globalAttrs[attr];
323 |   }
324 | 
325 |   populate(s);
326 |   for (var tag in data) if (data.hasOwnProperty(tag) && data[tag] != s)
327 |     populate(data[tag]);
328 | 
329 |   CodeMirror.htmlSchema = data;
330 |   function htmlHint(cm, options) {
331 |     var local = {schemaInfo: data};
332 |     if (options) for (var opt in options) local[opt] = options[opt];
333 |     return CodeMirror.hint.xml(cm, local);
334 |   }
335 |   CodeMirror.htmlHint = htmlHint; // deprecated
336 |   CodeMirror.registerHelper("hint", "html", htmlHint);
337 | })();
338 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/javascript-hint.js:
--------------------------------------------------------------------------------
  1 | (function () {
  2 |   var Pos = CodeMirror.Pos;
  3 | 
  4 |   function forEach(arr, f) {
  5 |     for (var i = 0, e = arr.length; i < e; ++i) f(arr[i]);
  6 |   }
  7 | 
  8 |   function arrayContains(arr, item) {
  9 |     if (!Array.prototype.indexOf) {
 10 |       var i = arr.length;
 11 |       while (i--) {
 12 |         if (arr[i] === item) {
 13 |           return true;
 14 |         }
 15 |       }
 16 |       return false;
 17 |     }
 18 |     return arr.indexOf(item) != -1;
 19 |   }
 20 | 
 21 |   function scriptHint(editor, keywords, getToken, options) {
 22 |     // Find the token at the cursor
 23 |     var cur = editor.getCursor(), token = getToken(editor, cur), tprop = token;
 24 |     token.state = CodeMirror.innerMode(editor.getMode(), token.state).state;
 25 | 
 26 |     // If it's not a 'word-style' token, ignore the token.
 27 |     if (!/^[\w$_]*$/.test(token.string)) {
 28 |       token = tprop = {start: cur.ch, end: cur.ch, string: "", state: token.state,
 29 |                        type: token.string == "." ? "property" : null};
 30 |     }
 31 |     // If it is a property, find out what it is a property of.
 32 |     while (tprop.type == "property") {
 33 |       tprop = getToken(editor, Pos(cur.line, tprop.start));
 34 |       if (tprop.string != ".") return;
 35 |       tprop = getToken(editor, Pos(cur.line, tprop.start));
 36 |       if (!context) var context = [];
 37 |       context.push(tprop);
 38 |     }
 39 |     return {list: getCompletions(token, context, keywords, options),
 40 |             from: Pos(cur.line, token.start),
 41 |             to: Pos(cur.line, token.end)};
 42 |   }
 43 | 
 44 |   function javascriptHint(editor, options) {
 45 |     return scriptHint(editor, javascriptKeywords,
 46 |                       function (e, cur) {return e.getTokenAt(cur);},
 47 |                       options);
 48 |   };
 49 |   CodeMirror.javascriptHint = javascriptHint; // deprecated
 50 |   CodeMirror.registerHelper("hint", "javascript", javascriptHint);
 51 | 
 52 |   function getCoffeeScriptToken(editor, cur) {
 53 |   // This getToken, it is for coffeescript, imitates the behavior of
 54 |   // getTokenAt method in javascript.js, that is, returning "property"
 55 |   // type and treat "." as indepenent token.
 56 |     var token = editor.getTokenAt(cur);
 57 |     if (cur.ch == token.start + 1 && token.string.charAt(0) == '.') {
 58 |       token.end = token.start;
 59 |       token.string = '.';
 60 |       token.type = "property";
 61 |     }
 62 |     else if (/^\.[\w$_]*$/.test(token.string)) {
 63 |       token.type = "property";
 64 |       token.start++;
 65 |       token.string = token.string.replace(/\./, '');
 66 |     }
 67 |     return token;
 68 |   }
 69 | 
 70 |   function coffeescriptHint(editor, options) {
 71 |     return scriptHint(editor, coffeescriptKeywords, getCoffeeScriptToken, options);
 72 |   }
 73 |   CodeMirror.coffeescriptHint = coffeescriptHint; // deprecated
 74 |   CodeMirror.registerHelper("hint", "coffeescript", coffeescriptHint);
 75 | 
 76 |   var stringProps = ("charAt charCodeAt indexOf lastIndexOf substring substr slice trim trimLeft trimRight " +
 77 |                      "toUpperCase toLowerCase split concat match replace search").split(" ");
 78 |   var arrayProps = ("length concat join splice push pop shift unshift slice reverse sort indexOf " +
 79 |                     "lastIndexOf every some filter forEach map reduce reduceRight ").split(" ");
 80 |   var funcProps = "prototype apply call bind".split(" ");
 81 |   var javascriptKeywords = ("break case catch continue debugger default delete do else false finally for function " +
 82 |                   "if in instanceof new null return switch throw true try typeof var void while with").split(" ");
 83 |   var coffeescriptKeywords = ("and break catch class continue delete do else extends false finally for " +
 84 |                   "if in instanceof isnt new no not null of off on or return switch then throw true try typeof until void while with yes").split(" ");
 85 | 
 86 |   function getCompletions(token, context, keywords, options) {
 87 |     var found = [], start = token.string;
 88 |     function maybeAdd(str) {
 89 |       if (str.indexOf(start) == 0 && !arrayContains(found, str)) found.push(str);
 90 |     }
 91 |     function gatherCompletions(obj) {
 92 |       if (typeof obj == "string") forEach(stringProps, maybeAdd);
 93 |       else if (obj instanceof Array) forEach(arrayProps, maybeAdd);
 94 |       else if (obj instanceof Function) forEach(funcProps, maybeAdd);
 95 |       for (var name in obj) maybeAdd(name);
 96 |     }
 97 | 
 98 |     if (context && context.length) {
 99 |       // If this is a property, see if it belongs to some object we can
100 |       // find in the current environment.
101 |       var obj = context.pop(), base;
102 |       if (obj.type && obj.type.indexOf("variable") === 0) {
103 |         if (options && options.additionalContext)
104 |           base = options.additionalContext[obj.string];
105 |         base = base || window[obj.string];
106 |       } else if (obj.type == "string") {
107 |         base = "";
108 |       } else if (obj.type == "atom") {
109 |         base = 1;
110 |       } else if (obj.type == "function") {
111 |         if (window.jQuery != null && (obj.string == '$' || obj.string == 'jQuery') &&
112 |             (typeof window.jQuery == 'function'))
113 |           base = window.jQuery();
114 |         else if (window._ != null && (obj.string == '_') && (typeof window._ == 'function'))
115 |           base = window._();
116 |       }
117 |       while (base != null && context.length)
118 |         base = base[context.pop().string];
119 |       if (base != null) gatherCompletions(base);
120 |     } else {
121 |       // If not, just look in the window object and any local scope
122 |       // (reading into JS mode internals to get at the local and global variables)
123 |       for (var v = token.state.localVars; v; v = v.next) maybeAdd(v.name);
124 |       for (var v = token.state.globalVars; v; v = v.next) maybeAdd(v.name);
125 |       gatherCompletions(window);
126 |       forEach(keywords, maybeAdd);
127 |     }
128 |     return found;
129 |   }
130 | })();
131 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/pig-hint.js:
--------------------------------------------------------------------------------
  1 | (function () {
  2 |   "use strict";
  3 | 
  4 |   function forEach(arr, f) {
  5 |     for (var i = 0, e = arr.length; i < e; ++i) f(arr[i]);
  6 |   }
  7 | 
  8 |   function arrayContains(arr, item) {
  9 |     if (!Array.prototype.indexOf) {
 10 |       var i = arr.length;
 11 |       while (i--) {
 12 |         if (arr[i] === item) {
 13 |           return true;
 14 |         }
 15 |       }
 16 |       return false;
 17 |     }
 18 |     return arr.indexOf(item) != -1;
 19 |   }
 20 | 
 21 |   function scriptHint(editor, _keywords, getToken) {
 22 |     // Find the token at the cursor
 23 |     var cur = editor.getCursor(), token = getToken(editor, cur), tprop = token;
 24 |     // If it's not a 'word-style' token, ignore the token.
 25 | 
 26 |     if (!/^[\w$_]*$/.test(token.string)) {
 27 |         token = tprop = {start: cur.ch, end: cur.ch, string: "", state: token.state,
 28 |                          className: token.string == ":" ? "pig-type" : null};
 29 |     }
 30 | 
 31 |     if (!context) var context = [];
 32 |     context.push(tprop);
 33 | 
 34 |     var completionList = getCompletions(token, context);
 35 |     completionList = completionList.sort();
 36 |     //prevent autocomplete for last word, instead show dropdown with one word
 37 |     if(completionList.length == 1) {
 38 |       completionList.push(" ");
 39 |     }
 40 | 
 41 |     return {list: completionList,
 42 |             from: CodeMirror.Pos(cur.line, token.start),
 43 |             to: CodeMirror.Pos(cur.line, token.end)};
 44 |   }
 45 | 
 46 |   function pigHint(editor) {
 47 |     return scriptHint(editor, pigKeywordsU, function (e, cur) {return e.getTokenAt(cur);});
 48 |   }
 49 |   CodeMirror.pigHint = pigHint; // deprecated
 50 |   CodeMirror.registerHelper("hint", "pig", pigHint);
 51 | 
 52 |   var pigKeywords = "VOID IMPORT RETURNS DEFINE LOAD FILTER FOREACH ORDER CUBE DISTINCT COGROUP "
 53 |   + "JOIN CROSS UNION SPLIT INTO IF OTHERWISE ALL AS BY USING INNER OUTER ONSCHEMA PARALLEL "
 54 |   + "PARTITION GROUP AND OR NOT GENERATE FLATTEN ASC DESC IS STREAM THROUGH STORE MAPREDUCE "
 55 |   + "SHIP CACHE INPUT OUTPUT STDERROR STDIN STDOUT LIMIT SAMPLE LEFT RIGHT FULL EQ GT LT GTE LTE "
 56 |   + "NEQ MATCHES TRUE FALSE";
 57 |   var pigKeywordsU = pigKeywords.split(" ");
 58 |   var pigKeywordsL = pigKeywords.toLowerCase().split(" ");
 59 | 
 60 |   var pigTypes = "BOOLEAN INT LONG FLOAT DOUBLE CHARARRAY BYTEARRAY BAG TUPLE MAP";
 61 |   var pigTypesU = pigTypes.split(" ");
 62 |   var pigTypesL = pigTypes.toLowerCase().split(" ");
 63 | 
 64 |   var pigBuiltins = "ABS ACOS ARITY ASIN ATAN AVG BAGSIZE BINSTORAGE BLOOM BUILDBLOOM CBRT CEIL "
 65 |   + "CONCAT COR COS COSH COUNT COUNT_STAR COV CONSTANTSIZE CUBEDIMENSIONS DIFF DISTINCT DOUBLEABS "
 66 |   + "DOUBLEAVG DOUBLEBASE DOUBLEMAX DOUBLEMIN DOUBLEROUND DOUBLESUM EXP FLOOR FLOATABS FLOATAVG "
 67 |   + "FLOATMAX FLOATMIN FLOATROUND FLOATSUM GENERICINVOKER INDEXOF INTABS INTAVG INTMAX INTMIN "
 68 |   + "INTSUM INVOKEFORDOUBLE INVOKEFORFLOAT INVOKEFORINT INVOKEFORLONG INVOKEFORSTRING INVOKER "
 69 |   + "ISEMPTY JSONLOADER JSONMETADATA JSONSTORAGE LAST_INDEX_OF LCFIRST LOG LOG10 LOWER LONGABS "
 70 |   + "LONGAVG LONGMAX LONGMIN LONGSUM MAX MIN MAPSIZE MONITOREDUDF NONDETERMINISTIC OUTPUTSCHEMA  "
 71 |   + "PIGSTORAGE PIGSTREAMING RANDOM REGEX_EXTRACT REGEX_EXTRACT_ALL REPLACE ROUND SIN SINH SIZE "
 72 |   + "SQRT STRSPLIT SUBSTRING SUM STRINGCONCAT STRINGMAX STRINGMIN STRINGSIZE TAN TANH TOBAG "
 73 |   + "TOKENIZE TOMAP TOP TOTUPLE TRIM TEXTLOADER TUPLESIZE UCFIRST UPPER UTF8STORAGECONVERTER";
 74 |   var pigBuiltinsU = pigBuiltins.split(" ").join("() ").split(" ");
 75 |   var pigBuiltinsL = pigBuiltins.toLowerCase().split(" ").join("() ").split(" ");
 76 |   var pigBuiltinsC = ("BagSize BinStorage Bloom BuildBloom ConstantSize CubeDimensions DoubleAbs "
 77 |   + "DoubleAvg DoubleBase DoubleMax DoubleMin DoubleRound DoubleSum FloatAbs FloatAvg FloatMax "
 78 |   + "FloatMin FloatRound FloatSum GenericInvoker IntAbs IntAvg IntMax IntMin IntSum "
 79 |   + "InvokeForDouble InvokeForFloat InvokeForInt InvokeForLong InvokeForString Invoker "
 80 |   + "IsEmpty JsonLoader JsonMetadata JsonStorage LongAbs LongAvg LongMax LongMin LongSum MapSize "
 81 |   + "MonitoredUDF Nondeterministic OutputSchema PigStorage PigStreaming StringConcat StringMax "
 82 |   + "StringMin StringSize TextLoader TupleSize Utf8StorageConverter").split(" ").join("() ").split(" ");
 83 | 
 84 |   function getCompletions(token, context) {
 85 |     var found = [], start = token.string;
 86 |     function maybeAdd(str) {
 87 |       if (str.indexOf(start) == 0 && !arrayContains(found, str)) found.push(str);
 88 |     }
 89 | 
 90 |     function gatherCompletions(obj) {
 91 |       if(obj == ":") {
 92 |         forEach(pigTypesL, maybeAdd);
 93 |       }
 94 |       else {
 95 |         forEach(pigBuiltinsU, maybeAdd);
 96 |         forEach(pigBuiltinsL, maybeAdd);
 97 |         forEach(pigBuiltinsC, maybeAdd);
 98 |         forEach(pigTypesU, maybeAdd);
 99 |         forEach(pigTypesL, maybeAdd);
100 |         forEach(pigKeywordsU, maybeAdd);
101 |         forEach(pigKeywordsL, maybeAdd);
102 |       }
103 |     }
104 | 
105 |     if (context) {
106 |       // If this is a property, see if it belongs to some object we can
107 |       // find in the current environment.
108 |       var obj = context.pop(), base;
109 | 
110 |       if (obj.type == "variable")
111 |           base = obj.string;
112 |       else if(obj.type == "variable-3")
113 |           base = ":" + obj.string;
114 | 
115 |       while (base != null && context.length)
116 |         base = base[context.pop().string];
117 |       if (base != null) gatherCompletions(base);
118 |     }
119 |     return found;
120 |   }
121 | })();
122 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/python-hint.js:
--------------------------------------------------------------------------------
 1 | (function () {
 2 |   function forEach(arr, f) {
 3 |     for (var i = 0, e = arr.length; i < e; ++i) f(arr[i]);
 4 |   }
 5 | 
 6 |   function arrayContains(arr, item) {
 7 |     if (!Array.prototype.indexOf) {
 8 |       var i = arr.length;
 9 |       while (i--) {
10 |         if (arr[i] === item) {
11 |           return true;
12 |         }
13 |       }
14 |       return false;
15 |     }
16 |     return arr.indexOf(item) != -1;
17 |   }
18 | 
19 |   function scriptHint(editor, _keywords, getToken) {
20 |     // Find the token at the cursor
21 |     var cur = editor.getCursor(), token = getToken(editor, cur), tprop = token;
22 |     // If it's not a 'word-style' token, ignore the token.
23 | 
24 |     if (!/^[\w$_]*$/.test(token.string)) {
25 |         token = tprop = {start: cur.ch, end: cur.ch, string: "", state: token.state,
26 |                          className: token.string == ":" ? "python-type" : null};
27 |     }
28 | 
29 |     if (!context) var context = [];
30 |     context.push(tprop);
31 | 
32 |     var completionList = getCompletions(token, context);
33 |     completionList = completionList.sort();
34 |     //prevent autocomplete for last word, instead show dropdown with one word
35 |     if(completionList.length == 1) {
36 |       completionList.push(" ");
37 |     }
38 | 
39 |     return {list: completionList,
40 |             from: CodeMirror.Pos(cur.line, token.start),
41 |             to: CodeMirror.Pos(cur.line, token.end)};
42 |   }
43 | 
44 |   function pythonHint(editor) {
45 |     return scriptHint(editor, pythonKeywordsU, function (e, cur) {return e.getTokenAt(cur);});
46 |   }
47 |   CodeMirror.pythonHint = pythonHint; // deprecated
48 |   CodeMirror.registerHelper("hint", "python", pythonHint);
49 | 
50 |   var pythonKeywords = "and del from not while as elif global or with assert else if pass yield"
51 | + "break except import print class exec in raise continue finally is return def for lambda try";
52 |   var pythonKeywordsL = pythonKeywords.split(" ");
53 |   var pythonKeywordsU = pythonKeywords.toUpperCase().split(" ");
54 | 
55 |   var pythonBuiltins = "abs divmod input open staticmethod all enumerate int ord str "
56 | + "any eval isinstance pow sum basestring execfile issubclass print super"
57 | + "bin file iter property tuple bool filter len range type"
58 | + "bytearray float list raw_input unichr callable format locals reduce unicode"
59 | + "chr frozenset long reload vars classmethod getattr map repr xrange"
60 | + "cmp globals max reversed zip compile hasattr memoryview round __import__"
61 | + "complex hash min set apply delattr help next setattr buffer"
62 | + "dict hex object slice coerce dir id oct sorted intern ";
63 |   var pythonBuiltinsL = pythonBuiltins.split(" ").join("() ").split(" ");
64 |   var pythonBuiltinsU = pythonBuiltins.toUpperCase().split(" ").join("() ").split(" ");
65 | 
66 |   function getCompletions(token, context) {
67 |     var found = [], start = token.string;
68 |     function maybeAdd(str) {
69 |       if (str.indexOf(start) == 0 && !arrayContains(found, str)) found.push(str);
70 |     }
71 | 
72 |     function gatherCompletions(_obj) {
73 |         forEach(pythonBuiltinsL, maybeAdd);
74 |         forEach(pythonBuiltinsU, maybeAdd);
75 |         forEach(pythonKeywordsL, maybeAdd);
76 |         forEach(pythonKeywordsU, maybeAdd);
77 |     }
78 | 
79 |     if (context) {
80 |       // If this is a property, see if it belongs to some object we can
81 |       // find in the current environment.
82 |       var obj = context.pop(), base;
83 | 
84 |       if (obj.type == "variable")
85 |           base = obj.string;
86 |       else if(obj.type == "variable-3")
87 |           base = ":" + obj.string;
88 | 
89 |       while (base != null && context.length)
90 |         base = base[context.pop().string];
91 |       if (base != null) gatherCompletions(base);
92 |     }
93 |     return found;
94 |   }
95 | })();
96 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/show-hint.css:
--------------------------------------------------------------------------------
 1 | .CodeMirror-hints {
 2 |   position: absolute;
 3 |   z-index: 10;
 4 |   overflow: hidden;
 5 |   list-style: none;
 6 | 
 7 |   margin: 0;
 8 |   padding: 2px;
 9 | 
10 |   -webkit-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
11 |   -moz-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
12 |   box-shadow: 2px 3px 5px rgba(0,0,0,.2);
13 |   border-radius: 3px;
14 |   border: 1px solid silver;
15 | 
16 |   background: white;
17 |   font-size: 90%;
18 |   font-family: monospace;
19 | 
20 |   max-height: 20em;
21 |   overflow-y: auto;
22 | }
23 | 
24 | .CodeMirror-hint {
25 |   margin: 0;
26 |   padding: 0 4px;
27 |   border-radius: 2px;
28 |   max-width: 19em;
29 |   overflow: hidden;
30 |   white-space: pre;
31 |   color: black;
32 |   cursor: pointer;
33 | }
34 | 
35 | .CodeMirror-hint-active {
36 |   background: #08f;
37 |   color: white;
38 | }
39 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/show-hint.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   "use strict";
  3 | 
  4 |   CodeMirror.showHint = function(cm, getHints, options) {
  5 |     // We want a single cursor position.
  6 |     if (cm.somethingSelected()) return;
  7 |     if (getHints == null) getHints = cm.getHelper(cm.getCursor(), "hint");
  8 |     if (getHints == null) return;
  9 | 
 10 |     if (cm.state.completionActive) cm.state.completionActive.close();
 11 | 
 12 |     var completion = cm.state.completionActive = new Completion(cm, getHints, options || {});
 13 |     CodeMirror.signal(cm, "startCompletion", cm);
 14 |     if (completion.options.async)
 15 |       getHints(cm, function(hints) { completion.showHints(hints); }, completion.options);
 16 |     else
 17 |       return completion.showHints(getHints(cm, completion.options));
 18 |   };
 19 | 
 20 |   function Completion(cm, getHints, options) {
 21 |     this.cm = cm;
 22 |     this.getHints = getHints;
 23 |     this.options = options;
 24 |     this.widget = this.onClose = null;
 25 |   }
 26 | 
 27 |   Completion.prototype = {
 28 |     close: function() {
 29 |       if (!this.active()) return;
 30 |       this.cm.state.completionActive = null;
 31 | 
 32 |       if (this.widget) this.widget.close();
 33 |       if (this.onClose) this.onClose();
 34 |       CodeMirror.signal(this.cm, "endCompletion", this.cm);
 35 |     },
 36 | 
 37 |     active: function() {
 38 |       return this.cm.state.completionActive == this;
 39 |     },
 40 | 
 41 |     pick: function(data, i) {
 42 |       var completion = data.list[i];
 43 |       if (completion.hint) completion.hint(this.cm, data, completion);
 44 |       else this.cm.replaceRange(getText(completion), data.from, data.to);
 45 |       this.close();
 46 |     },
 47 | 
 48 |     showHints: function(data) {
 49 |       if (!data || !data.list.length || !this.active()) return this.close();
 50 | 
 51 |       if (this.options.completeSingle != false && data.list.length == 1)
 52 |         this.pick(data, 0);
 53 |       else
 54 |         this.showWidget(data);
 55 |     },
 56 | 
 57 |     showWidget: function(data) {
 58 |       this.widget = new Widget(this, data);
 59 |       CodeMirror.signal(data, "shown");
 60 | 
 61 |       var debounce = null, completion = this, finished;
 62 |       var closeOn = this.options.closeCharacters || /[\s()\[\]{};:>,]/;
 63 |       var startPos = this.cm.getCursor(), startLen = this.cm.getLine(startPos.line).length;
 64 | 
 65 |       function done() {
 66 |         if (finished) return;
 67 |         finished = true;
 68 |         completion.close();
 69 |         completion.cm.off("cursorActivity", activity);
 70 |         if (data) CodeMirror.signal(data, "close");
 71 |       }
 72 | 
 73 |       function update() {
 74 |         if (finished) return;
 75 |         CodeMirror.signal(data, "update");
 76 |         if (completion.options.async)
 77 |           completion.getHints(completion.cm, finishUpdate, completion.options);
 78 |         else
 79 |           finishUpdate(completion.getHints(completion.cm, completion.options));
 80 |       }
 81 |       function finishUpdate(data_) {
 82 |         data = data_;
 83 |         if (finished) return;
 84 |         if (!data || !data.list.length) return done();
 85 |         completion.widget = new Widget(completion, data);
 86 |       }
 87 | 
 88 |       function activity() {
 89 |         clearTimeout(debounce);
 90 |         var pos = completion.cm.getCursor(), line = completion.cm.getLine(pos.line);
 91 |         if (pos.line != startPos.line || line.length - pos.ch != startLen - startPos.ch ||
 92 |             pos.ch < startPos.ch || completion.cm.somethingSelected() ||
 93 |             (pos.ch && closeOn.test(line.charAt(pos.ch - 1)))) {
 94 |           completion.close();
 95 |         } else {
 96 |           debounce = setTimeout(update, 170);
 97 |           if (completion.widget) completion.widget.close();
 98 |         }
 99 |       }
100 |       this.cm.on("cursorActivity", activity);
101 |       this.onClose = done;
102 |     }
103 |   };
104 | 
105 |   function getText(completion) {
106 |     if (typeof completion == "string") return completion;
107 |     else return completion.text;
108 |   }
109 | 
110 |   function buildKeyMap(options, handle) {
111 |     var baseMap = {
112 |       Up: function() {handle.moveFocus(-1);},
113 |       Down: function() {handle.moveFocus(1);},
114 |       PageUp: function() {handle.moveFocus(-handle.menuSize() + 1, true);},
115 |       PageDown: function() {handle.moveFocus(handle.menuSize() - 1, true);},
116 |       Home: function() {handle.setFocus(0);},
117 |       End: function() {handle.setFocus(handle.length - 1);},
118 |       Enter: handle.pick,
119 |       Tab: handle.pick,
120 |       Esc: handle.close
121 |     };
122 |     var ourMap = options.customKeys ? {} : baseMap;
123 |     function addBinding(key, val) {
124 |       var bound;
125 |       if (typeof val != "string")
126 |         bound = function(cm) { return val(cm, handle); };
127 |       // This mechanism is deprecated
128 |       else if (baseMap.hasOwnProperty(val))
129 |         bound = baseMap[val];
130 |       else
131 |         bound = val;
132 |       ourMap[key] = bound;
133 |     }
134 |     if (options.customKeys)
135 |       for (var key in options.customKeys) if (options.customKeys.hasOwnProperty(key))
136 |         addBinding(key, options.customKeys[key]);
137 |     if (options.extraKeys)
138 |       for (var key in options.extraKeys) if (options.extraKeys.hasOwnProperty(key))
139 |         addBinding(key, options.extraKeys[key]);
140 |     return ourMap;
141 |   }
142 | 
143 |   function Widget(completion, data) {
144 |     this.completion = completion;
145 |     this.data = data;
146 |     var widget = this, cm = completion.cm, options = completion.options;
147 | 
148 |     var hints = this.hints = document.createElement("ul");
149 |     hints.className = "CodeMirror-hints";
150 |     this.selectedHint = 0;
151 | 
152 |     var completions = data.list;
153 |     for (var i = 0; i < completions.length; ++i) {
154 |       var elt = hints.appendChild(document.createElement("li")), cur = completions[i];
155 |       var className = "CodeMirror-hint" + (i ? "" : " CodeMirror-hint-active");
156 |       if (cur.className != null) className = cur.className + " " + className;
157 |       elt.className = className;
158 |       if (cur.render) cur.render(elt, data, cur);
159 |       else elt.appendChild(document.createTextNode(cur.displayText || getText(cur)));
160 |       elt.hintId = i;
161 |     }
162 | 
163 |     var pos = cm.cursorCoords(options.alignWithWord !== false ? data.from : null);
164 |     var left = pos.left, top = pos.bottom, below = true;
165 |     hints.style.left = left + "px";
166 |     hints.style.top = top + "px";
167 |     // If we're at the edge of the screen, then we want the menu to appear on the left of the cursor.
168 |     var winW = window.innerWidth || Math.max(document.body.offsetWidth, document.documentElement.offsetWidth);
169 |     var winH = window.innerHeight || Math.max(document.body.offsetHeight, document.documentElement.offsetHeight);
170 |     (options.container || document.body).appendChild(hints);
171 |     var box = hints.getBoundingClientRect();
172 |     var overlapX = box.right - winW, overlapY = box.bottom - winH;
173 |     if (overlapX > 0) {
174 |       if (box.right - box.left > winW) {
175 |         hints.style.width = (winW - 5) + "px";
176 |         overlapX -= (box.right - box.left) - winW;
177 |       }
178 |       hints.style.left = (left = pos.left - overlapX) + "px";
179 |     }
180 |     if (overlapY > 0) {
181 |       var height = box.bottom - box.top;
182 |       if (box.top - (pos.bottom - pos.top) - height > 0) {
183 |         overlapY = height + (pos.bottom - pos.top);
184 |         below = false;
185 |       } else if (height > winH) {
186 |         hints.style.height = (winH - 5) + "px";
187 |         overlapY -= height - winH;
188 |       }
189 |       hints.style.top = (top = pos.bottom - overlapY) + "px";
190 |     }
191 | 
192 |     cm.addKeyMap(this.keyMap = buildKeyMap(options, {
193 |       moveFocus: function(n, avoidWrap) { widget.changeActive(widget.selectedHint + n, avoidWrap); },
194 |       setFocus: function(n) { widget.changeActive(n); },
195 |       menuSize: function() { return widget.screenAmount(); },
196 |       length: completions.length,
197 |       close: function() { completion.close(); },
198 |       pick: function() { widget.pick(); }
199 |     }));
200 | 
201 |     if (options.closeOnUnfocus !== false) {
202 |       var closingOnBlur;
203 |       cm.on("blur", this.onBlur = function() { closingOnBlur = setTimeout(function() { completion.close(); }, 100); });
204 |       cm.on("focus", this.onFocus = function() { clearTimeout(closingOnBlur); });
205 |     }
206 | 
207 |     var startScroll = cm.getScrollInfo();
208 |     cm.on("scroll", this.onScroll = function() {
209 |       var curScroll = cm.getScrollInfo(), editor = cm.getWrapperElement().getBoundingClientRect();
210 |       var newTop = top + startScroll.top - curScroll.top;
211 |       var point = newTop - (window.pageYOffset || (document.documentElement || document.body).scrollTop);
212 |       if (!below) point += hints.offsetHeight;
213 |       if (point <= editor.top || point >= editor.bottom) return completion.close();
214 |       hints.style.top = newTop + "px";
215 |       hints.style.left = (left + startScroll.left - curScroll.left) + "px";
216 |     });
217 | 
218 |     CodeMirror.on(hints, "dblclick", function(e) {
219 |       var t = e.target || e.srcElement;
220 |       if (t.hintId != null) {widget.changeActive(t.hintId); widget.pick();}
221 |     });
222 |     CodeMirror.on(hints, "click", function(e) {
223 |       var t = e.target || e.srcElement;
224 |       if (t.hintId != null) widget.changeActive(t.hintId);
225 |     });
226 |     CodeMirror.on(hints, "mousedown", function() {
227 |       setTimeout(function(){cm.focus();}, 20);
228 |     });
229 | 
230 |     CodeMirror.signal(data, "select", completions[0], hints.firstChild);
231 |     return true;
232 |   }
233 | 
234 |   Widget.prototype = {
235 |     close: function() {
236 |       if (this.completion.widget != this) return;
237 |       this.completion.widget = null;
238 |       this.hints.parentNode.removeChild(this.hints);
239 |       this.completion.cm.removeKeyMap(this.keyMap);
240 | 
241 |       var cm = this.completion.cm;
242 |       if (this.completion.options.closeOnUnfocus !== false) {
243 |         cm.off("blur", this.onBlur);
244 |         cm.off("focus", this.onFocus);
245 |       }
246 |       cm.off("scroll", this.onScroll);
247 |     },
248 | 
249 |     pick: function() {
250 |       this.completion.pick(this.data, this.selectedHint);
251 |     },
252 | 
253 |     changeActive: function(i, avoidWrap) {
254 |       if (i >= this.data.list.length)
255 |         i = avoidWrap ? this.data.list.length - 1 : 0;
256 |       else if (i < 0)
257 |         i = avoidWrap ? 0  : this.data.list.length - 1;
258 |       if (this.selectedHint == i) return;
259 |       var node = this.hints.childNodes[this.selectedHint];
260 |       node.className = node.className.replace(" CodeMirror-hint-active", "");
261 |       node = this.hints.childNodes[this.selectedHint = i];
262 |       node.className += " CodeMirror-hint-active";
263 |       if (node.offsetTop < this.hints.scrollTop)
264 |         this.hints.scrollTop = node.offsetTop - 3;
265 |       else if (node.offsetTop + node.offsetHeight > this.hints.scrollTop + this.hints.clientHeight)
266 |         this.hints.scrollTop = node.offsetTop + node.offsetHeight - this.hints.clientHeight + 3;
267 |       CodeMirror.signal(this.data, "select", this.data.list[this.selectedHint], node);
268 |     },
269 | 
270 |     screenAmount: function() {
271 |       return Math.floor(this.hints.clientHeight / this.hints.firstChild.offsetHeight) || 1;
272 |     }
273 |   };
274 | })();
275 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/sql-hint.js:
--------------------------------------------------------------------------------
  1 | (function () {
  2 |   "use strict";
  3 | 
  4 |   var tables;
  5 |   var keywords;
  6 | 
  7 |   function getKeywords(editor) {
  8 |     var mode = editor.doc.modeOption;
  9 |     if(mode === "sql") mode = "text/x-sql";
 10 |     return CodeMirror.resolveMode(mode).keywords;
 11 |   }
 12 | 
 13 |   function match(string, word) {
 14 |     var len = string.length;
 15 |     var sub = word.substr(0, len);
 16 |     return string.toUpperCase() === sub.toUpperCase();
 17 |   }
 18 | 
 19 |   function addMatches(result, search, wordlist, formatter) {
 20 |     for(var word in wordlist) {
 21 |       if(!wordlist.hasOwnProperty(word)) continue;
 22 |       if(Array.isArray(wordlist)) {
 23 |         word = wordlist[word];
 24 |       }
 25 |       if(match(search, word)) {
 26 |         result.push(formatter(word));
 27 |       }
 28 |     }
 29 |   }
 30 | 
 31 |   function columnCompletion(result, editor) {
 32 |     var cur = editor.getCursor();
 33 |     var token = editor.getTokenAt(cur);
 34 |     var string = token.string.substr(1);
 35 |     var prevCur = CodeMirror.Pos(cur.line, token.start);
 36 |     var table = editor.getTokenAt(prevCur).string;
 37 |     var columns = tables[table];
 38 |     if(!columns) {
 39 |       table = findTableByAlias(table, editor);
 40 |     }
 41 |     columns = tables[table];
 42 |     if(!columns) {
 43 |       return;
 44 |     }
 45 |     addMatches(result, string, columns,
 46 |         function(w) {return "." + w;});
 47 |   }
 48 | 
 49 |   function eachWord(line, f) {
 50 |     var words = line.text.split(" ");
 51 |     for(var i = 0; i < words.length; i++) {
 52 |       f(words[i]);
 53 |     }
 54 |   }
 55 | 
 56 |   // Tries to find possible table name from alias.
 57 |   function findTableByAlias(alias, editor) {
 58 |     var aliasUpperCase = alias.toUpperCase();
 59 |     var previousWord = "";
 60 |     var table = "";
 61 | 
 62 |     editor.eachLine(function(line) {
 63 |       eachWord(line, function(word) {
 64 |         var wordUpperCase = word.toUpperCase();
 65 |         if(wordUpperCase === aliasUpperCase) {
 66 |           if(tables.hasOwnProperty(previousWord)) {
 67 |             table = previousWord;
 68 |           }
 69 |         }
 70 |         if(wordUpperCase !== "AS") {
 71 |           previousWord = word;
 72 |         }
 73 |       });
 74 |     });
 75 |     return table;
 76 |   }
 77 | 
 78 |   function sqlHint(editor, options) {
 79 |     tables = (options && options.tables) || {};
 80 |     keywords = keywords || getKeywords(editor);
 81 |     var cur = editor.getCursor();
 82 |     var token = editor.getTokenAt(cur);
 83 | 
 84 |     var result = [];
 85 | 
 86 |     var search = token.string.trim();
 87 | 
 88 |     addMatches(result, search, keywords,
 89 |         function(w) {return w.toUpperCase();});
 90 | 
 91 |     addMatches(result, search, tables,
 92 |         function(w) {return w;});
 93 | 
 94 |     if(search.lastIndexOf('.') === 0) {
 95 |       columnCompletion(result, editor);
 96 |     }
 97 | 
 98 |     return {
 99 |       list: result,
100 |         from: CodeMirror.Pos(cur.line, token.start),
101 |         to: CodeMirror.Pos(cur.line, token.end)
102 |     };
103 |   }
104 |   CodeMirror.registerHelper("hint", "sql", sqlHint);
105 | })();
106 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/hint/xml-hint.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   "use strict";
 3 | 
 4 |   var Pos = CodeMirror.Pos;
 5 | 
 6 |   function getHints(cm, options) {
 7 |     var tags = options && options.schemaInfo;
 8 |     var quote = (options && options.quoteChar) || '"';
 9 |     if (!tags) return;
10 |     var cur = cm.getCursor(), token = cm.getTokenAt(cur);
11 |     var inner = CodeMirror.innerMode(cm.getMode(), token.state);
12 |     if (inner.mode.name != "xml") return;
13 |     var result = [], replaceToken = false, prefix;
14 |     var isTag = token.string.charAt(0) == "<";
15 |     if (!inner.state.tagName || isTag) { // Tag completion
16 |       if (isTag) {
17 |         prefix = token.string.slice(1);
18 |         replaceToken = true;
19 |       }
20 |       var cx = inner.state.context, curTag = cx && tags[cx.tagName];
21 |       var childList = cx ? curTag && curTag.children : tags["!top"];
22 |       if (childList) {
23 |         for (var i = 0; i < childList.length; ++i) if (!prefix || childList[i].indexOf(prefix) == 0)
24 |           result.push("<" + childList[i]);
25 |       } else {
26 |         for (var name in tags) if (tags.hasOwnProperty(name) && name != "!top" && (!prefix || name.indexOf(prefix) == 0))
27 |           result.push("<" + name);
28 |       }
29 |       if (cx && (!prefix || ("/" + cx.tagName).indexOf(prefix) == 0))
30 |         result.push("</" + cx.tagName + ">");
31 |     } else {
32 |       // Attribute completion
33 |       var curTag = tags[inner.state.tagName], attrs = curTag && curTag.attrs;
34 |       if (!attrs) return;
35 |       if (token.type == "string" || token.string == "=") { // A value
36 |         var before = cm.getRange(Pos(cur.line, Math.max(0, cur.ch - 60)),
37 |                                  Pos(cur.line, token.type == "string" ? token.start : token.end));
38 |         var atName = before.match(/([^\s\u00a0=<>\"\']+)=$/), atValues;
39 |         if (!atName || !attrs.hasOwnProperty(atName[1]) || !(atValues = attrs[atName[1]])) return;
40 |         if (typeof atValues == 'function') atValues = atValues.call(this, cm); // Functions can be used to supply values for autocomplete widget
41 |         if (token.type == "string") {
42 |           prefix = token.string;
43 |           if (/['"]/.test(token.string.charAt(0))) {
44 |             quote = token.string.charAt(0);
45 |             prefix = token.string.slice(1);
46 |           }
47 |           replaceToken = true;
48 |         }
49 |         for (var i = 0; i < atValues.length; ++i) if (!prefix || atValues[i].indexOf(prefix) == 0)
50 |           result.push(quote + atValues[i] + quote);
51 |       } else { // An attribute name
52 |         if (token.type == "attribute") {
53 |           prefix = token.string;
54 |           replaceToken = true;
55 |         }
56 |         for (var attr in attrs) if (attrs.hasOwnProperty(attr) && (!prefix || attr.indexOf(prefix) == 0))
57 |           result.push(attr);
58 |       }
59 |     }
60 |     return {
61 |       list: result,
62 |       from: replaceToken ? Pos(cur.line, token.start) : cur,
63 |       to: replaceToken ? Pos(cur.line, token.end) : cur
64 |     };
65 |   }
66 | 
67 |   CodeMirror.xmlHint = getHints; // deprecated
68 |   CodeMirror.registerHelper("hint", "xml", getHints);
69 | })();
70 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/lint/coffeescript-lint.js:
--------------------------------------------------------------------------------
 1 | // Depends on coffeelint.js from http://www.coffeelint.org/js/coffeelint.js
 2 | 
 3 | // declare global: coffeelint
 4 | 
 5 | CodeMirror.registerHelper("lint", "coffeescript", function(text) {
 6 |   var found = [];
 7 |   var parseError = function(err) {
 8 |     var loc = err.lineNumber;
 9 |     found.push({from: CodeMirror.Pos(loc-1, 0),
10 |                 to: CodeMirror.Pos(loc, 0),
11 |                 severity: err.level,
12 |                 message: err.message});
13 |   };
14 |   try {
15 |     var res = coffeelint.lint(text);
16 |     for(var i = 0; i < res.length; i++) {
17 |       parseError(res[i]);
18 |     }
19 |   } catch(e) {
20 |     found.push({from: CodeMirror.Pos(e.location.first_line, 0),
21 |                 to: CodeMirror.Pos(e.location.last_line, e.location.last_column),
22 |                 severity: 'error',
23 |                 message: e.message});
24 |   }
25 |   return found;
26 | });
27 | CodeMirror.coffeeValidator = CodeMirror.lint.coffeescript; // deprecated
28 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/lint/css-lint.js:
--------------------------------------------------------------------------------
 1 | // Depends on csslint.js from https://github.com/stubbornella/csslint
 2 | 
 3 | // declare global: CSSLint
 4 | 
 5 | CodeMirror.registerHelper("lint", "css", function(text) {
 6 |   var found = [];
 7 |   var results = CSSLint.verify(text), messages = results.messages, message = null;
 8 |   for ( var i = 0; i < messages.length; i++) {
 9 |     message = messages[i];
10 |     var startLine = message.line -1, endLine = message.line -1, startCol = message.col -1, endCol = message.col;
11 |     found.push({
12 |       from: CodeMirror.Pos(startLine, startCol),
13 |       to: CodeMirror.Pos(endLine, endCol),
14 |       message: message.message,
15 |       severity : message.type
16 |     });
17 |   }
18 |   return found;
19 | });
20 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/lint/javascript-lint.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   "use strict";
  3 |   // declare global: JSHINT
  4 | 
  5 |   var bogus = [ "Dangerous comment" ];
  6 | 
  7 |   var warnings = [ [ "Expected '{'",
  8 |                      "Statement body should be inside '{ }' braces." ] ];
  9 | 
 10 |   var errors = [ "Missing semicolon", "Extra comma", "Missing property name",
 11 |                  "Unmatched ", " and instead saw", " is not defined",
 12 |                  "Unclosed string", "Stopping, unable to continue" ];
 13 | 
 14 |   function validator(text, options) {
 15 |     JSHINT(text, options);
 16 |     var errors = JSHINT.data().errors, result = [];
 17 |     if (errors) parseErrors(errors, result);
 18 |     return result;
 19 |   }
 20 | 
 21 |   CodeMirror.registerHelper("lint", "javascript", validator);
 22 |   CodeMirror.javascriptValidator = CodeMirror.lint.javascript; // deprecated
 23 | 
 24 |   function cleanup(error) {
 25 |     // All problems are warnings by default
 26 |     fixWith(error, warnings, "warning", true);
 27 |     fixWith(error, errors, "error");
 28 | 
 29 |     return isBogus(error) ? null : error;
 30 |   }
 31 | 
 32 |   function fixWith(error, fixes, severity, force) {
 33 |     var description, fix, find, replace, found;
 34 | 
 35 |     description = error.description;
 36 | 
 37 |     for ( var i = 0; i < fixes.length; i++) {
 38 |       fix = fixes[i];
 39 |       find = (typeof fix === "string" ? fix : fix[0]);
 40 |       replace = (typeof fix === "string" ? null : fix[1]);
 41 |       found = description.indexOf(find) !== -1;
 42 | 
 43 |       if (force || found) {
 44 |         error.severity = severity;
 45 |       }
 46 |       if (found && replace) {
 47 |         error.description = replace;
 48 |       }
 49 |     }
 50 |   }
 51 | 
 52 |   function isBogus(error) {
 53 |     var description = error.description;
 54 |     for ( var i = 0; i < bogus.length; i++) {
 55 |       if (description.indexOf(bogus[i]) !== -1) {
 56 |         return true;
 57 |       }
 58 |     }
 59 |     return false;
 60 |   }
 61 | 
 62 |   function parseErrors(errors, output) {
 63 |     for ( var i = 0; i < errors.length; i++) {
 64 |       var error = errors[i];
 65 |       if (error) {
 66 |         var linetabpositions, index;
 67 | 
 68 |         linetabpositions = [];
 69 | 
 70 |         // This next block is to fix a problem in jshint. Jshint
 71 |         // replaces
 72 |         // all tabs with spaces then performs some checks. The error
 73 |         // positions (character/space) are then reported incorrectly,
 74 |         // not taking the replacement step into account. Here we look
 75 |         // at the evidence line and try to adjust the character position
 76 |         // to the correct value.
 77 |         if (error.evidence) {
 78 |           // Tab positions are computed once per line and cached
 79 |           var tabpositions = linetabpositions[error.line];
 80 |           if (!tabpositions) {
 81 |             var evidence = error.evidence;
 82 |             tabpositions = [];
 83 |             // ugggh phantomjs does not like this
 84 |             // forEachChar(evidence, function(item, index) {
 85 |             Array.prototype.forEach.call(evidence, function(item,
 86 |                                                             index) {
 87 |               if (item === '\t') {
 88 |                 // First col is 1 (not 0) to match error
 89 |                 // positions
 90 |                 tabpositions.push(index + 1);
 91 |               }
 92 |             });
 93 |             linetabpositions[error.line] = tabpositions;
 94 |           }
 95 |           if (tabpositions.length > 0) {
 96 |             var pos = error.character;
 97 |             tabpositions.forEach(function(tabposition) {
 98 |               if (pos > tabposition) pos -= 1;
 99 |             });
100 |             error.character = pos;
101 |           }
102 |         }
103 | 
104 |         var start = error.character - 1, end = start + 1;
105 |         if (error.evidence) {
106 |           index = error.evidence.substring(start).search(/.\b/);
107 |           if (index > -1) {
108 |             end += index;
109 |           }
110 |         }
111 | 
112 |         // Convert to format expected by validation service
113 |         error.description = error.reason;// + "(jshint)";
114 |         error.start = error.character;
115 |         error.end = end;
116 |         error = cleanup(error);
117 | 
118 |         if (error)
119 |           output.push({message: error.description,
120 |                        severity: error.severity,
121 |                        from: CodeMirror.Pos(error.line - 1, start),
122 |                        to: CodeMirror.Pos(error.line - 1, end)});
123 |       }
124 |     }
125 |   }
126 | })();
127 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/lint/json-lint.js:
--------------------------------------------------------------------------------
 1 | // Depends on jsonlint.js from https://github.com/zaach/jsonlint
 2 | 
 3 | // declare global: jsonlint
 4 | 
 5 | CodeMirror.registerHelper("lint", "json", function(text) {
 6 |   var found = [];
 7 |   jsonlint.parseError = function(str, hash) {
 8 |     var loc = hash.loc;
 9 |     found.push({from: CodeMirror.Pos(loc.first_line - 1, loc.first_column),
10 |                 to: CodeMirror.Pos(loc.last_line - 1, loc.last_column),
11 |                 message: str});
12 |   };
13 |   try { jsonlint.parse(text); }
14 |   catch(e) {}
15 |   return found;
16 | });
17 | CodeMirror.jsonValidator = CodeMirror.lint.json; // deprecated
18 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/lint/lint.css:
--------------------------------------------------------------------------------
 1 | /* The lint marker gutter */
 2 | .CodeMirror-lint-markers {
 3 |   width: 16px;
 4 | }
 5 | 
 6 | .CodeMirror-lint-tooltip {
 7 |   background-color: infobackground;
 8 |   border: 1px solid black;
 9 |   border-radius: 4px 4px 4px 4px;
10 |   color: infotext;
11 |   font-family: monospace;
12 |   font-size: 10pt;
13 |   overflow: hidden;
14 |   padding: 2px 5px;
15 |   position: fixed;
16 |   white-space: pre;
17 |   white-space: pre-wrap;
18 |   z-index: 100;
19 |   max-width: 600px;
20 |   opacity: 0;
21 |   transition: opacity .4s;
22 |   -moz-transition: opacity .4s;
23 |   -webkit-transition: opacity .4s;
24 |   -o-transition: opacity .4s;
25 |   -ms-transition: opacity .4s;
26 | }
27 | 
28 | .CodeMirror-lint-mark-error, .CodeMirror-lint-mark-warning {
29 |   background-position: left bottom;
30 |   background-repeat: repeat-x;
31 | }
32 | 
33 | .CodeMirror-lint-mark-error {
34 |   background-image:
35 |   url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJDw4cOCW1/KIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAHElEQVQI12NggIL/DAz/GdA5/xkY/qPKMDAwAADLZwf5rvm+LQAAAABJRU5ErkJggg==")
36 |   ;
37 | }
38 | 
39 | .CodeMirror-lint-mark-warning {
40 |   background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJFhQXEbhTg7YAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAMklEQVQI12NkgIIvJ3QXMjAwdDN+OaEbysDA4MPAwNDNwMCwiOHLCd1zX07o6kBVGQEAKBANtobskNMAAAAASUVORK5CYII=");
41 | }
42 | 
43 | .CodeMirror-lint-marker-error, .CodeMirror-lint-marker-warning {
44 |   background-position: center center;
45 |   background-repeat: no-repeat;
46 |   cursor: pointer;
47 |   display: inline-block;
48 |   height: 16px;
49 |   width: 16px;
50 |   vertical-align: middle;
51 |   position: relative;
52 | }
53 | 
54 | .CodeMirror-lint-message-error, .CodeMirror-lint-message-warning {
55 |   padding-left: 18px;
56 |   background-position: top left;
57 |   background-repeat: no-repeat;
58 | }
59 | 
60 | .CodeMirror-lint-marker-error, .CodeMirror-lint-message-error {
61 |   background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAHlBMVEW7AAC7AACxAAC7AAC7AAAAAAC4AAC5AAD///+7AAAUdclpAAAABnRSTlMXnORSiwCK0ZKSAAAATUlEQVR42mWPOQ7AQAgDuQLx/z8csYRmPRIFIwRGnosRrpamvkKi0FTIiMASR3hhKW+hAN6/tIWhu9PDWiTGNEkTtIOucA5Oyr9ckPgAWm0GPBog6v4AAAAASUVORK5CYII=");
62 | }
63 | 
64 | .CodeMirror-lint-marker-warning, .CodeMirror-lint-message-warning {
65 |   background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAANlBMVEX/uwDvrwD/uwD/uwD/uwD/uwD/uwD/uwD/uwD6twD/uwAAAADurwD2tQD7uAD+ugAAAAD/uwDhmeTRAAAADHRSTlMJ8mN1EYcbmiixgACm7WbuAAAAVklEQVR42n3PUQqAIBBFUU1LLc3u/jdbOJoW1P08DA9Gba8+YWJ6gNJoNYIBzAA2chBth5kLmG9YUoG0NHAUwFXwO9LuBQL1giCQb8gC9Oro2vp5rncCIY8L8uEx5ZkAAAAASUVORK5CYII=");
66 | }
67 | 
68 | .CodeMirror-lint-marker-multiple {
69 |   background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAAHCAMAAADzjKfhAAAACVBMVEUAAAAAAAC/v7914kyHAAAAAXRSTlMAQObYZgAAACNJREFUeNo1ioEJAAAIwmz/H90iFFSGJgFMe3gaLZ0od+9/AQZ0ADosbYraAAAAAElFTkSuQmCC");
70 |   background-repeat: no-repeat;
71 |   background-position: right bottom;
72 |   width: 100%; height: 100%;
73 | }
74 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/lint/lint.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   "use strict";
  3 |   var GUTTER_ID = "CodeMirror-lint-markers";
  4 |   var SEVERITIES = /^(?:error|warning)$/;
  5 | 
  6 |   function showTooltip(e, content) {
  7 |     var tt = document.createElement("div");
  8 |     tt.className = "CodeMirror-lint-tooltip";
  9 |     tt.appendChild(content.cloneNode(true));
 10 |     document.body.appendChild(tt);
 11 | 
 12 |     function position(e) {
 13 |       if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position);
 14 |       tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
 15 |       tt.style.left = (e.clientX + 5) + "px";
 16 |     }
 17 |     CodeMirror.on(document, "mousemove", position);
 18 |     position(e);
 19 |     if (tt.style.opacity != null) tt.style.opacity = 1;
 20 |     return tt;
 21 |   }
 22 |   function rm(elt) {
 23 |     if (elt.parentNode) elt.parentNode.removeChild(elt);
 24 |   }
 25 |   function hideTooltip(tt) {
 26 |     if (!tt.parentNode) return;
 27 |     if (tt.style.opacity == null) rm(tt);
 28 |     tt.style.opacity = 0;
 29 |     setTimeout(function() { rm(tt); }, 600);
 30 |   }
 31 | 
 32 |   function showTooltipFor(e, content, node) {
 33 |     var tooltip = showTooltip(e, content);
 34 |     function hide() {
 35 |       CodeMirror.off(node, "mouseout", hide);
 36 |       if (tooltip) { hideTooltip(tooltip); tooltip = null; }
 37 |     }
 38 |     var poll = setInterval(function() {
 39 |       if (tooltip) for (var n = node;; n = n.parentNode) {
 40 |         if (n == document.body) return;
 41 |         if (!n) { hide(); break; }
 42 |       }
 43 |       if (!tooltip) return clearInterval(poll);
 44 |     }, 400);
 45 |     CodeMirror.on(node, "mouseout", hide);
 46 |   }
 47 | 
 48 |   function LintState(cm, options, hasGutter) {
 49 |     this.marked = [];
 50 |     this.options = options;
 51 |     this.timeout = null;
 52 |     this.hasGutter = hasGutter;
 53 |     this.onMouseOver = function(e) { onMouseOver(cm, e); };
 54 |   }
 55 | 
 56 |   function parseOptions(cm, options) {
 57 |     if (options instanceof Function) return {getAnnotations: options};
 58 |     if (!options || options === true) options = {};
 59 |     if (!options.getAnnotations) options.getAnnotations = cm.getHelper(CodeMirror.Pos(0, 0), "lint");
 60 |     if (!options.getAnnotations) throw new Error("Required option 'getAnnotations' missing (lint addon)");
 61 |     return options;
 62 |   }
 63 | 
 64 |   function clearMarks(cm) {
 65 |     var state = cm.state.lint;
 66 |     if (state.hasGutter) cm.clearGutter(GUTTER_ID);
 67 |     for (var i = 0; i < state.marked.length; ++i)
 68 |       state.marked[i].clear();
 69 |     state.marked.length = 0;
 70 |   }
 71 | 
 72 |   function makeMarker(labels, severity, multiple, tooltips) {
 73 |     var marker = document.createElement("div"), inner = marker;
 74 |     marker.className = "CodeMirror-lint-marker-" + severity;
 75 |     if (multiple) {
 76 |       inner = marker.appendChild(document.createElement("div"));
 77 |       inner.className = "CodeMirror-lint-marker-multiple";
 78 |     }
 79 | 
 80 |     if (tooltips != false) CodeMirror.on(inner, "mouseover", function(e) {
 81 |       showTooltipFor(e, labels, inner);
 82 |     });
 83 | 
 84 |     return marker;
 85 |   }
 86 | 
 87 |   function getMaxSeverity(a, b) {
 88 |     if (a == "error") return a;
 89 |     else return b;
 90 |   }
 91 | 
 92 |   function groupByLine(annotations) {
 93 |     var lines = [];
 94 |     for (var i = 0; i < annotations.length; ++i) {
 95 |       var ann = annotations[i], line = ann.from.line;
 96 |       (lines[line] || (lines[line] = [])).push(ann);
 97 |     }
 98 |     return lines;
 99 |   }
100 | 
101 |   function annotationTooltip(ann) {
102 |     var severity = ann.severity;
103 |     if (!SEVERITIES.test(severity)) severity = "error";
104 |     var tip = document.createElement("div");
105 |     tip.className = "CodeMirror-lint-message-" + severity;
106 |     tip.appendChild(document.createTextNode(ann.message));
107 |     return tip;
108 |   }
109 | 
110 |   function startLinting(cm) {
111 |     var state = cm.state.lint, options = state.options;
112 |     if (options.async)
113 |       options.getAnnotations(cm, updateLinting, options);
114 |     else
115 |       updateLinting(cm, options.getAnnotations(cm.getValue(), options));
116 |   }
117 | 
118 |   function updateLinting(cm, annotationsNotSorted) {
119 |     clearMarks(cm);
120 |     var state = cm.state.lint, options = state.options;
121 | 
122 |     var annotations = groupByLine(annotationsNotSorted);
123 | 
124 |     for (var line = 0; line < annotations.length; ++line) {
125 |       var anns = annotations[line];
126 |       if (!anns) continue;
127 | 
128 |       var maxSeverity = null;
129 |       var tipLabel = state.hasGutter && document.createDocumentFragment();
130 | 
131 |       for (var i = 0; i < anns.length; ++i) {
132 |         var ann = anns[i];
133 |         var severity = ann.severity;
134 |         if (!SEVERITIES.test(severity)) severity = "error";
135 |         maxSeverity = getMaxSeverity(maxSeverity, severity);
136 | 
137 |         if (options.formatAnnotation) ann = options.formatAnnotation(ann);
138 |         if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));
139 | 
140 |         if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, {
141 |           className: "CodeMirror-lint-mark-" + severity,
142 |           __annotation: ann
143 |         }));
144 |       }
145 | 
146 |       if (state.hasGutter)
147 |         cm.setGutterMarker(line, GUTTER_ID, makeMarker(tipLabel, maxSeverity, anns.length > 1,
148 |                                                        state.options.tooltips));
149 |     }
150 |     if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
151 |   }
152 | 
153 |   function onChange(cm) {
154 |     var state = cm.state.lint;
155 |     clearTimeout(state.timeout);
156 |     state.timeout = setTimeout(function(){startLinting(cm);}, state.options.delay || 500);
157 |   }
158 | 
159 |   function popupSpanTooltip(ann, e) {
160 |     var target = e.target || e.srcElement;
161 |     showTooltipFor(e, annotationTooltip(ann), target);
162 |   }
163 | 
164 |   // When the mouseover fires, the cursor might not actually be over
165 |   // the character itself yet. These pairs of x,y offsets are used to
166 |   // probe a few nearby points when no suitable marked range is found.
167 |   var nearby = [0, 0, 0, 5, 0, -5, 5, 0, -5, 0];
168 | 
169 |   function onMouseOver(cm, e) {
170 |     if (!/\bCodeMirror-lint-mark-/.test((e.target || e.srcElement).className)) return;
171 |     for (var i = 0; i < nearby.length; i += 2) {
172 |       var spans = cm.findMarksAt(cm.coordsChar({left: e.clientX + nearby[i],
173 |                                                 top: e.clientY + nearby[i + 1]}));
174 |       for (var j = 0; j < spans.length; ++j) {
175 |         var span = spans[j], ann = span.__annotation;
176 |         if (ann) return popupSpanTooltip(ann, e);
177 |       }
178 |     }
179 |   }
180 | 
181 |   function optionHandler(cm, val, old) {
182 |     if (old && old != CodeMirror.Init) {
183 |       clearMarks(cm);
184 |       cm.off("change", onChange);
185 |       CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver);
186 |       delete cm.state.lint;
187 |     }
188 | 
189 |     if (val) {
190 |       var gutters = cm.getOption("gutters"), hasLintGutter = false;
191 |       for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
192 |       var state = cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter);
193 |       cm.on("change", onChange);
194 |       if (state.options.tooltips != false)
195 |         CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);
196 | 
197 |       startLinting(cm);
198 |     }
199 |   }
200 | 
201 |   CodeMirror.defineOption("lintWith", false, optionHandler); // deprecated
202 |   CodeMirror.defineOption("lint", false, optionHandler); // deprecated
203 | })();
204 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/merge/merge.css:
--------------------------------------------------------------------------------
 1 | .CodeMirror-merge {
 2 |   position: relative;
 3 |   border: 1px solid #ddd;
 4 |   white-space: pre;
 5 | }
 6 | 
 7 | .CodeMirror-merge, .CodeMirror-merge .CodeMirror {
 8 |   height: 350px;
 9 | }
10 | 
11 | .CodeMirror-merge-2pane .CodeMirror-merge-pane { width: 47%; }
12 | .CodeMirror-merge-2pane .CodeMirror-merge-gap { width: 6%; }
13 | .CodeMirror-merge-3pane .CodeMirror-merge-pane { width: 31%; }
14 | .CodeMirror-merge-3pane .CodeMirror-merge-gap { width: 3.5%; }
15 | 
16 | .CodeMirror-merge-pane {
17 |   display: inline-block;
18 |   white-space: normal;
19 |   vertical-align: top;
20 | }
21 | .CodeMirror-merge-pane-rightmost {
22 |   position: absolute;
23 |   right: 0px;
24 |   z-index: 1;
25 | }
26 | 
27 | .CodeMirror-merge-gap {
28 |   z-index: 2;
29 |   display: inline-block;
30 |   height: 100%;
31 |   -moz-box-sizing: border-box;
32 |   box-sizing: border-box;
33 |   overflow: hidden;
34 |   border-left: 1px solid #ddd;
35 |   border-right: 1px solid #ddd;
36 |   position: relative;
37 |   background: #f8f8f8;
38 | }
39 | 
40 | .CodeMirror-merge-scrolllock-wrap {
41 |   position: absolute;
42 |   bottom: 0; left: 50%;
43 | }
44 | .CodeMirror-merge-scrolllock {
45 |   position: relative;
46 |   left: -50%;
47 |   cursor: pointer;
48 |   color: #555;
49 |   line-height: 1;
50 | }
51 | 
52 | .CodeMirror-merge-copybuttons-left, .CodeMirror-merge-copybuttons-right {
53 |   position: absolute;
54 |   left: 0; top: 0;
55 |   right: 0; bottom: 0;
56 |   line-height: 1;
57 | }
58 | 
59 | .CodeMirror-merge-copy {
60 |   position: absolute;
61 |   cursor: pointer;
62 |   color: #44c;
63 | }
64 | 
65 | .CodeMirror-merge-copybuttons-left .CodeMirror-merge-copy { left: 2px; }
66 | .CodeMirror-merge-copybuttons-right .CodeMirror-merge-copy { right: 2px; }
67 | 
68 | .CodeMirror-merge-r-inserted, .CodeMirror-merge-l-inserted {
69 |   background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12MwuCXy3+CWyH8GBgYGJgYkAABZbAQ9ELXurwAAAABJRU5ErkJggg==);
70 |   background-position: bottom left;
71 |   background-repeat: repeat-x;
72 | }
73 | 
74 | .CodeMirror-merge-r-deleted, .CodeMirror-merge-l-deleted {
75 |   background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12M4Kyb2/6yY2H8GBgYGJgYkAABURgPz6Ks7wQAAAABJRU5ErkJggg==);
76 |   background-position: bottom left;
77 |   background-repeat: repeat-x;
78 | }
79 | 
80 | .CodeMirror-merge-r-chunk { background: #ffffe0; }
81 | .CodeMirror-merge-r-chunk-start { border-top: 1px solid #ee8; }
82 | .CodeMirror-merge-r-chunk-end { border-bottom: 1px solid #ee8; }
83 | .CodeMirror-merge-r-connect { fill: #ffffe0; stroke: #ee8; stroke-width: 1px; }
84 | 
85 | .CodeMirror-merge-l-chunk { background: #eef; }
86 | .CodeMirror-merge-l-chunk-start { border-top: 1px solid #88e; }
87 | .CodeMirror-merge-l-chunk-end { border-bottom: 1px solid #88e; }
88 | .CodeMirror-merge-l-connect { fill: #eef; stroke: #88e; stroke-width: 1px; }
89 | 
90 | .CodeMirror-merge-l-chunk.CodeMirror-merge-r-chunk { background: #dfd; }
91 | .CodeMirror-merge-l-chunk-start.CodeMirror-merge-r-chunk-start { border-top: 1px solid #4e4; }
92 | .CodeMirror-merge-l-chunk-end.CodeMirror-merge-r-chunk-end { border-bottom: 1px solid #4e4; }
93 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/mode/loadmode.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   if (!CodeMirror.modeURL) CodeMirror.modeURL = "../mode/%N/%N.js";
 3 | 
 4 |   var loading = {};
 5 |   function splitCallback(cont, n) {
 6 |     var countDown = n;
 7 |     return function() { if (--countDown == 0) cont(); };
 8 |   }
 9 |   function ensureDeps(mode, cont) {
10 |     var deps = CodeMirror.modes[mode].dependencies;
11 |     if (!deps) return cont();
12 |     var missing = [];
13 |     for (var i = 0; i < deps.length; ++i) {
14 |       if (!CodeMirror.modes.hasOwnProperty(deps[i]))
15 |         missing.push(deps[i]);
16 |     }
17 |     if (!missing.length) return cont();
18 |     var split = splitCallback(cont, missing.length);
19 |     for (var i = 0; i < missing.length; ++i)
20 |       CodeMirror.requireMode(missing[i], split);
21 |   }
22 | 
23 |   CodeMirror.requireMode = function(mode, cont) {
24 |     if (typeof mode != "string") mode = mode.name;
25 |     if (CodeMirror.modes.hasOwnProperty(mode)) return ensureDeps(mode, cont);
26 |     if (loading.hasOwnProperty(mode)) return loading[mode].push(cont);
27 | 
28 |     var script = document.createElement("script");
29 |     script.src = CodeMirror.modeURL.replace(/%N/g, mode);
30 |     var others = document.getElementsByTagName("script")[0];
31 |     others.parentNode.insertBefore(script, others);
32 |     var list = loading[mode] = [cont];
33 |     var count = 0, poll = setInterval(function() {
34 |       if (++count > 100) return clearInterval(poll);
35 |       if (CodeMirror.modes.hasOwnProperty(mode)) {
36 |         clearInterval(poll);
37 |         loading[mode] = null;
38 |         ensureDeps(mode, function() {
39 |           for (var i = 0; i < list.length; ++i) list[i]();
40 |         });
41 |       }
42 |     }, 200);
43 |   };
44 | 
45 |   CodeMirror.autoLoadMode = function(instance, mode) {
46 |     if (!CodeMirror.modes.hasOwnProperty(mode))
47 |       CodeMirror.requireMode(mode, function() {
48 |         instance.setOption("mode", instance.getOption("mode"));
49 |       });
50 |   };
51 | }());
52 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/mode/multiplex.js:
--------------------------------------------------------------------------------
  1 | CodeMirror.multiplexingMode = function(outer /*, others */) {
  2 |   // Others should be {open, close, mode [, delimStyle] [, innerStyle]} objects
  3 |   var others = Array.prototype.slice.call(arguments, 1);
  4 |   var n_others = others.length;
  5 | 
  6 |   function indexOf(string, pattern, from) {
  7 |     if (typeof pattern == "string") return string.indexOf(pattern, from);
  8 |     var m = pattern.exec(from ? string.slice(from) : string);
  9 |     return m ? m.index + from : -1;
 10 |   }
 11 | 
 12 |   return {
 13 |     startState: function() {
 14 |       return {
 15 |         outer: CodeMirror.startState(outer),
 16 |         innerActive: null,
 17 |         inner: null
 18 |       };
 19 |     },
 20 | 
 21 |     copyState: function(state) {
 22 |       return {
 23 |         outer: CodeMirror.copyState(outer, state.outer),
 24 |         innerActive: state.innerActive,
 25 |         inner: state.innerActive && CodeMirror.copyState(state.innerActive.mode, state.inner)
 26 |       };
 27 |     },
 28 | 
 29 |     token: function(stream, state) {
 30 |       if (!state.innerActive) {
 31 |         var cutOff = Infinity, oldContent = stream.string;
 32 |         for (var i = 0; i < n_others; ++i) {
 33 |           var other = others[i];
 34 |           var found = indexOf(oldContent, other.open, stream.pos);
 35 |           if (found == stream.pos) {
 36 |             stream.match(other.open);
 37 |             state.innerActive = other;
 38 |             state.inner = CodeMirror.startState(other.mode, outer.indent ? outer.indent(state.outer, "") : 0);
 39 |             return other.delimStyle;
 40 |           } else if (found != -1 && found < cutOff) {
 41 |             cutOff = found;
 42 |           }
 43 |         }
 44 |         if (cutOff != Infinity) stream.string = oldContent.slice(0, cutOff);
 45 |         var outerToken = outer.token(stream, state.outer);
 46 |         if (cutOff != Infinity) stream.string = oldContent;
 47 |         return outerToken;
 48 |       } else {
 49 |         var curInner = state.innerActive, oldContent = stream.string;
 50 |         var found = indexOf(oldContent, curInner.close, stream.pos);
 51 |         if (found == stream.pos) {
 52 |           stream.match(curInner.close);
 53 |           state.innerActive = state.inner = null;
 54 |           return curInner.delimStyle;
 55 |         }
 56 |         if (found > -1) stream.string = oldContent.slice(0, found);
 57 |         var innerToken = curInner.mode.token(stream, state.inner);
 58 |         if (found > -1) stream.string = oldContent;
 59 |         var cur = stream.current(), found = cur.indexOf(curInner.close);
 60 |         if (found > -1) stream.backUp(cur.length - found);
 61 | 
 62 |         if (curInner.innerStyle) {
 63 |           if (innerToken) innerToken = innerToken + ' ' + curInner.innerStyle;
 64 |           else innerToken = curInner.innerStyle;
 65 |         }
 66 | 
 67 |         return innerToken;
 68 |       }
 69 |     },
 70 | 
 71 |     indent: function(state, textAfter) {
 72 |       var mode = state.innerActive ? state.innerActive.mode : outer;
 73 |       if (!mode.indent) return CodeMirror.Pass;
 74 |       return mode.indent(state.innerActive ? state.inner : state.outer, textAfter);
 75 |     },
 76 | 
 77 |     blankLine: function(state) {
 78 |       var mode = state.innerActive ? state.innerActive.mode : outer;
 79 |       if (mode.blankLine) {
 80 |         mode.blankLine(state.innerActive ? state.inner : state.outer);
 81 |       }
 82 |       if (!state.innerActive) {
 83 |         for (var i = 0; i < n_others; ++i) {
 84 |           var other = others[i];
 85 |           if (other.open === "\n") {
 86 |             state.innerActive = other;
 87 |             state.inner = CodeMirror.startState(other.mode, mode.indent ? mode.indent(state.outer, "") : 0);
 88 |           }
 89 |         }
 90 |       } else if (state.innerActive.close === "\n") {
 91 |         state.innerActive = state.inner = null;
 92 |       }
 93 |     },
 94 | 
 95 |     electricChars: outer.electricChars,
 96 | 
 97 |     innerMode: function(state) {
 98 |       return state.inner ? {state: state.inner, mode: state.innerActive.mode} : {state: state.outer, mode: outer};
 99 |     }
100 |   };
101 | };
102 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/mode/multiplex_test.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   CodeMirror.defineMode("markdown_with_stex", function(){
 3 |     var inner = CodeMirror.getMode({}, "stex");
 4 |     var outer = CodeMirror.getMode({}, "markdown");
 5 | 
 6 |     var innerOptions = {
 7 |       open: '$',
 8 |       close: '$',
 9 |       mode: inner,
10 |       delimStyle: 'delim',
11 |       innerStyle: 'inner'
12 |     };
13 | 
14 |     return CodeMirror.multiplexingMode(outer, innerOptions);
15 |   });
16 | 
17 |   var mode = CodeMirror.getMode({}, "markdown_with_stex");
18 | 
19 |   function MT(name) {
20 |     test.mode(
21 |       name,
22 |       mode,
23 |       Array.prototype.slice.call(arguments, 1),
24 |       'multiplexing');
25 |   }
26 | 
27 |   MT(
28 |     "stexInsideMarkdown",
29 |     "[strong **Equation:**] [delim $][inner&tag \\pi][delim $]");
30 | })();
31 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/mode/overlay.js:
--------------------------------------------------------------------------------
 1 | // Utility function that allows modes to be combined. The mode given
 2 | // as the base argument takes care of most of the normal mode
 3 | // functionality, but a second (typically simple) mode is used, which
 4 | // can override the style of text. Both modes get to parse all of the
 5 | // text, but when both assign a non-null style to a piece of code, the
 6 | // overlay wins, unless the combine argument was true, in which case
 7 | // the styles are combined.
 8 | 
 9 | // overlayParser is the old, deprecated name
10 | CodeMirror.overlayMode = CodeMirror.overlayParser = function(base, overlay, combine) {
11 |   return {
12 |     startState: function() {
13 |       return {
14 |         base: CodeMirror.startState(base),
15 |         overlay: CodeMirror.startState(overlay),
16 |         basePos: 0, baseCur: null,
17 |         overlayPos: 0, overlayCur: null
18 |       };
19 |     },
20 |     copyState: function(state) {
21 |       return {
22 |         base: CodeMirror.copyState(base, state.base),
23 |         overlay: CodeMirror.copyState(overlay, state.overlay),
24 |         basePos: state.basePos, baseCur: null,
25 |         overlayPos: state.overlayPos, overlayCur: null
26 |       };
27 |     },
28 | 
29 |     token: function(stream, state) {
30 |       if (stream.start == state.basePos) {
31 |         state.baseCur = base.token(stream, state.base);
32 |         state.basePos = stream.pos;
33 |       }
34 |       if (stream.start == state.overlayPos) {
35 |         stream.pos = stream.start;
36 |         state.overlayCur = overlay.token(stream, state.overlay);
37 |         state.overlayPos = stream.pos;
38 |       }
39 |       stream.pos = Math.min(state.basePos, state.overlayPos);
40 |       if (stream.eol()) state.basePos = state.overlayPos = 0;
41 | 
42 |       if (state.overlayCur == null) return state.baseCur;
43 |       if (state.baseCur != null && combine) return state.baseCur + " " + state.overlayCur;
44 |       else return state.overlayCur;
45 |     },
46 | 
47 |     indent: base.indent && function(state, textAfter) {
48 |       return base.indent(state.base, textAfter);
49 |     },
50 |     electricChars: base.electricChars,
51 | 
52 |     innerMode: function(state) { return {state: state.base, mode: base}; },
53 | 
54 |     blankLine: function(state) {
55 |       if (base.blankLine) base.blankLine(state.base);
56 |       if (overlay.blankLine) overlay.blankLine(state.overlay);
57 |     }
58 |   };
59 | };
60 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/runmode/colorize.js:
--------------------------------------------------------------------------------
 1 | CodeMirror.colorize = (function() {
 2 | 
 3 |   var isBlock = /^(p|li|div|h\\d|pre|blockquote|td)$/;
 4 | 
 5 |   function textContent(node, out) {
 6 |     if (node.nodeType == 3) return out.push(node.nodeValue);
 7 |     for (var ch = node.firstChild; ch; ch = ch.nextSibling) {
 8 |       textContent(ch, out);
 9 |       if (isBlock.test(node.nodeType)) out.push("\n");
10 |     }
11 |   }
12 | 
13 |   return function(collection, defaultMode) {
14 |     if (!collection) collection = document.body.getElementsByTagName("pre");
15 | 
16 |     for (var i = 0; i < collection.length; ++i) {
17 |       var node = collection[i];
18 |       var mode = node.getAttribute("data-lang") || defaultMode;
19 |       if (!mode) continue;
20 | 
21 |       var text = [];
22 |       textContent(node, text);
23 |       node.innerHTML = "";
24 |       CodeMirror.runMode(text.join(""), mode, node);
25 | 
26 |       node.className += " cm-s-default";
27 |     }
28 |   };
29 | })();
30 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/runmode/runmode-standalone.js:
--------------------------------------------------------------------------------
  1 | /* Just enough of CodeMirror to run runMode under node.js */
  2 | 
  3 | window.CodeMirror = {};
  4 | 
  5 | (function() {
  6 | "use strict";
  7 | 
  8 | function splitLines(string){ return string.split(/\r?\n|\r/); };
  9 | 
 10 | function StringStream(string) {
 11 |   this.pos = this.start = 0;
 12 |   this.string = string;
 13 | }
 14 | StringStream.prototype = {
 15 |   eol: function() {return this.pos >= this.string.length;},
 16 |   sol: function() {return this.pos == 0;},
 17 |   peek: function() {return this.string.charAt(this.pos) || null;},
 18 |   next: function() {
 19 |     if (this.pos < this.string.length)
 20 |       return this.string.charAt(this.pos++);
 21 |   },
 22 |   eat: function(match) {
 23 |     var ch = this.string.charAt(this.pos);
 24 |     if (typeof match == "string") var ok = ch == match;
 25 |     else var ok = ch && (match.test ? match.test(ch) : match(ch));
 26 |     if (ok) {++this.pos; return ch;}
 27 |   },
 28 |   eatWhile: function(match) {
 29 |     var start = this.pos;
 30 |     while (this.eat(match)){}
 31 |     return this.pos > start;
 32 |   },
 33 |   eatSpace: function() {
 34 |     var start = this.pos;
 35 |     while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
 36 |     return this.pos > start;
 37 |   },
 38 |   skipToEnd: function() {this.pos = this.string.length;},
 39 |   skipTo: function(ch) {
 40 |     var found = this.string.indexOf(ch, this.pos);
 41 |     if (found > -1) {this.pos = found; return true;}
 42 |   },
 43 |   backUp: function(n) {this.pos -= n;},
 44 |   column: function() {return this.start;},
 45 |   indentation: function() {return 0;},
 46 |   match: function(pattern, consume, caseInsensitive) {
 47 |     if (typeof pattern == "string") {
 48 |       var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
 49 |       var substr = this.string.substr(this.pos, pattern.length);
 50 |       if (cased(substr) == cased(pattern)) {
 51 |         if (consume !== false) this.pos += pattern.length;
 52 |         return true;
 53 |       }
 54 |     } else {
 55 |       var match = this.string.slice(this.pos).match(pattern);
 56 |       if (match && match.index > 0) return null;
 57 |       if (match && consume !== false) this.pos += match[0].length;
 58 |       return match;
 59 |     }
 60 |   },
 61 |   current: function(){return this.string.slice(this.start, this.pos);}
 62 | };
 63 | CodeMirror.StringStream = StringStream;
 64 | 
 65 | CodeMirror.startState = function (mode, a1, a2) {
 66 |   return mode.startState ? mode.startState(a1, a2) : true;
 67 | };
 68 | 
 69 | var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {};
 70 | CodeMirror.defineMode = function (name, mode) { modes[name] = mode; };
 71 | CodeMirror.defineMIME = function (mime, spec) { mimeModes[mime] = spec; };
 72 | CodeMirror.getMode = function (options, spec) {
 73 |   if (typeof spec == "string" && mimeModes.hasOwnProperty(spec))
 74 |     spec = mimeModes[spec];
 75 |   if (typeof spec == "string")
 76 |     var mname = spec, config = {};
 77 |   else if (spec != null)
 78 |     var mname = spec.name, config = spec;
 79 |   var mfactory = modes[mname];
 80 |   if (!mfactory) throw new Error("Unknown mode: " + spec);
 81 |   return mfactory(options, config || {});
 82 | };
 83 | 
 84 | CodeMirror.runMode = function (string, modespec, callback, options) {
 85 |   var mode = CodeMirror.getMode({ indentUnit: 2 }, modespec);
 86 | 
 87 |   if (callback.nodeType == 1) {
 88 |     var tabSize = (options && options.tabSize) || 4;
 89 |     var node = callback, col = 0;
 90 |     node.innerHTML = "";
 91 |     callback = function (text, style) {
 92 |       if (text == "\n") {
 93 |         node.appendChild(document.createElement("br"));
 94 |         col = 0;
 95 |         return;
 96 |       }
 97 |       var content = "";
 98 |       // replace tabs
 99 |       for (var pos = 0; ;) {
100 |         var idx = text.indexOf("\t", pos);
101 |         if (idx == -1) {
102 |           content += text.slice(pos);
103 |           col += text.length - pos;
104 |           break;
105 |         } else {
106 |           col += idx - pos;
107 |           content += text.slice(pos, idx);
108 |           var size = tabSize - col % tabSize;
109 |           col += size;
110 |           for (var i = 0; i < size; ++i) content += " ";
111 |           pos = idx + 1;
112 |         }
113 |       }
114 | 
115 |       if (style) {
116 |         var sp = node.appendChild(document.createElement("span"));
117 |         sp.className = "cm-" + style.replace(/ +/g, " cm-");
118 |         sp.appendChild(document.createTextNode(content));
119 |       } else {
120 |         node.appendChild(document.createTextNode(content));
121 |       }
122 |     };
123 |   }
124 | 
125 |   var lines = splitLines(string), state = CodeMirror.startState(mode);
126 |   for (var i = 0, e = lines.length; i < e; ++i) {
127 |     if (i) callback("\n");
128 |     var stream = new CodeMirror.StringStream(lines[i]);
129 |     while (!stream.eol()) {
130 |       var style = mode.token(stream, state);
131 |       callback(stream.current(), style, i, stream.start, state);
132 |       stream.start = stream.pos;
133 |     }
134 |   }
135 | };
136 | })();
137 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/runmode/runmode.js:
--------------------------------------------------------------------------------
 1 | CodeMirror.runMode = function(string, modespec, callback, options) {
 2 |   var mode = CodeMirror.getMode(CodeMirror.defaults, modespec);
 3 |   var ie = /MSIE \d/.test(navigator.userAgent);
 4 |   var ie_lt9 = ie && (document.documentMode == null || document.documentMode < 9);
 5 | 
 6 |   if (callback.nodeType == 1) {
 7 |     var tabSize = (options && options.tabSize) || CodeMirror.defaults.tabSize;
 8 |     var node = callback, col = 0;
 9 |     node.innerHTML = "";
10 |     callback = function(text, style) {
11 |       if (text == "\n") {
12 |         // Emitting LF or CRLF on IE8 or earlier results in an incorrect display.
13 |         // Emitting a carriage return makes everything ok.
14 |         node.appendChild(document.createTextNode(ie_lt9 ? '\r' : text));
15 |         col = 0;
16 |         return;
17 |       }
18 |       var content = "";
19 |       // replace tabs
20 |       for (var pos = 0;;) {
21 |         var idx = text.indexOf("\t", pos);
22 |         if (idx == -1) {
23 |           content += text.slice(pos);
24 |           col += text.length - pos;
25 |           break;
26 |         } else {
27 |           col += idx - pos;
28 |           content += text.slice(pos, idx);
29 |           var size = tabSize - col % tabSize;
30 |           col += size;
31 |           for (var i = 0; i < size; ++i) content += " ";
32 |           pos = idx + 1;
33 |         }
34 |       }
35 | 
36 |       if (style) {
37 |         var sp = node.appendChild(document.createElement("span"));
38 |         sp.className = "cm-" + style.replace(/ +/g, " cm-");
39 |         sp.appendChild(document.createTextNode(content));
40 |       } else {
41 |         node.appendChild(document.createTextNode(content));
42 |       }
43 |     };
44 |   }
45 | 
46 |   var lines = CodeMirror.splitLines(string), state = CodeMirror.startState(mode);
47 |   for (var i = 0, e = lines.length; i < e; ++i) {
48 |     if (i) callback("\n");
49 |     var stream = new CodeMirror.StringStream(lines[i]);
50 |     while (!stream.eol()) {
51 |       var style = mode.token(stream, state);
52 |       callback(stream.current(), style, i, stream.start, state);
53 |       stream.start = stream.pos;
54 |     }
55 |   }
56 | };
57 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/runmode/runmode.node.js:
--------------------------------------------------------------------------------
  1 | /* Just enough of CodeMirror to run runMode under node.js */
  2 | 
  3 | function splitLines(string){ return string.split(/\r?\n|\r/); };
  4 | 
  5 | function StringStream(string) {
  6 |   this.pos = this.start = 0;
  7 |   this.string = string;
  8 | }
  9 | StringStream.prototype = {
 10 |   eol: function() {return this.pos >= this.string.length;},
 11 |   sol: function() {return this.pos == 0;},
 12 |   peek: function() {return this.string.charAt(this.pos) || null;},
 13 |   next: function() {
 14 |     if (this.pos < this.string.length)
 15 |       return this.string.charAt(this.pos++);
 16 |   },
 17 |   eat: function(match) {
 18 |     var ch = this.string.charAt(this.pos);
 19 |     if (typeof match == "string") var ok = ch == match;
 20 |     else var ok = ch && (match.test ? match.test(ch) : match(ch));
 21 |     if (ok) {++this.pos; return ch;}
 22 |   },
 23 |   eatWhile: function(match) {
 24 |     var start = this.pos;
 25 |     while (this.eat(match)){}
 26 |     return this.pos > start;
 27 |   },
 28 |   eatSpace: function() {
 29 |     var start = this.pos;
 30 |     while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
 31 |     return this.pos > start;
 32 |   },
 33 |   skipToEnd: function() {this.pos = this.string.length;},
 34 |   skipTo: function(ch) {
 35 |     var found = this.string.indexOf(ch, this.pos);
 36 |     if (found > -1) {this.pos = found; return true;}
 37 |   },
 38 |   backUp: function(n) {this.pos -= n;},
 39 |   column: function() {return this.start;},
 40 |   indentation: function() {return 0;},
 41 |   match: function(pattern, consume, caseInsensitive) {
 42 |     if (typeof pattern == "string") {
 43 |       var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
 44 |       var substr = this.string.substr(this.pos, pattern.length);
 45 |       if (cased(substr) == cased(pattern)) {
 46 |         if (consume !== false) this.pos += pattern.length;
 47 |         return true;
 48 |       }
 49 |     } else {
 50 |       var match = this.string.slice(this.pos).match(pattern);
 51 |       if (match && match.index > 0) return null;
 52 |       if (match && consume !== false) this.pos += match[0].length;
 53 |       return match;
 54 |     }
 55 |   },
 56 |   current: function(){return this.string.slice(this.start, this.pos);}
 57 | };
 58 | exports.StringStream = StringStream;
 59 | 
 60 | exports.startState = function(mode, a1, a2) {
 61 |   return mode.startState ? mode.startState(a1, a2) : true;
 62 | };
 63 | 
 64 | var modes = exports.modes = {}, mimeModes = exports.mimeModes = {};
 65 | exports.defineMode = function(name, mode) {
 66 |   if (arguments.length > 2) {
 67 |     mode.dependencies = [];
 68 |     for (var i = 2; i < arguments.length; ++i) mode.dependencies.push(arguments[i]);
 69 |   }
 70 |   modes[name] = mode;
 71 | };
 72 | exports.defineMIME = function(mime, spec) { mimeModes[mime] = spec; };
 73 | 
 74 | exports.defineMode("null", function() {
 75 |   return {token: function(stream) {stream.skipToEnd();}};
 76 | });
 77 | exports.defineMIME("text/plain", "null");
 78 | 
 79 | exports.getMode = function(options, spec) {
 80 |   if (typeof spec == "string" && mimeModes.hasOwnProperty(spec))
 81 |     spec = mimeModes[spec];
 82 |   if (typeof spec == "string")
 83 |     var mname = spec, config = {};
 84 |   else if (spec != null)
 85 |     var mname = spec.name, config = spec;
 86 |   var mfactory = modes[mname];
 87 |   if (!mfactory) throw new Error("Unknown mode: " + spec);
 88 |   return mfactory(options, config || {});
 89 | };
 90 | 
 91 | exports.runMode = function(string, modespec, callback) {
 92 |   var mode = exports.getMode({indentUnit: 2}, modespec);
 93 |   var lines = splitLines(string), state = exports.startState(mode);
 94 |   for (var i = 0, e = lines.length; i < e; ++i) {
 95 |     if (i) callback("\n");
 96 |     var stream = new exports.StringStream(lines[i]);
 97 |     while (!stream.eol()) {
 98 |       var style = mode.token(stream, state);
 99 |       callback(stream.current(), style, i, stream.start, state);
100 |       stream.start = stream.pos;
101 |     }
102 |   }
103 | };
104 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/scroll/scrollpastend.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   "use strict";
 3 | 
 4 |   CodeMirror.defineOption("scrollPastEnd", false, function(cm, val, old) {
 5 |     if (old && old != CodeMirror.Init) {
 6 |       cm.off("change", onChange);
 7 |       cm.display.lineSpace.parentNode.style.paddingBottom = "";
 8 |       cm.state.scrollPastEndPadding = null;
 9 |     }
10 |     if (val) {
11 |       cm.on("change", onChange);
12 |       updateBottomMargin(cm);
13 |     }
14 |   });
15 | 
16 |   function onChange(cm, change) {
17 |     if (CodeMirror.changeEnd(change).line == cm.lastLine())
18 |       updateBottomMargin(cm);
19 |   }
20 | 
21 |   function updateBottomMargin(cm) {
22 |     var padding = "";
23 |     if (cm.lineCount() > 1) {
24 |       var totalH = cm.display.scroller.clientHeight - 30,
25 |           lastLineH = cm.getLineHandle(cm.lastLine()).height;
26 |       padding = (totalH - lastLineH) + "px";
27 |     }
28 |     if (cm.state.scrollPastEndPadding != padding) {
29 |       cm.state.scrollPastEndPadding = padding;
30 |       cm.display.lineSpace.parentNode.style.paddingBottom = padding;
31 |       cm.setSize();
32 |     }
33 |   }
34 | })();
35 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/search/match-highlighter.js:
--------------------------------------------------------------------------------
 1 | // Highlighting text that matches the selection
 2 | //
 3 | // Defines an option highlightSelectionMatches, which, when enabled,
 4 | // will style strings that match the selection throughout the
 5 | // document.
 6 | //
 7 | // The option can be set to true to simply enable it, or to a
 8 | // {minChars, style, showToken} object to explicitly configure it.
 9 | // minChars is the minimum amount of characters that should be
10 | // selected for the behavior to occur, and style is the token style to
11 | // apply to the matches. This will be prefixed by "cm-" to create an
12 | // actual CSS class name. showToken, when enabled, will cause the
13 | // current token to be highlighted when nothing is selected.
14 | 
15 | (function() {
16 |   var DEFAULT_MIN_CHARS = 2;
17 |   var DEFAULT_TOKEN_STYLE = "matchhighlight";
18 |   var DEFAULT_DELAY = 100;
19 | 
20 |   function State(options) {
21 |     if (typeof options == "object") {
22 |       this.minChars = options.minChars;
23 |       this.style = options.style;
24 |       this.showToken = options.showToken;
25 |       this.delay = options.delay;
26 |     }
27 |     if (this.style == null) this.style = DEFAULT_TOKEN_STYLE;
28 |     if (this.minChars == null) this.minChars = DEFAULT_MIN_CHARS;
29 |     if (this.delay == null) this.delay = DEFAULT_DELAY;
30 |     this.overlay = this.timeout = null;
31 |   }
32 | 
33 |   CodeMirror.defineOption("highlightSelectionMatches", false, function(cm, val, old) {
34 |     if (old && old != CodeMirror.Init) {
35 |       var over = cm.state.matchHighlighter.overlay;
36 |       if (over) cm.removeOverlay(over);
37 |       clearTimeout(cm.state.matchHighlighter.timeout);
38 |       cm.state.matchHighlighter = null;
39 |       cm.off("cursorActivity", cursorActivity);
40 |     }
41 |     if (val) {
42 |       cm.state.matchHighlighter = new State(val);
43 |       highlightMatches(cm);
44 |       cm.on("cursorActivity", cursorActivity);
45 |     }
46 |   });
47 | 
48 |   function cursorActivity(cm) {
49 |     var state = cm.state.matchHighlighter;
50 |     clearTimeout(state.timeout);
51 |     state.timeout = setTimeout(function() {highlightMatches(cm);}, state.delay);
52 |   }
53 | 
54 |   function highlightMatches(cm) {
55 |     cm.operation(function() {
56 |       var state = cm.state.matchHighlighter;
57 |       if (state.overlay) {
58 |         cm.removeOverlay(state.overlay);
59 |         state.overlay = null;
60 |       }
61 |       if (!cm.somethingSelected() && state.showToken) {
62 |         var re = state.showToken === true ? /[\w$]/ : state.showToken;
63 |         var cur = cm.getCursor(), line = cm.getLine(cur.line), start = cur.ch, end = start;
64 |         while (start && re.test(line.charAt(start - 1))) --start;
65 |         while (end < line.length && re.test(line.charAt(end))) ++end;
66 |         if (start < end)
67 |           cm.addOverlay(state.overlay = makeOverlay(line.slice(start, end), re, state.style));
68 |         return;
69 |       }
70 |       if (cm.getCursor("head").line != cm.getCursor("anchor").line) return;
71 |       var selection = cm.getSelection().replace(/^\s+|\s+$/g, "");
72 |       if (selection.length >= state.minChars)
73 |         cm.addOverlay(state.overlay = makeOverlay(selection, false, state.style));
74 |     });
75 |   }
76 | 
77 |   function boundariesAround(stream, re) {
78 |     return (!stream.start || !re.test(stream.string.charAt(stream.start - 1))) &&
79 |       (stream.pos == stream.string.length || !re.test(stream.string.charAt(stream.pos)));
80 |   }
81 | 
82 |   function makeOverlay(query, hasBoundary, style) {
83 |     return {token: function(stream) {
84 |       if (stream.match(query) &&
85 |           (!hasBoundary || boundariesAround(stream, hasBoundary)))
86 |         return style;
87 |       stream.next();
88 |       stream.skipTo(query.charAt(0)) || stream.skipToEnd();
89 |     }};
90 |   }
91 | })();
92 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/search/search.js:
--------------------------------------------------------------------------------
  1 | // Define search commands. Depends on dialog.js or another
  2 | // implementation of the openDialog method.
  3 | 
  4 | // Replace works a little oddly -- it will do the replace on the next
  5 | // Ctrl-G (or whatever is bound to findNext) press. You prevent a
  6 | // replace by making sure the match is no longer selected when hitting
  7 | // Ctrl-G.
  8 | 
  9 | (function() {
 10 |   function searchOverlay(query) {
 11 |     if (typeof query == "string") return {token: function(stream) {
 12 |       if (stream.match(query)) return "searching";
 13 |       stream.next();
 14 |       stream.skipTo(query.charAt(0)) || stream.skipToEnd();
 15 |     }};
 16 |     return {token: function(stream) {
 17 |       if (stream.match(query)) return "searching";
 18 |       while (!stream.eol()) {
 19 |         stream.next();
 20 |         if (stream.match(query, false)) break;
 21 |       }
 22 |     }};
 23 |   }
 24 | 
 25 |   function SearchState() {
 26 |     this.posFrom = this.posTo = this.query = null;
 27 |     this.overlay = null;
 28 |   }
 29 |   function getSearchState(cm) {
 30 |     return cm.state.search || (cm.state.search = new SearchState());
 31 |   }
 32 |   function getSearchCursor(cm, query, pos) {
 33 |     // Heuristic: if the query string is all lowercase, do a case insensitive search.
 34 |     return cm.getSearchCursor(query, pos, typeof query == "string" && query == query.toLowerCase());
 35 |   }
 36 |   function dialog(cm, text, shortText, f) {
 37 |     if (cm.openDialog) cm.openDialog(text, f);
 38 |     else f(prompt(shortText, ""));
 39 |   }
 40 |   function confirmDialog(cm, text, shortText, fs) {
 41 |     if (cm.openConfirm) cm.openConfirm(text, fs);
 42 |     else if (confirm(shortText)) fs[0]();
 43 |   }
 44 |   function parseQuery(query) {
 45 |     var isRE = query.match(/^\/(.*)\/([a-z]*)$/);
 46 |     return isRE ? new RegExp(isRE[1], isRE[2].indexOf("i") == -1 ? "" : "i") : query;
 47 |   }
 48 |   var queryDialog =
 49 |     'Search: <input type="text" style="width: 10em"/> <span style="color: #888">(Use /re/ syntax for regexp search)</span>';
 50 |   function doSearch(cm, rev) {
 51 |     var state = getSearchState(cm);
 52 |     if (state.query) return findNext(cm, rev);
 53 |     dialog(cm, queryDialog, "Search for:", function(query) {
 54 |       cm.operation(function() {
 55 |         if (!query || state.query) return;
 56 |         state.query = parseQuery(query);
 57 |         cm.removeOverlay(state.overlay);
 58 |         state.overlay = searchOverlay(state.query);
 59 |         cm.addOverlay(state.overlay);
 60 |         state.posFrom = state.posTo = cm.getCursor();
 61 |         findNext(cm, rev);
 62 |       });
 63 |     });
 64 |   }
 65 |   function findNext(cm, rev) {cm.operation(function() {
 66 |     var state = getSearchState(cm);
 67 |     var cursor = getSearchCursor(cm, state.query, rev ? state.posFrom : state.posTo);
 68 |     if (!cursor.find(rev)) {
 69 |       cursor = getSearchCursor(cm, state.query, rev ? CodeMirror.Pos(cm.lastLine()) : CodeMirror.Pos(cm.firstLine(), 0));
 70 |       if (!cursor.find(rev)) return;
 71 |     }
 72 |     cm.setSelection(cursor.from(), cursor.to());
 73 |     cm.scrollIntoView({from: cursor.from(), to: cursor.to()});
 74 |     state.posFrom = cursor.from(); state.posTo = cursor.to();
 75 |   });}
 76 |   function clearSearch(cm) {cm.operation(function() {
 77 |     var state = getSearchState(cm);
 78 |     if (!state.query) return;
 79 |     state.query = null;
 80 |     cm.removeOverlay(state.overlay);
 81 |   });}
 82 | 
 83 |   var replaceQueryDialog =
 84 |     'Replace: <input type="text" style="width: 10em"/> <span style="color: #888">(Use /re/ syntax for regexp search)</span>';
 85 |   var replacementQueryDialog = 'With: <input type="text" style="width: 10em"/>';
 86 |   var doReplaceConfirm = "Replace? <button>Yes</button> <button>No</button> <button>Stop</button>";
 87 |   function replace(cm, all) {
 88 |     dialog(cm, replaceQueryDialog, "Replace:", function(query) {
 89 |       if (!query) return;
 90 |       query = parseQuery(query);
 91 |       dialog(cm, replacementQueryDialog, "Replace with:", function(text) {
 92 |         if (all) {
 93 |           cm.operation(function() {
 94 |             for (var cursor = getSearchCursor(cm, query); cursor.findNext();) {
 95 |               if (typeof query != "string") {
 96 |                 var match = cm.getRange(cursor.from(), cursor.to()).match(query);
 97 |                 cursor.replace(text.replace(/\$(\d)/, function(_, i) {return match[i];}));
 98 |               } else cursor.replace(text);
 99 |             }
100 |           });
101 |         } else {
102 |           clearSearch(cm);
103 |           var cursor = getSearchCursor(cm, query, cm.getCursor());
104 |           var advance = function() {
105 |             var start = cursor.from(), match;
106 |             if (!(match = cursor.findNext())) {
107 |               cursor = getSearchCursor(cm, query);
108 |               if (!(match = cursor.findNext()) ||
109 |                   (start && cursor.from().line == start.line && cursor.from().ch == start.ch)) return;
110 |             }
111 |             cm.setSelection(cursor.from(), cursor.to());
112 |             cm.scrollIntoView({from: cursor.from(), to: cursor.to()});
113 |             confirmDialog(cm, doReplaceConfirm, "Replace?",
114 |                           [function() {doReplace(match);}, advance]);
115 |           };
116 |           var doReplace = function(match) {
117 |             cursor.replace(typeof query == "string" ? text :
118 |                            text.replace(/\$(\d)/, function(_, i) {return match[i];}));
119 |             advance();
120 |           };
121 |           advance();
122 |         }
123 |       });
124 |     });
125 |   }
126 | 
127 |   CodeMirror.commands.find = function(cm) {clearSearch(cm); doSearch(cm);};
128 |   CodeMirror.commands.findNext = doSearch;
129 |   CodeMirror.commands.findPrev = function(cm) {doSearch(cm, true);};
130 |   CodeMirror.commands.clearSearch = clearSearch;
131 |   CodeMirror.commands.replace = replace;
132 |   CodeMirror.commands.replaceAll = function(cm) {replace(cm, true);};
133 | })();
134 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/search/searchcursor.js:
--------------------------------------------------------------------------------
  1 | (function(){
  2 |   var Pos = CodeMirror.Pos;
  3 | 
  4 |   function SearchCursor(doc, query, pos, caseFold) {
  5 |     this.atOccurrence = false; this.doc = doc;
  6 |     if (caseFold == null && typeof query == "string") caseFold = false;
  7 | 
  8 |     pos = pos ? doc.clipPos(pos) : Pos(0, 0);
  9 |     this.pos = {from: pos, to: pos};
 10 | 
 11 |     // The matches method is filled in based on the type of query.
 12 |     // It takes a position and a direction, and returns an object
 13 |     // describing the next occurrence of the query, or null if no
 14 |     // more matches were found.
 15 |     if (typeof query != "string") { // Regexp match
 16 |       if (!query.global) query = new RegExp(query.source, query.ignoreCase ? "ig" : "g");
 17 |       this.matches = function(reverse, pos) {
 18 |         if (reverse) {
 19 |           query.lastIndex = 0;
 20 |           var line = doc.getLine(pos.line).slice(0, pos.ch), cutOff = 0, match, start;
 21 |           for (;;) {
 22 |             query.lastIndex = cutOff;
 23 |             var newMatch = query.exec(line);
 24 |             if (!newMatch) break;
 25 |             match = newMatch;
 26 |             start = match.index;
 27 |             cutOff = match.index + (match[0].length || 1);
 28 |             if (cutOff == line.length) break;
 29 |           }
 30 |           var matchLen = (match && match[0].length) || 0;
 31 |           if (!matchLen) {
 32 |             if (start == 0 && line.length == 0) {match = undefined;}
 33 |             else if (start != doc.getLine(pos.line).length) {
 34 |               matchLen++;
 35 |             }
 36 |           }
 37 |         } else {
 38 |           query.lastIndex = pos.ch;
 39 |           var line = doc.getLine(pos.line), match = query.exec(line);
 40 |           var matchLen = (match && match[0].length) || 0;
 41 |           var start = match && match.index;
 42 |           if (start + matchLen != line.length && !matchLen) matchLen = 1;
 43 |         }
 44 |         if (match && matchLen)
 45 |           return {from: Pos(pos.line, start),
 46 |                   to: Pos(pos.line, start + matchLen),
 47 |                   match: match};
 48 |       };
 49 |     } else { // String query
 50 |       if (caseFold) query = query.toLowerCase();
 51 |       var fold = caseFold ? function(str){return str.toLowerCase();} : function(str){return str;};
 52 |       var target = query.split("\n");
 53 |       // Different methods for single-line and multi-line queries
 54 |       if (target.length == 1) {
 55 |         if (!query.length) {
 56 |           // Empty string would match anything and never progress, so
 57 |           // we define it to match nothing instead.
 58 |           this.matches = function() {};
 59 |         } else {
 60 |           this.matches = function(reverse, pos) {
 61 |             var line = fold(doc.getLine(pos.line)), len = query.length, match;
 62 |             if (reverse ? (pos.ch >= len && (match = line.lastIndexOf(query, pos.ch - len)) != -1)
 63 |                         : (match = line.indexOf(query, pos.ch)) != -1)
 64 |               return {from: Pos(pos.line, match),
 65 |                       to: Pos(pos.line, match + len)};
 66 |           };
 67 |         }
 68 |       } else {
 69 |         this.matches = function(reverse, pos) {
 70 |           var ln = pos.line, idx = (reverse ? target.length - 1 : 0), match = target[idx], line = fold(doc.getLine(ln));
 71 |           var offsetA = (reverse ? line.indexOf(match) + match.length : line.lastIndexOf(match));
 72 |           if (reverse ? offsetA > pos.ch || offsetA != match.length
 73 |               : offsetA < pos.ch || offsetA != line.length - match.length)
 74 |             return;
 75 |           for (;;) {
 76 |             if (reverse ? !ln : ln == doc.lineCount() - 1) return;
 77 |             line = fold(doc.getLine(ln += reverse ? -1 : 1));
 78 |             match = target[reverse ? --idx : ++idx];
 79 |             if (idx > 0 && idx < target.length - 1) {
 80 |               if (line != match) return;
 81 |               else continue;
 82 |             }
 83 |             var offsetB = (reverse ? line.lastIndexOf(match) : line.indexOf(match) + match.length);
 84 |             if (reverse ? offsetB != line.length - match.length : offsetB != match.length)
 85 |               return;
 86 |             var start = Pos(pos.line, offsetA), end = Pos(ln, offsetB);
 87 |             return {from: reverse ? end : start, to: reverse ? start : end};
 88 |           }
 89 |         };
 90 |       }
 91 |     }
 92 |   }
 93 | 
 94 |   SearchCursor.prototype = {
 95 |     findNext: function() {return this.find(false);},
 96 |     findPrevious: function() {return this.find(true);},
 97 | 
 98 |     find: function(reverse) {
 99 |       var self = this, pos = this.doc.clipPos(reverse ? this.pos.from : this.pos.to);
100 |       function savePosAndFail(line) {
101 |         var pos = Pos(line, 0);
102 |         self.pos = {from: pos, to: pos};
103 |         self.atOccurrence = false;
104 |         return false;
105 |       }
106 | 
107 |       for (;;) {
108 |         if (this.pos = this.matches(reverse, pos)) {
109 |           if (!this.pos.from || !this.pos.to) { console.log(this.matches, this.pos); }
110 |           this.atOccurrence = true;
111 |           return this.pos.match || true;
112 |         }
113 |         if (reverse) {
114 |           if (!pos.line) return savePosAndFail(0);
115 |           pos = Pos(pos.line-1, this.doc.getLine(pos.line-1).length);
116 |         }
117 |         else {
118 |           var maxLine = this.doc.lineCount();
119 |           if (pos.line == maxLine - 1) return savePosAndFail(maxLine);
120 |           pos = Pos(pos.line + 1, 0);
121 |         }
122 |       }
123 |     },
124 | 
125 |     from: function() {if (this.atOccurrence) return this.pos.from;},
126 |     to: function() {if (this.atOccurrence) return this.pos.to;},
127 | 
128 |     replace: function(newText) {
129 |       if (!this.atOccurrence) return;
130 |       var lines = CodeMirror.splitLines(newText);
131 |       this.doc.replaceRange(lines, this.pos.from, this.pos.to);
132 |       this.pos.to = Pos(this.pos.from.line + lines.length - 1,
133 |                         lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0));
134 |     }
135 |   };
136 | 
137 |   CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
138 |     return new SearchCursor(this.doc, query, pos, caseFold);
139 |   });
140 |   CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) {
141 |     return new SearchCursor(this, query, pos, caseFold);
142 |   });
143 | })();
144 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/selection/active-line.js:
--------------------------------------------------------------------------------
 1 | // Because sometimes you need to style the cursor's line.
 2 | //
 3 | // Adds an option 'styleActiveLine' which, when enabled, gives the
 4 | // active line's wrapping <div> the CSS class "CodeMirror-activeline",
 5 | // and gives its background <div> the class "CodeMirror-activeline-background".
 6 | 
 7 | (function() {
 8 |   "use strict";
 9 |   var WRAP_CLASS = "CodeMirror-activeline";
10 |   var BACK_CLASS = "CodeMirror-activeline-background";
11 | 
12 |   CodeMirror.defineOption("styleActiveLine", false, function(cm, val, old) {
13 |     var prev = old && old != CodeMirror.Init;
14 |     if (val && !prev) {
15 |       updateActiveLine(cm);
16 |       cm.on("cursorActivity", updateActiveLine);
17 |     } else if (!val && prev) {
18 |       cm.off("cursorActivity", updateActiveLine);
19 |       clearActiveLine(cm);
20 |       delete cm.state.activeLine;
21 |     }
22 |   });
23 | 
24 |   function clearActiveLine(cm) {
25 |     if ("activeLine" in cm.state) {
26 |       cm.removeLineClass(cm.state.activeLine, "wrap", WRAP_CLASS);
27 |       cm.removeLineClass(cm.state.activeLine, "background", BACK_CLASS);
28 |     }
29 |   }
30 | 
31 |   function updateActiveLine(cm) {
32 |     var line = cm.getLineHandleVisualStart(cm.getCursor().line);
33 |     if (cm.state.activeLine == line) return;
34 |     clearActiveLine(cm);
35 |     cm.addLineClass(line, "wrap", WRAP_CLASS);
36 |     cm.addLineClass(line, "background", BACK_CLASS);
37 |     cm.state.activeLine = line;
38 |   }
39 | })();
40 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/selection/mark-selection.js:
--------------------------------------------------------------------------------
  1 | // Because sometimes you need to mark the selected *text*.
  2 | //
  3 | // Adds an option 'styleSelectedText' which, when enabled, gives
  4 | // selected text the CSS class given as option value, or
  5 | // "CodeMirror-selectedtext" when the value is not a string.
  6 | 
  7 | (function() {
  8 |   "use strict";
  9 | 
 10 |   CodeMirror.defineOption("styleSelectedText", false, function(cm, val, old) {
 11 |     var prev = old && old != CodeMirror.Init;
 12 |     if (val && !prev) {
 13 |       cm.state.markedSelection = [];
 14 |       cm.state.markedSelectionStyle = typeof val == "string" ? val : "CodeMirror-selectedtext";
 15 |       reset(cm);
 16 |       cm.on("cursorActivity", onCursorActivity);
 17 |       cm.on("change", onChange);
 18 |     } else if (!val && prev) {
 19 |       cm.off("cursorActivity", onCursorActivity);
 20 |       cm.off("change", onChange);
 21 |       clear(cm);
 22 |       cm.state.markedSelection = cm.state.markedSelectionStyle = null;
 23 |     }
 24 |   });
 25 | 
 26 |   function onCursorActivity(cm) {
 27 |     cm.operation(function() { update(cm); });
 28 |   }
 29 | 
 30 |   function onChange(cm) {
 31 |     if (cm.state.markedSelection.length)
 32 |       cm.operation(function() { clear(cm); });
 33 |   }
 34 | 
 35 |   var CHUNK_SIZE = 8;
 36 |   var Pos = CodeMirror.Pos;
 37 | 
 38 |   function cmp(pos1, pos2) {
 39 |     return pos1.line - pos2.line || pos1.ch - pos2.ch;
 40 |   }
 41 | 
 42 |   function coverRange(cm, from, to, addAt) {
 43 |     if (cmp(from, to) == 0) return;
 44 |     var array = cm.state.markedSelection;
 45 |     var cls = cm.state.markedSelectionStyle;
 46 |     for (var line = from.line;;) {
 47 |       var start = line == from.line ? from : Pos(line, 0);
 48 |       var endLine = line + CHUNK_SIZE, atEnd = endLine >= to.line;
 49 |       var end = atEnd ? to : Pos(endLine, 0);
 50 |       var mark = cm.markText(start, end, {className: cls});
 51 |       if (addAt == null) array.push(mark);
 52 |       else array.splice(addAt++, 0, mark);
 53 |       if (atEnd) break;
 54 |       line = endLine;
 55 |     }
 56 |   }
 57 | 
 58 |   function clear(cm) {
 59 |     var array = cm.state.markedSelection;
 60 |     for (var i = 0; i < array.length; ++i) array[i].clear();
 61 |     array.length = 0;
 62 |   }
 63 | 
 64 |   function reset(cm) {
 65 |     clear(cm);
 66 |     var from = cm.getCursor("start"), to = cm.getCursor("end");
 67 |     coverRange(cm, from, to);
 68 |   }
 69 | 
 70 |   function update(cm) {
 71 |     var from = cm.getCursor("start"), to = cm.getCursor("end");
 72 |     if (cmp(from, to) == 0) return clear(cm);
 73 | 
 74 |     var array = cm.state.markedSelection;
 75 |     if (!array.length) return coverRange(cm, from, to);
 76 | 
 77 |     var coverStart = array[0].find(), coverEnd = array[array.length - 1].find();
 78 |     if (!coverStart || !coverEnd || to.line - from.line < CHUNK_SIZE ||
 79 |         cmp(from, coverEnd.to) >= 0 || cmp(to, coverStart.from) <= 0)
 80 |       return reset(cm);
 81 | 
 82 |     while (cmp(from, coverStart.from) > 0) {
 83 |       array.shift().clear();
 84 |       coverStart = array[0].find();
 85 |     }
 86 |     if (cmp(from, coverStart.from) < 0) {
 87 |       if (coverStart.to.line - from.line < CHUNK_SIZE) {
 88 |         array.shift().clear();
 89 |         coverRange(cm, from, coverStart.to, 0);
 90 |       } else {
 91 |         coverRange(cm, from, coverStart.from, 0);
 92 |       }
 93 |     }
 94 | 
 95 |     while (cmp(to, coverEnd.to) < 0) {
 96 |       array.pop().clear();
 97 |       coverEnd = array[array.length - 1].find();
 98 |     }
 99 |     if (cmp(to, coverEnd.to) > 0) {
100 |       if (to.line - coverEnd.from.line < CHUNK_SIZE) {
101 |         array.pop().clear();
102 |         coverRange(cm, coverEnd.from, to);
103 |       } else {
104 |         coverRange(cm, coverEnd.to, to);
105 |       }
106 |     }
107 |   }
108 | })();
109 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/tern/tern.css:
--------------------------------------------------------------------------------
 1 | .CodeMirror-Tern-completion {
 2 |   padding-left: 22px;
 3 |   position: relative;
 4 | }
 5 | .CodeMirror-Tern-completion:before {
 6 |   position: absolute;
 7 |   left: 2px;
 8 |   bottom: 2px;
 9 |   border-radius: 50%;
10 |   font-size: 12px;
11 |   font-weight: bold;
12 |   height: 15px;
13 |   width: 15px;
14 |   line-height: 16px;
15 |   text-align: center;
16 |   color: white;
17 |   -moz-box-sizing: border-box;
18 |   box-sizing: border-box;
19 | }
20 | .CodeMirror-Tern-completion-unknown:before {
21 |   content: "?";
22 |   background: #4bb;
23 | }
24 | .CodeMirror-Tern-completion-object:before {
25 |   content: "O";
26 |   background: #77c;
27 | }
28 | .CodeMirror-Tern-completion-fn:before {
29 |   content: "F";
30 |   background: #7c7;
31 | }
32 | .CodeMirror-Tern-completion-array:before {
33 |   content: "A";
34 |   background: #c66;
35 | }
36 | .CodeMirror-Tern-completion-number:before {
37 |   content: "1";
38 |   background: #999;
39 | }
40 | .CodeMirror-Tern-completion-string:before {
41 |   content: "S";
42 |   background: #999;
43 | }
44 | .CodeMirror-Tern-completion-bool:before {
45 |   content: "B";
46 |   background: #999;
47 | }
48 | 
49 | .CodeMirror-Tern-completion-guess {
50 |   color: #999;
51 | }
52 | 
53 | .CodeMirror-Tern-tooltip {
54 |   border: 1px solid silver;
55 |   border-radius: 3px;
56 |   color: #444;
57 |   padding: 2px 5px;
58 |   font-size: 90%;
59 |   font-family: monospace;
60 |   background-color: white;
61 |   white-space: pre-wrap;
62 | 
63 |   max-width: 40em;
64 |   position: absolute;
65 |   z-index: 10;
66 |   -webkit-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
67 |   -moz-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
68 |   box-shadow: 2px 3px 5px rgba(0,0,0,.2);
69 | 
70 |   transition: opacity 1s;
71 |   -moz-transition: opacity 1s;
72 |   -webkit-transition: opacity 1s;
73 |   -o-transition: opacity 1s;
74 |   -ms-transition: opacity 1s;
75 | }
76 | 
77 | .CodeMirror-Tern-hint-doc {
78 |   max-width: 25em;
79 | }
80 | 
81 | .CodeMirror-Tern-fname { color: black; }
82 | .CodeMirror-Tern-farg { color: #70a; }
83 | .CodeMirror-Tern-farg-current { text-decoration: underline; }
84 | .CodeMirror-Tern-type { color: #07c; }
85 | .CodeMirror-Tern-fhint-guess { opacity: .7; }
86 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/tern/worker.js:
--------------------------------------------------------------------------------
 1 | // declare global: tern, server
 2 | 
 3 | var server;
 4 | 
 5 | this.onmessage = function(e) {
 6 |   var data = e.data;
 7 |   switch (data.type) {
 8 |   case "init": return startServer(data.defs, data.plugins, data.scripts);
 9 |   case "add": return server.addFile(data.name, data.text);
10 |   case "del": return server.delFile(data.name);
11 |   case "req": return server.request(data.body, function(err, reqData) {
12 |     postMessage({id: data.id, body: reqData, err: err && String(err)});
13 |   });
14 |   case "getFile":
15 |     var c = pending[data.id];
16 |     delete pending[data.id];
17 |     return c(data.err, data.text);
18 |   default: throw new Error("Unknown message type: " + data.type);
19 |   }
20 | };
21 | 
22 | var nextId = 0, pending = {};
23 | function getFile(file, c) {
24 |   postMessage({type: "getFile", name: file, id: ++nextId});
25 |   pending[nextId] = c;
26 | }
27 | 
28 | function startServer(defs, plugins, scripts) {
29 |   if (scripts) importScripts.apply(null, scripts);
30 | 
31 |   server = new tern.Server({
32 |     getFile: getFile,
33 |     async: true,
34 |     defs: defs,
35 |     plugins: plugins
36 |   });
37 | }
38 | 
39 | var console = {
40 |   log: function(v) { postMessage({type: "debug", message: v}); }
41 | };
42 | 


--------------------------------------------------------------------------------
/assets/codemirror-addons/wrap/hardwrap.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   "use strict";
  3 | 
  4 |   var Pos = CodeMirror.Pos;
  5 | 
  6 |   function findParagraph(cm, pos, options) {
  7 |     var startRE = options.paragraphStart || cm.getHelper(pos, "paragraphStart");
  8 |     for (var start = pos.line, first = cm.firstLine(); start > first; --start) {
  9 |       var line = cm.getLine(start);
 10 |       if (startRE && startRE.test(line)) break;
 11 |       if (!/\S/.test(line)) { ++start; break; }
 12 |     }
 13 |     var endRE = options.paragraphEnd || cm.getHelper(pos, "paragraphEnd");
 14 |     for (var end = pos.line + 1, last = cm.lastLine(); end <= last; ++end) {
 15 |       var line = cm.getLine(end);
 16 |       if (endRE && endRE.test(line)) { ++end; break; }
 17 |       if (!/\S/.test(line)) break;
 18 |     }
 19 |     return {from: start, to: end};
 20 |   }
 21 | 
 22 |   function findBreakPoint(text, column, wrapOn, killTrailingSpace) {
 23 |     for (var at = column; at > 0; --at)
 24 |       if (wrapOn.test(text.slice(at - 1, at + 1))) break;
 25 |     if (at == 0) at = column;
 26 |     var endOfText = at;
 27 |     if (killTrailingSpace)
 28 |       while (text.charAt(endOfText - 1) == " ") --endOfText;
 29 |     return {from: endOfText, to: at};
 30 |   }
 31 | 
 32 |   function wrapRange(cm, from, to, options) {
 33 |     from = cm.clipPos(from); to = cm.clipPos(to);
 34 |     var column = options.column || 80;
 35 |     var wrapOn = options.wrapOn || /\s\S|-[^\.\d]/;
 36 |     var killTrailing = options.killTrailingSpace !== false;
 37 |     var changes = [], curLine = "", curNo = from.line;
 38 |     var lines = cm.getRange(from, to, false);
 39 |     for (var i = 0; i < lines.length; ++i) {
 40 |       var text = lines[i], oldLen = curLine.length, spaceInserted = 0;
 41 |       if (curLine && text && !wrapOn.test(curLine.charAt(curLine.length - 1) + text.charAt(0))) {
 42 |         curLine += " ";
 43 |         spaceInserted = 1;
 44 |       }
 45 |       curLine += text;
 46 |       if (i) {
 47 |         var firstBreak = curLine.length > column && findBreakPoint(curLine, column, wrapOn, killTrailing);
 48 |         // If this isn't broken, or is broken at a different point, remove old break
 49 |         if (!firstBreak || firstBreak.from != oldLen || firstBreak.to != oldLen + spaceInserted) {
 50 |           changes.push({text: spaceInserted ? " " : "",
 51 |                         from: Pos(curNo, oldLen),
 52 |                         to: Pos(curNo + 1, 0)});
 53 |         } else {
 54 |           curLine = text;
 55 |           ++curNo;
 56 |         }
 57 |       }
 58 |       while (curLine.length > column) {
 59 |         var bp = findBreakPoint(curLine, column, wrapOn, killTrailing);
 60 |         changes.push({text: "\n",
 61 |                       from: Pos(curNo, bp.from),
 62 |                       to: Pos(curNo, bp.to)});
 63 |         curLine = curLine.slice(bp.to);
 64 |         ++curNo;
 65 |       }
 66 |     }
 67 |     if (changes.length) cm.operation(function() {
 68 |       for (var i = 0; i < changes.length; ++i) {
 69 |         var change = changes[i];
 70 |         cm.replaceRange(change.text, change.from, change.to);
 71 |       }
 72 |     });
 73 |   }
 74 | 
 75 |   CodeMirror.defineExtension("wrapParagraph", function(pos, options) {
 76 |     options = options || {};
 77 |     if (!pos) pos = this.getCursor();
 78 |     var para = findParagraph(this, pos, options);
 79 |     wrapRange(this, Pos(para.from, 0), Pos(para.to - 1), options);
 80 |   });
 81 | 
 82 |   CodeMirror.defineExtension("wrapRange", function(from, to, options) {
 83 |     wrapRange(this, from, to, options || {});
 84 |   });
 85 | 
 86 |   CodeMirror.defineExtension("wrapParagraphsInRange", function(from, to, options) {
 87 |     options = options || {};
 88 |     var cm = this, paras = [];
 89 |     for (var line = from.line; line <= to.line;) {
 90 |       var para = findParagraph(cm, Pos(line, 0), options);
 91 |       paras.push(para);
 92 |       line = para.to;
 93 |     }
 94 |     if (paras.length) cm.operation(function() {
 95 |       for (var i = paras.length - 1; i >= 0; --i)
 96 |         wrapRange(cm, Pos(paras[i].from, 0), Pos(paras[i].to - 1), options);
 97 |     });
 98 |   });
 99 | })();
100 | 


--------------------------------------------------------------------------------
/assets/codemirror.css:
--------------------------------------------------------------------------------
  1 | /* BASICS */
  2 | 
  3 | .CodeMirror {
  4 |   /* Set height, width, borders, and global font properties here */
  5 |   font-family: monospace;
  6 |   height: 300px;
  7 | }
  8 | .CodeMirror-scroll {
  9 |   /* Set scrolling behaviour here */
 10 |   overflow: auto;
 11 | }
 12 | 
 13 | /* PADDING */
 14 | 
 15 | .CodeMirror-lines {
 16 |   padding: 4px 0; /* Vertical padding around content */
 17 | }
 18 | .CodeMirror pre {
 19 |   padding: 0 4px; /* Horizontal padding of content */
 20 | }
 21 | 
 22 | .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
 23 |   background-color: white; /* The little square between H and V scrollbars */
 24 | }
 25 | 
 26 | /* GUTTER */
 27 | 
 28 | .CodeMirror-gutters {
 29 |   border-right: 1px solid #ddd;
 30 |   background-color: #f7f7f7;
 31 |   white-space: nowrap;
 32 | }
 33 | .CodeMirror-linenumbers {}
 34 | .CodeMirror-linenumber {
 35 |   padding: 0 3px 0 5px;
 36 |   min-width: 20px;
 37 |   text-align: right;
 38 |   color: #999;
 39 | }
 40 | 
 41 | /* CURSOR */
 42 | 
 43 | .CodeMirror div.CodeMirror-cursor {
 44 |   border-left: 1px solid black;
 45 |   z-index: 3;
 46 | }
 47 | /* Shown when moving in bi-directional text */
 48 | .CodeMirror div.CodeMirror-secondarycursor {
 49 |   border-left: 1px solid silver;
 50 | }
 51 | .CodeMirror.cm-keymap-fat-cursor div.CodeMirror-cursor {
 52 |   width: auto;
 53 |   border: 0;
 54 |   background: #7e7;
 55 |   z-index: 1;
 56 | }
 57 | /* Can style cursor different in overwrite (non-insert) mode */
 58 | .CodeMirror div.CodeMirror-cursor.CodeMirror-overwrite {}
 59 | 
 60 | .cm-tab { display: inline-block; }
 61 | 
 62 | /* DEFAULT THEME */
 63 | 
 64 | .cm-s-default .cm-keyword {color: #708;}
 65 | .cm-s-default .cm-atom {color: #219;}
 66 | .cm-s-default .cm-number {color: #164;}
 67 | .cm-s-default .cm-def {color: #00f;}
 68 | .cm-s-default .cm-variable {color: black;}
 69 | .cm-s-default .cm-variable-2 {color: #05a;}
 70 | .cm-s-default .cm-variable-3 {color: #085;}
 71 | .cm-s-default .cm-property {color: black;}
 72 | .cm-s-default .cm-operator {color: black;}
 73 | .cm-s-default .cm-comment {color: #a50;}
 74 | .cm-s-default .cm-string {color: #a11;}
 75 | .cm-s-default .cm-string-2 {color: #f50;}
 76 | .cm-s-default .cm-meta {color: #555;}
 77 | .cm-s-default .cm-qualifier {color: #555;}
 78 | .cm-s-default .cm-builtin {color: #30a;}
 79 | .cm-s-default .cm-bracket {color: #997;}
 80 | .cm-s-default .cm-tag {color: #170;}
 81 | .cm-s-default .cm-attribute {color: #00c;}
 82 | .cm-s-default .cm-header {color: blue;}
 83 | .cm-s-default .cm-quote {color: #090;}
 84 | .cm-s-default .cm-hr {color: #999;}
 85 | .cm-s-default .cm-link {color: #00c;}
 86 | 
 87 | .cm-negative {color: #d44;}
 88 | .cm-positive {color: #292;}
 89 | .cm-header, .cm-strong {font-weight: bold;}
 90 | .cm-em {font-style: italic;}
 91 | .cm-link {text-decoration: underline;}
 92 | 
 93 | .cm-s-default .cm-error {color: #f00;}
 94 | .cm-invalidchar {color: #f00;}
 95 | 
 96 | div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
 97 | div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
 98 | .CodeMirror-activeline-background {background: #e8f2ff;}
 99 | 
100 | /* STOP */
101 | 
102 | /* The rest of this file contains styles related to the mechanics of
103 |    the editor. You probably shouldn't touch them. */
104 | 
105 | .CodeMirror {
106 |   line-height: 1;
107 |   position: relative;
108 |   overflow: hidden;
109 |   background: white;
110 |   color: black;
111 | }
112 | 
113 | .CodeMirror-scroll {
114 |   /* 30px is the magic margin used to hide the element's real scrollbars */
115 |   /* See overflow: hidden in .CodeMirror */
116 |   margin-bottom: -30px; margin-right: -30px;
117 |   padding-bottom: 30px; padding-right: 30px;
118 |   height: 100%;
119 |   outline: none; /* Prevent dragging from highlighting the element */
120 |   position: relative;
121 |   -moz-box-sizing: content-box;
122 |   box-sizing: content-box;
123 | }
124 | .CodeMirror-sizer {
125 |   position: relative;
126 | }
127 | 
128 | /* The fake, visible scrollbars. Used to force redraw during scrolling
129 |    before actuall scrolling happens, thus preventing shaking and
130 |    flickering artifacts. */
131 | .CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
132 |   position: absolute;
133 |   z-index: 6;
134 |   display: none;
135 | }
136 | .CodeMirror-vscrollbar {
137 |   right: 0; top: 0;
138 |   overflow-x: hidden;
139 |   overflow-y: scroll;
140 | }
141 | .CodeMirror-hscrollbar {
142 |   bottom: 0; left: 0;
143 |   overflow-y: hidden;
144 |   overflow-x: scroll;
145 | }
146 | .CodeMirror-scrollbar-filler {
147 |   right: 0; bottom: 0;
148 | }
149 | .CodeMirror-gutter-filler {
150 |   left: 0; bottom: 0;
151 | }
152 | 
153 | .CodeMirror-gutters {
154 |   position: absolute; left: 0; top: 0;
155 |   padding-bottom: 30px;
156 |   z-index: 3;
157 | }
158 | .CodeMirror-gutter {
159 |   white-space: normal;
160 |   height: 100%;
161 |   -moz-box-sizing: content-box;
162 |   box-sizing: content-box;
163 |   padding-bottom: 30px;
164 |   margin-bottom: -32px;
165 |   display: inline-block;
166 |   /* Hack to make IE7 behave */
167 |   *zoom:1;
168 |   *display:inline;
169 | }
170 | .CodeMirror-gutter-elt {
171 |   position: absolute;
172 |   cursor: default;
173 |   z-index: 4;
174 | }
175 | 
176 | .CodeMirror-lines {
177 |   cursor: text;
178 | }
179 | .CodeMirror pre {
180 |   /* Reset some styles that the rest of the page might have set */
181 |   -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
182 |   border-width: 0;
183 |   background: transparent;
184 |   font-family: inherit;
185 |   font-size: inherit;
186 |   margin: 0;
187 |   white-space: pre;
188 |   word-wrap: normal;
189 |   line-height: inherit;
190 |   color: inherit;
191 |   z-index: 2;
192 |   position: relative;
193 |   overflow: visible;
194 | }
195 | .CodeMirror-wrap pre {
196 |   word-wrap: break-word;
197 |   white-space: pre-wrap;
198 |   word-break: normal;
199 | }
200 | .CodeMirror-code pre {
201 |   border-right: 30px solid transparent;
202 |   width: -webkit-fit-content;
203 |   width: -moz-fit-content;
204 |   width: fit-content;
205 | }
206 | .CodeMirror-wrap .CodeMirror-code pre {
207 |   border-right: none;
208 |   width: auto;
209 | }
210 | .CodeMirror-linebackground {
211 |   position: absolute;
212 |   left: 0; right: 0; top: 0; bottom: 0;
213 |   z-index: 0;
214 | }
215 | 
216 | .CodeMirror-linewidget {
217 |   position: relative;
218 |   z-index: 2;
219 |   overflow: auto;
220 | }
221 | 
222 | .CodeMirror-widget {}
223 | 
224 | .CodeMirror-wrap .CodeMirror-scroll {
225 |   overflow-x: hidden;
226 | }
227 | 
228 | .CodeMirror-measure {
229 |   position: absolute;
230 |   width: 100%;
231 |   height: 0;
232 |   overflow: hidden;
233 |   visibility: hidden;
234 | }
235 | .CodeMirror-measure pre { position: static; }
236 | 
237 | .CodeMirror div.CodeMirror-cursor {
238 |   position: absolute;
239 |   visibility: hidden;
240 |   border-right: none;
241 |   width: 0;
242 | }
243 | .CodeMirror-focused div.CodeMirror-cursor {
244 |   visibility: visible;
245 | }
246 | 
247 | .CodeMirror-selected { background: #d9d9d9; }
248 | .CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
249 | 
250 | .cm-searching {
251 |   background: #ffa;
252 |   background: rgba(255, 255, 0, .4);
253 | }
254 | 
255 | /* IE7 hack to prevent it from returning funny offsetTops on the spans */
256 | .CodeMirror span { *vertical-align: text-bottom; }
257 | 
258 | @media print {
259 |   /* Hide the cursor when printing */
260 |   .CodeMirror div.CodeMirror-cursor {
261 |     visibility: hidden;
262 |   }
263 | }
264 | 


--------------------------------------------------------------------------------
/assets/style.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |   font-family: Helvetica, Arial, sans-serif;
  3 |   font-size: 14px;
  4 |   background-color: #efefef; 
  5 |   background-size: 26px 26px;
  6 |   margin: 0;
  7 | }
  8 | 
  9 | a {
 10 |   color: rgb(114, 189, 53);
 11 |   font-weight: bold;
 12 | }
 13 | 
 14 | a:hover {
 15 |   text-decoration: none;
 16 | }
 17 | 
 18 | header .links {
 19 |   float: right;
 20 |   font-size: 12px;
 21 |   margin-right: 4px;
 22 |   text-transform: none;
 23 | }
 24 | 
 25 | .gh-link a {
 26 |   color: #666;
 27 | }
 28 | 
 29 | header {
 30 |   background-color: rgba(255,255,255,0.8);
 31 |   padding: 10px 5px;
 32 |   border: 2px solid rgb(168,168,168);
 33 |   border-left: 0;
 34 |   border-right: 0
 35 | }
 36 | 
 37 | h1 {
 38 |   font-size: 12px;
 39 |   display: inline;
 40 |   position: relative;
 41 | }
 42 | 
 43 | .hammerpick {
 44 |   line-height: 12px;
 45 |   font-size: 38px;
 46 |   margin-left: 5px;
 47 |   float: left;
 48 |   color: rgb(114, 204, 40);
 49 | }
 50 | 
 51 | 
 52 | 
 53 | .subhead {
 54 |   font-size: 12px;
 55 |   text-transform: none;
 56 | }
 57 | 
 58 | header, h1, h2, h3 {
 59 |   padding-left: 10px;
 60 |   text-align: left;
 61 |   text-transform: uppercase;
 62 | }
 63 | 
 64 | h2 {
 65 |   font-size: 14px;
 66 | }
 67 | 
 68 | section {
 69 |   margin-bottom: 10px;
 70 | }
 71 | 
 72 | .ui-left {
 73 |   float: left;
 74 |   width: 500px;
 75 |   overflow: hidden;
 76 | }
 77 | 
 78 | .ui-right, #request-history .resp-info {
 79 |   margin-left: 520px;
 80 | }
 81 | 
 82 | #current-request {
 83 |   background-color: rgba(236, 236, 236, 0.8);
 84 |   border: 0px solid rgba(114, 204, 40,0.7);
 85 | 
 86 |   border-top-width: 5px;
 87 |   -webkit-transition: background-color 0.2s ease-in-out;                 
 88 |   -moz-transition: background-color 0.2s ease-in-out;                
 89 |   -o-transition: background-color 0.2s ease-in-out;  
 90 |   -ms-transition: background-color 0.2s ease-in-out;
 91 |   transition: background-color 0.2s ease-in-out;
 92 | }
 93 | 
 94 | #last-request {
 95 |   min-height: 544px;
 96 |   background-image: url('axe.png');
 97 |   background-repeat: no-repeat;
 98 |   background-position:center; 
 99 |   margin-top: 10px;
100 |   display: block;
101 |   border-top: 5px solid rgba(114, 204, 40,0.7);;
102 |   overflow: hidden;
103 |   background-color: #fff;
104 | }
105 | 
106 | #current-request form {
107 |   width: 500px;
108 | }
109 | 
110 | #current-request.highlight {
111 | 
112 |   background-color: rgb(241, 255, 229);
113 | }
114 | 
115 | #working-data, #historical-reqs {
116 |   border: 1px solid silver;
117 |   padding: 0 10px;
118 |   border-top: 0;
119 |   border-bottom: 0;
120 |   width: 100%;
121 |   position: relative;
122 |   width: 1100px;
123 |   margin: 0 auto;
124 | }
125 | 
126 | #last-request .body-cont {
127 |   display: none;
128 | }
129 | 
130 | .CodeMirror {
131 |   height: 494px;
132 | }
133 | 
134 | #request-history, #last-request {
135 |   font-family: monospace;
136 | }
137 | 
138 | #request-history {
139 |   clear: both;
140 |   padding-top: 0;
141 | }
142 | 
143 | #request-history-title {
144 |   font-family: Helvetica, Arial, sans-serif;
145 |   font-weight: bold;
146 |   font-size: 14px;
147 |   padding: 4px;
148 |   text-align: center;
149 |   border-bottom: 1px solid silver;
150 |   border-left: 0;
151 |   border-right: 0;
152 | }
153 | 
154 | #request-history .request {
155 |   padding: 10px 10px;
156 |   border-top: 5px solid rgba(114, 204, 40,0.7);
157 |   margin-bottom: 10px;
158 | 
159 |   background-color: rgb(255,255,255);
160 | }
161 | 
162 | #content {
163 |   background-color: rgba(255,255,255,0.7);
164 |   color: #333;
165 |   margin: 0px auto;
166 |   display: table;
167 |   width: 100%;
168 |   padding: 5px 0px;
169 |   border-bottom: 1px solid #eee;
170 | }
171 | 
172 | .request-form form {
173 |   display: table;
174 |   width: 100%;
175 | }
176 | 
177 | textarea {
178 |   line-height: 13px;
179 | }
180 | 
181 | .request-form form.method-post textarea, .request-form form.method-put textarea {
182 |   display: block;
183 | }
184 | 
185 | .request-form .errors {
186 |   font-weight: bold;
187 |   background-color: #fee;
188 |   margin: 5px 0;
189 | }
190 | 
191 | .request-form textarea {
192 |   width: 100%;
193 |   min-height: 80px;
194 | }
195 | 
196 | .request-form .fields {
197 |   display: table-row;
198 | }
199 | 
200 | .request-form #path {
201 |   display: table-cell;
202 |   width: 280px;
203 | }
204 | #method, #server {
205 |   display: table-cell;
206 | }
207 | 
208 | 
209 | #command-bar .labels, #command-bar .fields {
210 |   width: 920px;
211 |   display: table-row;
212 | }
213 | #command-bar .labels input, #command-bar .labels select, #command-bar .labels label, #command-bar .fields input, #command-bar .fields select, #command-bar .fields label {
214 |   display: inline-block;
215 |   padding: 2px 1px;
216 |   margin: 0px 5px;
217 | }
218 | #command-bar .labels #ajax-method, #command-bar .labels #ajax-method-label, #command-bar .fields #ajax-method, #command-bar .fields #ajax-method-label {
219 |   width: 80px;
220 | }
221 | #command-bar .labels #server, #command-bar .labels #server-label, #command-bar .fields #server, #command-bar .fields #server-label {
222 |   width: 200px;
223 | }
224 | #command-bar .labels #path, #command-bar .labels #path-label, #command-bar .fields #path, #command-bar .fields #path-label {
225 |   width: 500px;
226 | }
227 | 
228 | #body {
229 |   display: block;
230 |   float: left;
231 |   width: 450px;
232 |   min-height: 500px;
233 |   margin-top: 10px;
234 | }
235 | 
236 | #body label, #response label {
237 |   font-variant: small-caps;
238 | }
239 | 
240 | .response-cont, .body-cont {
241 |   position: relative;
242 | }
243 | 
244 | textarea.body {
245 |   background-color: #f8f8f8;
246 | }
247 | 
248 | .historical-req {
249 |   margin-top: 10px;
250 |   clear: both;
251 |   padding: 0 5px
252 | }
253 | 
254 | .historical-req .url {
255 |   font-size: 12px;
256 | }
257 | 
258 | .response-switches {
259 |   background-color: #f5f5f5;  
260 |   border-bottom: 1px solid silver;
261 | }
262 | 
263 | .showResponse {
264 |   float: left;
265 |   text-align: center;
266 |   border-right: 1px solid silver;
267 |   padding: 2px 3px;
268 |   cursor: pointer;
269 |   font-size: 12px;
270 |   color: #555;
271 | }
272 | 
273 | .showResponse[data-selected=true] {
274 |   color: #fefefe;
275 |   background-color: #888;
276 | }
277 | 
278 | .showResponse:hover {
279 |   text-decoration: underline;
280 | }
281 | 
282 | .response-cont .response-label, .body-cont .body-label {
283 |   font-size: 11px;
284 |   position: absolute;
285 |   top: 0;
286 |   right: 0;
287 |   padding: 1px 4px 1px 3px;
288 |   opacity: 0.8;
289 | }
290 | 
291 | .response-cont {
292 |   border: 1px solid;
293 |   width: 100%;
294 |   border-color: rgb(71, 36, 255);
295 |   overflow: auto;
296 |   background-color: white;
297 | }
298 | 
299 | .response-cont .fmt-nodes-top, .response-cont textarea {
300 |   max-height: 454px;
301 |   overflow: auto;
302 | }
303 | 
304 | .response-cont.json {
305 |   margin-top: 10px;
306 | }
307 | 
308 | .response-cont .response-label {
309 |   cursor: pointer;
310 | 
311 |   width: 70px;
312 | }
313 | 
314 | .response-label {
315 |   background: rgb(71, 36, 255);
316 |   color: #fafafa;
317 | }
318 | 
319 | .body-cont textarea.body {
320 |   border-color: rgba(180,180,180,1);
321 | }
322 | 
323 | .body-label {
324 |   background: rgba(180,180,180,1);
325 | }
326 | 
327 | .arrow {
328 |   font-weight: bold;
329 | }
330 | 
331 | .historical-req .method {
332 |   font-weight: bold;
333 | }
334 | 
335 | .req-meta {
336 |   display: inline-block;
337 |   padding-top: 3px;
338 |   position: relative;
339 | }
340 | 
341 | .req-meta th, .req-meta td {
342 |   vertical-align: top; /* Helps when a field overflows heightwise */
343 |   max-height: 15px;
344 |   overflow: hidden;
345 |   line-height: 10px;
346 |   border-right: 1px solid silver;
347 |   padding: 0 3px;
348 |   text-align: center;
349 |   font-weight: bold;
350 | }
351 | 
352 | .req-meta th:first-child, .req-meta td:first-child {
353 |   border-left: 1px solid silver;
354 | }
355 | 
356 | .req-meta th {
357 |   font-size: 10px;
358 | }
359 | 
360 | .req-meta td {
361 |   font-size: 12px;
362 | }
363 | 
364 | .req-meta td.server {
365 |   font-size: 10px;
366 |   max-width: 50px;
367 |   text-overflow: ellipsis;
368 |   overflow: hidden;
369 | }
370 | 
371 | .req-meta td.api {
372 |   text-transform: uppercase;
373 |   font-size: 10px;
374 |   padding: 2px;
375 |   min-width: 45px
376 | }
377 | 
378 | .req-meta td.api[data-api=document] {
379 |   color: rgb(197, 40, 204);
380 | }
381 | 
382 | .req-meta td.api[data-api=search] {
383 |   color: rgb(140, 182, 255);
384 | }
385 | 
386 | .req-meta td.server:hover {
387 |   max-width: none;
388 |   overflow: visible;
389 | }
390 | 
391 | #body {
392 |   margin-right: 15px;
393 | }
394 | 
395 | textarea.response, textarea.body {
396 |   white-space: pre-wrap;
397 |   margin: 0;
398 |   border: 1px solid silver;
399 |   border-top: 1px solid silver;
400 |   width: 100%;
401 |   color: black;
402 |   overflow: auto;
403 | }
404 | 
405 | .status {
406 |   font-weight: bold
407 | }
408 | 
409 | .misc-tools {
410 |   float: right;
411 |   min-width: 130px;
412 |   display: block;
413 |   text-align: right;
414 |   padding-top: 5px;
415 |   top: -5px;
416 | }
417 | 
418 | .run-again, .save {
419 |   cursor: pointer;
420 |   margin: 0 5px;
421 |   font-size: 18px;
422 |   line-height: 25px;
423 |   position: relative;
424 |   text-align: right;
425 | }
426 | 
427 | .misc-tools .small {
428 |   font-size:12px;
429 | }
430 | 
431 | .misc-tools span:hover {
432 |   color: #555;
433 | }
434 | 
435 | [data-status-group="errored"]:before {
436 |   color: red;
437 |   content: "CONN ERR ";
438 | }
439 | 
440 | .response-cont:hover .response-label, .body-cont:hover .body-label {
441 |   opacity: 0.3;
442 |   margin-right: 0;
443 |   -webkit-transition: all 0.05s ease-in-out;                 
444 |   -moz-transition: all 0.05s ease-in-out;                
445 |   -o-transition: all 0.05s ease-in-out;  
446 |   -ms-transition: all 0.05s ease-in-out;
447 |   transition: all 0.05s ease-in-out;
448 | }
449 | 
450 | .response-cont[data-status-group="500"] {
451 |   border-color: red;
452 | }
453 | 
454 | .response-cont[data-status-group="500"] .response-label {
455 |   background-color: red;
456 | }
457 | .status[data-status-group="500"] {
458 |   color: red;
459 | }
460 | 
461 | .response-cont[data-status-group="400"] {
462 |   border-color: orangered;
463 | }
464 | .response-cont[data-status-group="400"] .response-label {
465 |   background-color: orangered;
466 | }
467 | .status[data-status-group="400"] {
468 |   color: orangered;
469 | }
470 | 
471 | .response-cont[data-status-group="300"] {
472 |   border-color: purple;
473 | }
474 | .response-cont[data-status-group="300"] .response-label {
475 |   background-color: rgb(114, 204, 40);
476 | }
477 | .status[data-status-group="300"] {
478 |   color: rgb(114, 204, 40);
479 | }
480 | 
481 | .response-cont[data-status-group="200"] {
482 |   border-color: rgb(114, 204, 40);
483 | }
484 | .response-cont[data-status-group="200"] .response-label {
485 |   background-color: rgb(114, 204, 40);
486 | }
487 | .status[data-status-group="200"] {
488 |   color: rgb(114, 204, 40);
489 | }
490 | 
491 | .method-path {
492 |   padding-bottom: 4px;
493 | }
494 | 
495 | .context-meta.req-meta {
496 |   margin-top: 2px;
497 |   background-color: rgb(235, 255, 229);
498 |   border-left: 0;
499 |   border-right: 0;
500 |   width: 100%;
501 |   height: 30px;
502 |   top: 0;
503 | }
504 | 
505 | .context-meta.req-meta[data-shard-failure=true] {
506 |   background-color: rgb(255, 235, 229);  
507 | }
508 | 
509 | .context-meta.req-meta td {
510 |   padding: auto;
511 | }
512 | 
513 | textarea {
514 |   font-family: monospace;
515 |   font-size: 14px;
516 |   display: block;
517 |   width: 100%;
518 |   background: transparent;
519 | }
520 | 
521 | #submit-req {
522 |   width: 100%;
523 |   cursor: pointer;
524 |   border-radius: 7px;
525 |   background: rgb(198, 198, 198);
526 |   border: none;
527 | }
528 | 
529 | #submit-req:hover {
530 |   background: rgb(212, 212, 212);
531 | }
532 | 
533 | #submit-req:active {
534 |   background: rgb(225, 225, 225);
535 | }
536 | 
537 | .fmt-nodes-top {
538 |   margin-top: 5px;
539 |   font-size: 12px;
540 | }
541 | 
542 | .fmt-nodes-top .expandable {
543 |   cursor: pointer;
544 | }
545 | 
546 | .fmt-node:hover {
547 |   /*background-color: rgb(255,255,0);*/
548 | }
549 | 
550 | .fmt-nodes {
551 |   padding-left: 10px;
552 | }
553 | 
554 | ul.yaml-map, .fmt-nodes {
555 |   list-style-type: none;
556 | }
557 | 
558 | .yaml-array-elem > .yaml-map {
559 |   padding-left: 0;
560 | }
561 | 
562 | ul.yaml-map, .fmt-nodes ol.yaml-array {
563 |   margin: 3px 0px 2px 0px;
564 |   padding-left: 30px;
565 | }
566 | 
567 | .yaml-boolean {
568 |   font-weight: bold;
569 | }
570 | 
571 | .yaml-boolean.true {
572 |   color: #00AD15;
573 | }
574 | 
575 | .yaml-boolean.false {
576 |   color: #F15B2B;
577 | }
578 | 
579 | .yaml-number {
580 |   color: #EF3AFF;
581 | }
582 | 
583 | .yaml-map-key {
584 |   font-weight: bold;
585 |   color: #444;
586 | }
587 | 
588 | .fmt-node-value {
589 |   white-space: pre;
590 |   font-weight: bold;
591 | }
592 | 
593 | .fmt-nodes img {
594 |   width: 100px;
595 | }
596 | 
597 | #request-history-header {
598 |   background-color: #fff;
599 | }
600 | 
601 | #request-history .save {
602 |   display: none;
603 | }
604 | 
605 | #request-history-header h2 {
606 |   display: inline-block;
607 |   margin: 10px 0;
608 | }
609 | 
610 | #clear-request-history {
611 |   cursor: pointer;
612 |   font-size: 10px;
613 |   text-transform: uppercase;
614 |   color: orangered;
615 |   font-weight: bold;
616 | }
617 | 
618 | #clear-request-history:hover {
619 |   text-decoration: underline;
620 | }


--------------------------------------------------------------------------------
/assets/tiny_grid.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewvc/elastic-hammer/16a05e66af902b8d76d8985b29a81e73a3b03eac/assets/tiny_grid.png


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | 
  4 |   <head>
  5 | 
  6 |     <meta charset="UTF-8">
  7 | 
  8 |     <title>Elastic-Hammer</title>
  9 | 
 10 |     <link type='text/css' rel='stylesheet' style type='text/css' href="assets/codemirror.css"></link>
 11 |     <link type='text/css' rel='stylesheet' style type='text/css' href="assets/codemirror-addons/lint/lint.css"></link>
 12 |     <link type='text/css' rel='stylesheet' style type='text/css' href="assets/codemirror-addons/fold/foldgutter.css"></link>
 13 |     <link type='text/css' rel='stylesheet' style type='text/css' href="assets/codemirror-addons/hint/show-hint.css"></link>
 14 |     <link type='text/css' rel='stylesheet' style type='text/css' href="assets/style.css"></link>
 15 |     <script type='text/javascript' src='assets/jquery.js'></script>
 16 |     <script type='text/javascript' src='assets/knockback.js'></script>
 17 |     <script type="text/javascript" src="assets/backbone.localStorage.js"></script>
 18 |     <script type='text/javascript' src="assets/json2.js"></script>
 19 |     <script type='text/javascript' src='assets/codemirror.js'></script>
 20 |     <script type='text/javascript' src="assets/codemirror-addons/hint/show-hint.js"></script>
 21 |     <script type='text/javascript' src="assets/codemirror-addons/hint/javascript-hint.js"></script>
 22 |     <script type='text/javascript' src="assets/codemirror-addons/fold/foldcode.js"></script>
 23 |     <script type='text/javascript' src="assets/codemirror-addons/fold/foldgutter.js"></script>
 24 |     <script type='text/javascript' src="assets/codemirror-addons/fold/brace-fold.js"></script>
 25 |     <script type='text/javascript' src="assets/codemirror-addons/lint/lint.js"></script>
 26 |     <script type='text/javascript' src='assets/codemirror-addons/lint/javascript-lint.js'></script>
 27 |     <script type='text/javascript' src='assets/jsonlint.js'></script>
 28 |     <script type='text/javascript' src='assets/jshint.js'></script>
 29 |     <script type='text/javascript' src='assets/codemirror-addons/lint/json-lint.js'></script>
 30 | 
 31 |     <script type='text/javascript' src='assets/main.js'></script>
 32 | 
 33 |     <script type='text/javascript'>
 34 |       window.onbeforeunload = function(e) {
 35 |       return "Leaving will lose the current state. Request history is always saved.";
 36 |       };
 37 |     </script>
 38 | 
 39 |   </head>
 40 |   <body>
 41 |     <header>
 42 |       <span class='hammerpick'>&#9874;</span><h1>elastic hammer</h1>
 43 |       <div class="links">
 44 |         [
 45 |         <span id="clear-request-history" data-bind="event: {click: clear}">Clear Hist.</span> |
 46 |         <a href="http://exploringelasticsearch.com">book</a> |
 47 |         <a href="https://github.com/andrewvc/elastic-hammer">github</a>
 48 |         ]
 49 |       </div>
 50 |     </header>
 51 | 
 52 |     <datalist id="pathauto" data-bind="foreach: indexes">
 53 |       <option data-bind="text: index"></option>
 54 |     </datalist>
 55 | 
 56 |     <section id="working-data">
 57 |       <section id="current-request" class="request-form ui-left">
 58 |         <form data-bind="submit: exec, event: {keypress: checkCtrlEnter}">
 59 |           <input type='submit' data-bind="value: apiSubmit" id="submit-req" value='▶ Submit (&#9166; or CTRL+&#9166;)' />
 60 |           <div class='fields'>
 61 |             <select id="method" class='method' name='method' data-bind="value: method">
 62 |               <option value='GET'>GET</option>
 63 |               <option value='PUT'>PUT</option>
 64 |               <option value='POST'>POST</option>
 65 |               <option value='DELETE'>DELETE</option>
 66 |               <option value='HEAD'>HEAD</option>
 67 |             </select>
 68 |             <input id='server' class="server" placeholder='http://server:port' name='server' type='text' data-bind="value: server" />
 69 |             /
 70 |             <input id='path' placeholder='path' name='path' type='text' data-bind="value: path, event: {focus: fetchIndexes, keyup: updatePath, paste: updatePath}" list="pathauto" />
 71 |           </div>
 72 | 
 73 |           <div class="body-cont" data-bind="if: bodyCapable">
 74 |             <div class="errors" data-bind="text: errors"></div>
 75 |             <textarea id="current-request-body" name='body' class="body" data-bind="value: body, codemirror: { 'lineNumbers': true, 'matchBrackets': true, 'mode': 'text/typescript', json: true, lint: CodeMirror.lint.json, gutters: ['CodeMirror-lint-markers', 'CodeMirror-foldgutter']}"></textarea>
 76 |             <br />
 77 |             <small>
 78 |               <a href="#" id="format-req" data-bind="event: {click: format}">&raquo; Reformat Request</a>
 79 |             </small>
 80 |           </div>
 81 |         </form>
 82 |       </section>
 83 | 
 84 |       <section id="last-request" class="request-form ui-right">
 85 |         <!-- ko if: completed -->
 86 |         <div data-bind="template: {name: 'historical-request-tmpl'}"></div>
 87 |         <!-- /ko -->
 88 |         <!-- ko if: running -->
 89 |         Executing Request...
 90 | 
 91 |         <!-- /ko -->
 92 |       </section>
 93 | 
 94 |       <div style="clear: both"></div>
 95 |     </section>
 96 | 
 97 | 
 98 | <section id="request-history">
 99 |   <div id="request-history-title"></div>
100 |   <div id="historical-reqs" data-bind="foreach: requests">
101 |     <div class="historical-req-cont" data-bind="template: {name: 'historical-request-tmpl'}"></div>
102 |   </div>
103 | </section>
104 | 
105 | <script id="historical-request-tmpl" type="text/html">
106 |   <div class="historical-req request">
107 |     <div class='body-cont ui-left' data-bind="if: body">
108 |       <div class="body">
109 |         <textarea readonly='readonly' class='body' data-bind="text: body, autoTextArea: body"></textarea>
110 |       </div>
111 |     </div>
112 |     <div class="resp-info">
113 |       <div class="method-path" data-bind="attr: {'data-status-group': statusGroup}">
114 |         <span class="method" data-bind="text: method"></span>
115 |         <span class="url" data-bind="text: slashPath"></span>
116 |         <div>
117 |           <table class="req-meta">
118 |             <thead>
119 |               <th>API</th>
120 |               <th>server</th>
121 |               <th>rtt</th>
122 |               <th>status</th>
123 |               <th>state</th>
124 |             </thead>
125 |             <tbody>
126 |               <tr>
127 |                 <td class='api' data-bind="text: api, attr: {'data-api': api}"></td>
128 |                 <td class='server'  data-bind="text: serverNoProto"></td>
129 |                 <td class='rtt'  data-bind="text: rtt"></td>
130 |                 <td class='status' data-bind="attr: {'data-status-group': statusGroup}, text: status"></td>
131 |                 <td class='state' data-bind="attr: {'data-status-group': state}, text: state"></td>
132 |               </tr>
133 |             </tbody>
134 |           </table>
135 |           <span class="misc-tools">
136 |             <span class='run-again' data-bind="event: {click: runAgain}">↺R<span class="small">un Again</span></span>
137 |             /
138 |             <span class='save' data-bind="event: {click: save}">↯S<span class="small">ave</span></span>
139 |           </span>
140 |         </div>
141 |       </div>
142 | 
143 | 
144 | 
145 |       <!-- ko if: contextMeta -->
146 |       <table class='context-meta req-meta' data-bind="with: contextMeta, attr: {'data-shard-failure': shardFailure}">
147 |         <thead>
148 |           <tr data-bind="foreach: ths">
149 |             <th data-bind="text: th"></th>
150 |           </tr>
151 |         </thead>
152 |         <tbody>
153 |           <tr data-bind="foreach: tds">
154 |             <td data-bind="text: td"></td>
155 |           </tr>
156 |         </tbody>
157 |       </table>
158 |       <!-- /ko -->
159 | 
160 |       <div class='response-cont' data-bind="attr: {'data-status-group': statusGroup, 'data-shard-failure': shardFailure}, if: response">
161 |         <!-- ko if: formattableResponse -->
162 |         <div class="response-switches">
163 | 
164 |           <div class='showResponse' data-bind="event: {click: togglePretty}, attr: {'data-selected': prettyChosen}">Pretty Response</div>
165 |           <div class='showResponse' data-bind="event: {click: toggleJson}, attr: {'data-selected': jsonChosen}">JSON Response</div>
166 |           <div style="clear: both"></div>
167 |         </div>
168 |         <!-- /ko -->
169 | 
170 |         <!-- ko if: formattableResponse -->
171 |         <!-- ko if: prettyActivated -->
172 |         <div class='fmt-nodes fmt-nodes-top' data-bind="html: formattedResponse, event: {click: toggleExpansion}"></div>
173 |         <!-- /ko -->
174 |         <!-- /ko -->
175 | 
176 |         <!-- ko if: jsonActivated -->
177 |         <textarea readonly='readonly' class="response" data-bind="text: responseFmt, autoTextArea: responseFmt" ></textarea>
178 |         <!-- /ko -->
179 |       </div>
180 |     </div>
181 |   </div>
182 | </script>
183 | 
184 | <script type="text/javascript">
185 |   if (window.location.hostname === "elastichammer.exploringelasticsearch.com") {
186 |   (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
187 |   (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
188 |   m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
189 |   })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
190 | 
191 |   ga('create', 'UA-39929520-2', 'exploringelasticsearch.com');
192 |   ga('send', 'pageview');
193 |   }
194 | </script>
195 | 
196 | </body>
197 | 
198 | </html>
199 | 


--------------------------------------------------------------------------------