├── .gitignore ├── .github └── FUNDING.yml ├── code-mirror ├── addon │ ├── display │ │ ├── fullscreen.css │ │ ├── fullscreen.js │ │ └── placeholder.js │ ├── fold │ │ ├── foldgutter.css │ │ ├── indent-fold.js │ │ ├── comment-fold.js │ │ └── foldcode.js │ ├── edit │ │ ├── trailingspace.js │ │ ├── continuelist.js │ │ └── matchtags.js │ ├── lint │ │ ├── json-lint.js │ │ ├── css-lint.js │ │ ├── coffeescript-lint.js │ │ └── lint.css │ ├── dialog │ │ └── dialog.css │ ├── mode │ │ ├── multiplex_test.js │ │ ├── loadmode.js │ │ └── overlay.js │ ├── hint │ │ ├── show-hint.css │ │ ├── anyword-hint.js │ │ ├── css-hint.js │ │ ├── xml-hint.js │ │ └── sql-hint.js │ ├── runmode │ │ ├── colorize.js │ │ └── runmode.js │ ├── scroll │ │ └── scrollpastend.js │ ├── tern │ │ ├── worker.js │ │ └── tern.css │ ├── selection │ │ └── active-line.js │ ├── comment │ │ └── continuecomment.js │ └── merge │ │ └── merge.css └── mode │ ├── rpm │ ├── spec │ │ ├── spec.css │ │ └── spec.js │ └── changes │ │ ├── changes.js │ │ └── index.html │ ├── tiddlywiki │ └── tiddlywiki.css │ ├── tiki │ ├── tiki.css │ └── index.html │ ├── diff │ └── diff.js │ ├── ntriples │ └── index.html │ ├── jinja2 │ ├── jinja2.js │ └── index.html │ ├── http │ ├── index.html │ └── http.js │ ├── z80 │ ├── index.html │ └── z80.js │ ├── ecl │ └── index.html │ ├── rust │ └── index.html │ ├── pascal │ ├── index.html │ └── pascal.js │ ├── pig │ └── index.html │ ├── turtle │ └── index.html │ ├── vbscript │ └── index.html │ ├── gherkin │ └── index.html │ ├── properties │ ├── index.html │ └── properties.js │ ├── javascript │ ├── typescript.html │ └── test.js │ ├── sparql │ └── index.html │ ├── sass │ └── index.html │ ├── perl │ └── index.html │ ├── css │ ├── index.html │ ├── scss_test.js │ └── scss.html │ ├── shell │ └── index.html │ ├── gas │ └── index.html │ ├── toml │ ├── index.html │ └── toml.js │ ├── pegjs │ ├── index.html │ └── pegjs.js │ ├── smalltalk │ └── index.html │ ├── xml │ └── index.html │ ├── php │ └── index.html │ ├── octave │ └── index.html │ ├── htmlembedded │ ├── index.html │ └── htmlembedded.js │ ├── apl │ └── index.html │ ├── haml │ ├── index.html │ └── test.js │ ├── yaml │ ├── index.html │ └── yaml.js │ ├── lua │ └── index.html │ ├── erlang │ └── index.html │ ├── haskell │ └── index.html │ ├── go │ └── index.html │ ├── groovy │ └── index.html │ ├── jade │ ├── index.html │ └── jade.js │ ├── gfm │ ├── index.html │ └── gfm.js │ ├── haxe │ └── index.html │ ├── sql │ └── index.html │ ├── sieve │ └── index.html │ ├── fortran │ └── index.html │ ├── clojure │ └── index.html │ ├── scheme │ └── index.html │ ├── r │ └── index.html │ ├── htmlmixed │ └── index.html │ ├── julia │ └── index.html │ ├── ocaml │ └── ocaml.js │ └── stex │ └── test.js ├── LICENSE ├── CONTRIBUTING.md ├── package.json └── js └── functions.js /.gitignore: -------------------------------------------------------------------------------- 1 | *.swp 2 | *.swo 3 | *~ 4 | *.log 5 | node_modules 6 | *.env 7 | .DS_Store 8 | package-lock.json 9 | .bloggify/* 10 | -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: ionicabizau 2 | patreon: ionicabizau 3 | open_collective: ionicabizau 4 | custom: https://www.buymeacoffee.com/h96wwchmy -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/rpm/spec/spec.css: -------------------------------------------------------------------------------- 1 | .cm-s-default span.cm-preamble {color: #b26818; font-weight: bold;} 2 | .cm-s-default span.cm-macro {color: #b218b2;} 3 | .cm-s-default span.cm-section {color: green; font-weight: bold;} 4 | .cm-s-default span.cm-script {color: red;} 5 | .cm-s-default span.cm-issue {color: yellow;} 6 | -------------------------------------------------------------------------------- /code-mirror/mode/tiddlywiki/tiddlywiki.css: -------------------------------------------------------------------------------- 1 | span.cm-underlined { 2 | text-decoration: underline; 3 | } 4 | span.cm-strikethrough { 5 | text-decoration: line-through; 6 | } 7 | span.cm-brace { 8 | color: #170; 9 | font-weight: bold; 10 | } 11 | span.cm-table { 12 | color: blue; 13 | font-weight: bold; 14 | } 15 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/tiki/tiki.css: -------------------------------------------------------------------------------- 1 | .cm-tw-syntaxerror { 2 | color: #FFF; 3 | background-color: #900; 4 | } 5 | 6 | .cm-tw-deleted { 7 | text-decoration: line-through; 8 | } 9 | 10 | .cm-tw-header5 { 11 | font-weight: bold; 12 | } 13 | .cm-tw-listitem:first-child { /*Added first child to fix duplicate padding when highlighting*/ 14 | padding-left: 10px; 15 | } 16 | 17 | .cm-tw-box { 18 | border-top-width: 0px ! important; 19 | border-style: solid; 20 | border-width: 1px; 21 | border-color: inherit; 22 | } 23 | 24 | .cm-tw-underline { 25 | text-decoration: underline; 26 | } -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/rpm/changes/changes.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("changes", function() { 2 | var headerSeperator = /^-+$/; 3 | var headerLine = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ?\d{1,2} \d{2}:\d{2}(:\d{2})? [A-Z]{3,4} \d{4} - /; 4 | var simpleEmail = /^[\w+.-]+@[\w.-]+/; 5 | 6 | return { 7 | token: function(stream) { 8 | if (stream.sol()) { 9 | if (stream.match(headerSeperator)) { return 'tag'; } 10 | if (stream.match(headerLine)) { return 'tag'; } 11 | } 12 | if (stream.match(simpleEmail)) { return 'string'; } 13 | stream.next(); 14 | return null; 15 | } 16 | }; 17 | }); 18 | 19 | CodeMirror.defineMIME("text/x-rpm-changes", "changes"); 20 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/diff/diff.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("diff", function() { 2 | 3 | var TOKEN_NAMES = { 4 | '+': 'positive', 5 | '-': 'negative', 6 | '@': 'meta' 7 | }; 8 | 9 | return { 10 | token: function(stream) { 11 | var tw_pos = stream.string.search(/[\t ]+?$/); 12 | 13 | if (!stream.sol() || tw_pos === 0) { 14 | stream.skipToEnd(); 15 | return ("error " + ( 16 | TOKEN_NAMES[stream.string.charAt(0)] || '')).replace(/ $/, ''); 17 | } 18 | 19 | var token_name = TOKEN_NAMES[stream.peek()] || stream.skipToEnd(); 20 | 21 | if (tw_pos === -1) { 22 | stream.skipToEnd(); 23 | } else { 24 | stream.pos = tw_pos; 25 | } 26 | 27 | return token_name; 28 | } 29 | }; 30 | }); 31 | 32 | CodeMirror.defineMIME("text/x-diff", "diff"); 33 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014-25 Ionică Bizău (https://ionicabizau.net) 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /code-mirror/addon/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 = ""; 16 | wrap.style.height = "auto"; 17 | wrap.className += " CodeMirror-fullscreen"; 18 | document.documentElement.style.overflow = "hidden"; 19 | cm.refresh(); 20 | } 21 | 22 | function setNormal(cm) { 23 | var wrap = cm.getWrapperElement(); 24 | wrap.className = wrap.className.replace(/\s*CodeMirror-fullscreen\b/, ""); 25 | document.documentElement.style.overflow = ""; 26 | var info = cm.state.fullScreenRestore; 27 | wrap.style.width = info.width; wrap.style.height = info.height; 28 | window.scrollTo(info.scrollLeft, info.scrollTop); 29 | cm.refresh(); 30 | } 31 | })(); 32 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/fold/indent-fold.js: -------------------------------------------------------------------------------- 1 | CodeMirror.registerHelper("fold", "indent", function(cm, start) { 2 | var tabSize = cm.getOption("tabSize"), firstLine = cm.getLine(start.line); 3 | if (!/\S/.test(firstLine)) return; 4 | var getIndent = function(lineNum) { 5 | return CodeMirror.countColumn(lineNum, null, tabSize); 6 | }; 7 | var myIndent = getIndent(firstLine); 8 | var lastLineInFold = null; 9 | // Go through lines until we find a line that definitely doesn't belong in 10 | // the block we're folding, or to the end. 11 | for (var i = start.line + 1, end = cm.lastLine(); i <= end; ++i) { 12 | var curLine = cm.getLine(i); 13 | var curIndent = getIndent(curLine); 14 | if (curIndent > myIndent) { 15 | // Lines with a greater indent are considered part of the block. 16 | lastLineInFold = i; 17 | } else if (!/\S/.test(curLine)) { 18 | // Empty lines might be breaks within the block we're trying to fold. 19 | } else { 20 | // A non-empty line at an indent equal to or less than ours marks the 21 | // start of another block. 22 | break; 23 | } 24 | } 25 | if (lastLineInFold) return { 26 | from: CodeMirror.Pos(start.line, firstLine.length), 27 | to: CodeMirror.Pos(lastLineInFold, cm.getLine(lastLineInFold).length) 28 | }; 29 | }); 30 | CodeMirror.indentRangeFinder = CodeMirror.fold.indent; // deprecated 31 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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
the CSS class "CodeMirror-activeline", 5 | // and gives its background
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 | -------------------------------------------------------------------------------- /code-mirror/mode/ntriples/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: NTriples mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 15 | 28 | 29 |
30 |

NTriples mode

31 |
32 | 39 |
40 | 41 | 44 |

MIME types defined: text/n-triples.

45 |
46 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # 🌟 Contributing 2 | 3 | Want to contribute to this project? Great! Please read these quick steps to streamline the process and avoid unnecessary tasks. ✨ 4 | 5 | ## 💬 Discuss Changes 6 | Start by opening an issue in the repository using the [bug tracker][1]. Describe your proposed contribution or the bug you've found. If relevant, include platform info and screenshots. 🖼️ 7 | 8 | Wait for feedback before proceeding unless the fix is straightforward, like a typo. 📝 9 | 10 | ## 🔧 Fixing Issues 11 | 12 | Fork the project and create a branch for your fix, naming it `some-great-feature` or `some-issue-fix`. Commit changes while following the [code style][2]. If the project has tests, add one. ✅ 13 | 14 | If a `package.json` or `bower.json` exists, add yourself to the `contributors` array; create it if it doesn't. 🙌 15 | 16 | ```json 17 | { 18 | "contributors": [ 19 | "Your Name (http://your.website)" 20 | ] 21 | } 22 | ``` 23 | 24 | ## 📬 Creating a Pull Request 25 | Open a pull request and reference the initial issue (e.g., *fixes #*). Provide a clear title and consider adding visual aids for clarity. 📊 26 | 27 | ## ⏳ Wait for Feedback 28 | Your contributions will be reviewed. If feedback is given, update your branch as needed, and the pull request will auto-update. 🔄 29 | 30 | ## 🎉 Everyone Is Happy! 31 | Your contributions will be merged, and everyone will appreciate your effort! 😄❤️ 32 | 33 | Thanks! 🤩 34 | 35 | [1]: /issues 36 | [2]: https://github.com/IonicaBizau/code-style -------------------------------------------------------------------------------- /code-mirror/mode/jinja2/jinja2.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("jinja2", function() { 2 | var keywords = ["block", "endblock", "for", "endfor", "in", "true", "false", 3 | "loop", "none", "self", "super", "if", "as", "not", "and", 4 | "else", "import", "with", "without", "context"]; 5 | keywords = new RegExp("^((" + keywords.join(")|(") + "))\\b"); 6 | 7 | function tokenBase (stream, state) { 8 | var ch = stream.next(); 9 | if (ch == "{") { 10 | if (ch = stream.eat(/\{|%|#/)) { 11 | stream.eat("-"); 12 | state.tokenize = inTag(ch); 13 | return "tag"; 14 | } 15 | } 16 | } 17 | function inTag (close) { 18 | if (close == "{") { 19 | close = "}"; 20 | } 21 | return function (stream, state) { 22 | var ch = stream.next(); 23 | if ((ch == close || (ch == "-" && stream.eat(close))) 24 | && stream.eat("}")) { 25 | state.tokenize = tokenBase; 26 | return "tag"; 27 | } 28 | if (stream.match(keywords)) { 29 | return "keyword"; 30 | } 31 | return close == "#" ? "comment" : "string"; 32 | }; 33 | } 34 | return { 35 | startState: function () { 36 | return {tokenize: tokenBase}; 37 | }, 38 | token: function (stream, state) { 39 | return state.tokenize(stream, state); 40 | } 41 | }; 42 | }); 43 | -------------------------------------------------------------------------------- /code-mirror/mode/http/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: HTTP mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

HTTP mode

27 | 28 | 29 |
39 | 40 | 43 | 44 |

MIME types defined: message/http.

45 |
46 | -------------------------------------------------------------------------------- /code-mirror/mode/jinja2/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Jinja2 mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Jinja2 mode

27 |
45 | 50 |
51 | -------------------------------------------------------------------------------- /code-mirror/mode/z80/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Z80 assembly mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Z80 assembly mode

27 | 28 | 29 |
44 | 45 | 50 | 51 |

MIME type defined: text/x-z80.

52 |
53 | -------------------------------------------------------------------------------- /code-mirror/mode/ecl/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: ECL mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

ECL mode

27 |
45 | 48 | 49 |

Based on CodeMirror's clike mode. For more information see HPCC Systems web site.

50 |

MIME types defined: text/x-ecl.

51 | 52 |
53 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/rust/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Rust mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Rust mode

27 | 28 | 29 |
52 | 53 | 59 | 60 |

MIME types defined: text/x-rustsrc.

61 |
62 | -------------------------------------------------------------------------------- /code-mirror/mode/pascal/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Pascal mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Pascal mode

27 | 28 | 29 |
52 | 53 | 59 | 60 |

MIME types defined: text/x-pascal.

61 |
62 | -------------------------------------------------------------------------------- /code-mirror/mode/pig/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Pig Latin mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Pig Latin mode

27 |
39 | 40 | 47 | 48 |

49 | Simple mode that handles Pig Latin language. 50 |

51 | 52 |

MIME type defined: text/x-pig 53 | (PIG code) 54 | 55 |

56 | -------------------------------------------------------------------------------- /code-mirror/mode/turtle/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Turtle mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Turtle mode

27 |
41 | 48 | 49 |

MIME types defined: text/turtle.

50 | 51 |
52 | -------------------------------------------------------------------------------- /code-mirror/mode/vbscript/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: VBScript mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

VBScript mode

27 | 28 | 29 |
46 | 47 | 53 | 54 |

MIME types defined: text/vbscript.

55 |
56 | -------------------------------------------------------------------------------- /code-mirror/mode/gherkin/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Gherkin mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Gherkin mode

27 |
42 | 45 | 46 |

MIME types defined: text/x-feature.

47 | 48 |
49 | -------------------------------------------------------------------------------- /code-mirror/addon/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("blur", onBlur); 6 | cm.on("change", onChange); 7 | onChange(cm); 8 | } else if (!val && prev) { 9 | cm.off("blur", onBlur); 10 | cm.off("change", onChange); 11 | clearPlaceholder(cm); 12 | var wrapper = cm.getWrapperElement(); 13 | wrapper.className = wrapper.className.replace(" CodeMirror-empty", ""); 14 | } 15 | 16 | if (val && !cm.hasFocus()) onBlur(cm); 17 | }); 18 | 19 | function clearPlaceholder(cm) { 20 | if (cm.state.placeholder) { 21 | cm.state.placeholder.parentNode.removeChild(cm.state.placeholder); 22 | cm.state.placeholder = null; 23 | } 24 | } 25 | function setPlaceholder(cm) { 26 | clearPlaceholder(cm); 27 | var elt = cm.state.placeholder = document.createElement("pre"); 28 | elt.style.cssText = "height: 0; overflow: visible"; 29 | elt.className = "CodeMirror-placeholder"; 30 | elt.appendChild(document.createTextNode(cm.getOption("placeholder"))); 31 | cm.display.lineSpace.insertBefore(elt, cm.display.lineSpace.firstChild); 32 | } 33 | 34 | function onBlur(cm) { 35 | if (isEmpty(cm)) setPlaceholder(cm); 36 | } 37 | function onChange(cm) { 38 | var wrapper = cm.getWrapperElement(), empty = isEmpty(cm); 39 | wrapper.className = wrapper.className.replace(" CodeMirror-empty", "") + (empty ? " CodeMirror-empty" : ""); 40 | 41 | if (empty) setPlaceholder(cm); 42 | else clearPlaceholder(cm); 43 | } 44 | 45 | function isEmpty(cm) { 46 | return (cm.lineCount() === 1) && (cm.getLine(0) === ""); 47 | } 48 | })(); 49 | -------------------------------------------------------------------------------- /code-mirror/mode/properties/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Properties files mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Properties files mode

27 |
46 | 49 | 50 |

MIME types defined: text/x-properties, 51 | text/x-ini.

52 | 53 |
54 | -------------------------------------------------------------------------------- /code-mirror/mode/javascript/typescript.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: TypeScript mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

TypeScript mode

27 | 28 | 29 |
51 | 52 | 59 | 60 |

This is a specialization of the JavaScript mode.

61 |
62 | -------------------------------------------------------------------------------- /code-mirror/mode/sparql/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: SPARQL mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 25 | 26 |
27 |

SPARQL mode

28 |
44 | 51 | 52 |

MIME types defined: application/x-sparql-query.

53 | 54 |
55 | -------------------------------------------------------------------------------- /code-mirror/mode/sass/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Sass mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 25 | 26 |
27 |

Sass mode

28 |
58 | 64 | 65 |

MIME types defined: text/x-sass.

66 |
67 | -------------------------------------------------------------------------------- /code-mirror/mode/perl/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Perl mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Perl mode

27 | 28 | 29 |
67 | 68 | 73 | 74 |

MIME types defined: text/x-perl.

75 |
76 | -------------------------------------------------------------------------------- /code-mirror/mode/css/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: CSS mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

CSS mode

27 |
62 | 65 | 66 |

MIME types defined: text/css.

67 | 68 |

Parsing/Highlighting Tests: normal, verbose.

69 | 70 |
71 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/shell/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Shell mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 14 | 27 | 28 |
29 |

Shell mode

30 | 31 | 32 | 56 | 57 | 64 | 65 |

MIME types defined: text/x-sh.

66 |
67 | -------------------------------------------------------------------------------- /code-mirror/mode/properties/properties.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("properties", function() { 2 | return { 3 | token: function(stream, state) { 4 | var sol = stream.sol() || state.afterSection; 5 | var eol = stream.eol(); 6 | 7 | state.afterSection = false; 8 | 9 | if (sol) { 10 | if (state.nextMultiline) { 11 | state.inMultiline = true; 12 | state.nextMultiline = false; 13 | } else { 14 | state.position = "def"; 15 | } 16 | } 17 | 18 | if (eol && ! state.nextMultiline) { 19 | state.inMultiline = false; 20 | state.position = "def"; 21 | } 22 | 23 | if (sol) { 24 | while(stream.eatSpace()); 25 | } 26 | 27 | var ch = stream.next(); 28 | 29 | if (sol && (ch === "#" || ch === "!" || ch === ";")) { 30 | state.position = "comment"; 31 | stream.skipToEnd(); 32 | return "comment"; 33 | } else if (sol && ch === "[") { 34 | state.afterSection = true; 35 | stream.skipTo("]"); stream.eat("]"); 36 | return "header"; 37 | } else if (ch === "=" || ch === ":") { 38 | state.position = "quote"; 39 | return null; 40 | } else if (ch === "\\" && state.position === "quote") { 41 | if (stream.next() !== "u") { // u = Unicode sequence \u1234 42 | // Multiline value 43 | state.nextMultiline = true; 44 | } 45 | } 46 | 47 | return state.position; 48 | }, 49 | 50 | startState: function() { 51 | return { 52 | position : "def", // Current position, "def", "quote" or "comment" 53 | nextMultiline : false, // Is the next line multiline value 54 | inMultiline : false, // Is the current line a multiline value 55 | afterSection : false // Did we just open a section 56 | }; 57 | } 58 | 59 | }; 60 | }); 61 | 62 | CodeMirror.defineMIME("text/x-properties", "properties"); 63 | CodeMirror.defineMIME("text/x-ini", "properties"); 64 | -------------------------------------------------------------------------------- /code-mirror/mode/gas/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Gas mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Gas mode

27 |
28 | 50 |
51 | 52 | 58 | 59 |

Handles AT&T assembler syntax (more specifically this handles 60 | the GNU Assembler (gas) syntax.) 61 | It takes a single optional configuration parameter: 62 | architecture, which can be one of "ARM", 63 | "ARMv6" or "x86". 64 | Including the parameter adds syntax for the registers and special 65 | directives for the supplied architecture. 66 | 67 |

MIME types defined: text/x-gas

68 |
69 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/toml/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: TOML Mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

TOML Mode

27 |
64 | 70 |

The TOML Mode

71 |

Created by Forbes Lindesay.

72 |

MIME type defined: text/x-toml.

73 |
74 | -------------------------------------------------------------------------------- /code-mirror/mode/pegjs/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | CodeMirror: PEG.js Mode 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 28 | 29 |
30 |

PEG.js Mode

31 |
56 | 62 |

The PEG.js Mode

63 |

Created by Forbes Lindesay.

64 |
65 | 66 | 67 | -------------------------------------------------------------------------------- /code-mirror/mode/tiki/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Tiki wiki mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 25 | 26 |
27 |

Tiki wiki mode

28 | 29 | 30 |
87 | 88 | 94 | 95 |
96 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/smalltalk/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Smalltalk mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 16 | 29 | 30 |
31 |

Smalltalk mode

32 |
55 | 56 | 64 | 65 |

Simple Smalltalk mode.

66 | 67 |

MIME types defined: text/x-stsrc.

68 |
69 | -------------------------------------------------------------------------------- /code-mirror/mode/xml/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: XML mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

XML mode

27 |
39 | 45 |

The XML mode supports two configuration parameters:

46 |
47 |
htmlMode (boolean)
48 |
This switches the mode to parse HTML instead of XML. This 49 | means attributes do not have to be quoted, and some elements 50 | (such as br) do not require a closing tag.
51 |
alignCDATA (boolean)
52 |
Setting this to true will force the opening tag of CDATA 53 | blocks to not be indented.
54 |
55 | 56 |

MIME types defined: application/xml, text/html.

57 |
58 | -------------------------------------------------------------------------------- /code-mirror/mode/php/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: PHP mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 30 | 31 |
32 |

PHP mode

33 |
44 | 45 | 56 | 57 |

Simple HTML/PHP mode based on 58 | the C-like mode. Depends on XML, 59 | JavaScript, CSS, HTMLMixed, and C-like modes.

60 | 61 |

MIME types defined: application/x-httpd-php (HTML with PHP code), text/x-php (plain, non-wrapped PHP code).

62 |
63 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/octave/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Octave mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Octave mode

27 | 28 |
82 | 93 | 94 |

MIME types defined: text/x-octave.

95 |
96 | -------------------------------------------------------------------------------- /code-mirror/mode/htmlembedded/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Html Embedded Scripts mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 28 | 29 |
30 |

Html Embedded Scripts mode

31 |
43 | 44 | 54 | 55 |

Mode for html embedded scripts like JSP and ASP.NET. Depends on HtmlMixed which in turn depends on 56 | JavaScript, CSS and XML.
Other dependancies include those of the scriping language chosen.

57 | 58 |

MIME types defined: application/x-aspx (ASP.NET), 59 | application/x-ejs (Embedded Javascript), application/x-jsp (JavaServer Pages)

60 |
61 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/apl/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: APL mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 14 | 27 | 28 |
29 |

APL mode

30 |
56 | 57 | 64 | 65 |

Simple mode that tries to handle APL as well as it can.

66 |

It attempts to label functions/operators based upon 67 | monadic/dyadic usage (but this is far from fully fleshed out). 68 | This means there are meaningful classnames so hover states can 69 | have popups etc.

70 | 71 |

MIME types defined: text/apl (APL code)

72 |
73 | -------------------------------------------------------------------------------- /code-mirror/mode/haml/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: HAML mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 28 | 29 |
30 |

HAML mode

31 |
68 | 74 | 75 |

MIME types defined: text/x-haml.

76 | 77 |

Parsing/Highlighting Tests: normal, verbose.

78 | 79 |
80 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/yaml/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: YAML mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

YAML mode

27 |
74 | 77 | 78 |

MIME types defined: text/x-yaml.

79 | 80 |
81 | -------------------------------------------------------------------------------- /code-mirror/mode/lua/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Lua mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 26 | 27 |
28 |

Lua mode

29 |
70 | 77 | 78 |

Loosely based on Franciszek 79 | Wawrzak's CodeMirror 80 | 1 mode. One configuration parameter is 81 | supported, specials, to which you can provide an 82 | array of strings to have those identifiers highlighted with 83 | the lua-special style.

84 |

MIME types defined: text/x-lua.

85 | 86 |
87 | -------------------------------------------------------------------------------- /code-mirror/mode/erlang/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Erlang mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 26 | 27 |
28 |

Erlang mode

29 |
64 | 65 | 73 | 74 |

MIME types defined: text/x-erlang.

75 |
76 | -------------------------------------------------------------------------------- /code-mirror/mode/rpm/changes/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: RPM changes mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 26 | 27 |
28 |

RPM changes mode

29 | 30 |
57 | 65 | 66 |

MIME types defined: text/x-rpm-changes.

67 |
68 | -------------------------------------------------------------------------------- /code-mirror/mode/haskell/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Haskell mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 26 | 27 |
28 |

Haskell mode

29 |
63 | 64 | 71 | 72 |

MIME types defined: text/x-haskell.

73 |
74 | -------------------------------------------------------------------------------- /code-mirror/mode/go/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Go mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 26 | 27 |
28 |

Go mode

29 |
72 | 73 | 83 | 84 |

MIME type: text/x-go

85 |
86 | -------------------------------------------------------------------------------- /code-mirror/mode/groovy/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Groovy mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 25 | 26 |
27 |

Groovy mode

28 |
74 | 75 | 82 | 83 |

MIME types defined: text/x-groovy

84 |
85 | -------------------------------------------------------------------------------- /code-mirror/mode/jade/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Jade Templating Mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Jade Templating Mode

27 |
57 | 63 |

The Jade Templating Mode

64 |

Created by Drew Bratcher. Managed as part of an Adobe Brackets extension at https://github.com/dbratcher/brackets-jade.

65 |

MIME type defined: text/x-jade.

66 |
67 | -------------------------------------------------------------------------------- /code-mirror/mode/toml/toml.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("toml", function () { 2 | return { 3 | startState: function () { 4 | return { 5 | inString: false, 6 | stringType: "", 7 | lhs: true, 8 | inArray: 0 9 | }; 10 | }, 11 | token: function (stream, state) { 12 | //check for state changes 13 | if (!state.inString && ((stream.peek() == '"') || (stream.peek() == "'"))) { 14 | state.stringType = stream.peek(); 15 | stream.next(); // Skip quote 16 | state.inString = true; // Update state 17 | } 18 | if (stream.sol() && state.inArray === 0) { 19 | state.lhs = true; 20 | } 21 | //return state 22 | if (state.inString) { 23 | while (state.inString && !stream.eol()) { 24 | if (stream.peek() === state.stringType) { 25 | stream.next(); // Skip quote 26 | state.inString = false; // Clear flag 27 | } else if (stream.peek() === '\\') { 28 | stream.next(); 29 | stream.next(); 30 | } else { 31 | stream.match(/^.[^\\\"\']*/); 32 | } 33 | } 34 | return state.lhs ? "property string" : "string"; // Token style 35 | } else if (state.inArray && stream.peek() === ']') { 36 | stream.next(); 37 | state.inArray--; 38 | return 'bracket'; 39 | } else if (state.lhs && stream.peek() === '[' && stream.skipTo(']')) { 40 | stream.next();//skip closing ] 41 | return "atom"; 42 | } else if (stream.peek() === "#") { 43 | stream.skipToEnd(); 44 | return "comment"; 45 | } else if (stream.eatSpace()) { 46 | return null; 47 | } else if (state.lhs && stream.eatWhile(function (c) { return c != '=' && c != ' '; })) { 48 | return "property"; 49 | } else if (state.lhs && stream.peek() === "=") { 50 | stream.next(); 51 | state.lhs = false; 52 | return null; 53 | } else if (!state.lhs && stream.match(/^\d\d\d\d[\d\-\:\.T]*Z/)) { 54 | return 'atom'; //date 55 | } else if (!state.lhs && (stream.match('true') || stream.match('false'))) { 56 | return 'atom'; 57 | } else if (!state.lhs && stream.peek() === '[') { 58 | state.inArray++; 59 | stream.next(); 60 | return 'bracket'; 61 | } else if (!state.lhs && stream.match(/^\-?\d+(?:\.\d+)?/)) { 62 | return 'number'; 63 | } else if (!stream.eatSpace()) { 64 | stream.next(); 65 | } 66 | return null; 67 | } 68 | }; 69 | }); 70 | 71 | CodeMirror.defineMIME('text/x-toml', 'toml'); 72 | -------------------------------------------------------------------------------- /code-mirror/mode/gfm/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: GFM mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 31 | 32 |
33 |

GFM mode

34 |
69 | 70 | 77 | 78 |

Optionally depends on other modes for properly highlighted code blocks.

79 | 80 |

Parsing/Highlighting Tests: normal, verbose.

81 | 82 |
83 | -------------------------------------------------------------------------------- /code-mirror/mode/haxe/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Haxe mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Haxe mode

27 | 28 | 29 |
93 | 94 | 101 | 102 |

MIME types defined: text/x-haxe.

103 |
104 | -------------------------------------------------------------------------------- /code-mirror/mode/sql/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: SQL Mode for CodeMirror 4 | 5 | 6 | 7 | 8 | 9 | 10 | 16 | 29 | 30 |
31 |

SQL Mode for CodeMirror

32 |
33 | 48 |
49 |

MIME types defined: 50 | text/x-sql, 51 | text/x-mysql, 52 | text/x-mariadb, 53 | text/x-cassandra, 54 | text/x-plsql, 55 | text/x-mssql. 56 |

57 | 74 | 75 |
76 | -------------------------------------------------------------------------------- /code-mirror/mode/sieve/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Sieve (RFC5228) mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Sieve (RFC5228) mode

27 |
87 | 90 | 91 |

MIME types defined: application/sieve.

92 | 93 |
94 | -------------------------------------------------------------------------------- /code-mirror/mode/http/http.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("http", function() { 2 | function failFirstLine(stream, state) { 3 | stream.skipToEnd(); 4 | state.cur = header; 5 | return "error"; 6 | } 7 | 8 | function start(stream, state) { 9 | if (stream.match(/^HTTP\/\d\.\d/)) { 10 | state.cur = responseStatusCode; 11 | return "keyword"; 12 | } else if (stream.match(/^[A-Z]+/) && /[ \t]/.test(stream.peek())) { 13 | state.cur = requestPath; 14 | return "keyword"; 15 | } else { 16 | return failFirstLine(stream, state); 17 | } 18 | } 19 | 20 | function responseStatusCode(stream, state) { 21 | var code = stream.match(/^\d+/); 22 | if (!code) return failFirstLine(stream, state); 23 | 24 | state.cur = responseStatusText; 25 | var status = Number(code[0]); 26 | if (status >= 100 && status < 200) { 27 | return "positive informational"; 28 | } else if (status >= 200 && status < 300) { 29 | return "positive success"; 30 | } else if (status >= 300 && status < 400) { 31 | return "positive redirect"; 32 | } else if (status >= 400 && status < 500) { 33 | return "negative client-error"; 34 | } else if (status >= 500 && status < 600) { 35 | return "negative server-error"; 36 | } else { 37 | return "error"; 38 | } 39 | } 40 | 41 | function responseStatusText(stream, state) { 42 | stream.skipToEnd(); 43 | state.cur = header; 44 | return null; 45 | } 46 | 47 | function requestPath(stream, state) { 48 | stream.eatWhile(/\S/); 49 | state.cur = requestProtocol; 50 | return "string-2"; 51 | } 52 | 53 | function requestProtocol(stream, state) { 54 | if (stream.match(/^HTTP\/\d\.\d$/)) { 55 | state.cur = header; 56 | return "keyword"; 57 | } else { 58 | return failFirstLine(stream, state); 59 | } 60 | } 61 | 62 | function header(stream) { 63 | if (stream.sol() && !stream.eat(/[ \t]/)) { 64 | if (stream.match(/^.*?:/)) { 65 | return "atom"; 66 | } else { 67 | stream.skipToEnd(); 68 | return "error"; 69 | } 70 | } else { 71 | stream.skipToEnd(); 72 | return "string"; 73 | } 74 | } 75 | 76 | function body(stream) { 77 | stream.skipToEnd(); 78 | return null; 79 | } 80 | 81 | return { 82 | token: function(stream, state) { 83 | var cur = state.cur; 84 | if (cur != header && cur != body && stream.eatSpace()) return null; 85 | return cur(stream, state); 86 | }, 87 | 88 | blankLine: function(state) { 89 | state.cur = body; 90 | }, 91 | 92 | startState: function() { 93 | return {cur: start}; 94 | } 95 | }; 96 | }); 97 | 98 | CodeMirror.defineMIME("message/http", "http"); 99 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/z80/z80.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode('z80', function() { 2 | var keywords1 = /^(exx?|(ld|cp|in)([di]r?)?|pop|push|ad[cd]|cpl|daa|dec|inc|neg|sbc|sub|and|bit|[cs]cf|x?or|res|set|r[lr]c?a?|r[lr]d|s[lr]a|srl|djnz|nop|rst|[de]i|halt|im|ot[di]r|out[di]?)\b/i; 3 | var keywords2 = /^(call|j[pr]|ret[in]?)\b/i; 4 | var keywords3 = /^b_?(call|jump)\b/i; 5 | var variables1 = /^(af?|bc?|c|de?|e|hl?|l|i[xy]?|r|sp)\b/i; 6 | var variables2 = /^(n?[zc]|p[oe]?|m)\b/i; 7 | var errors = /^([hl][xy]|i[xy][hl]|slia|sll)\b/i; 8 | var numbers = /^([\da-f]+h|[0-7]+o|[01]+b|\d+)\b/i; 9 | 10 | return { 11 | startState: function() { 12 | return {context: 0}; 13 | }, 14 | token: function(stream, state) { 15 | if (!stream.column()) 16 | state.context = 0; 17 | 18 | if (stream.eatSpace()) 19 | return null; 20 | 21 | var w; 22 | 23 | if (stream.eatWhile(/\w/)) { 24 | w = stream.current(); 25 | 26 | if (stream.indentation()) { 27 | if (state.context == 1 && variables1.test(w)) 28 | return 'variable-2'; 29 | 30 | if (state.context == 2 && variables2.test(w)) 31 | return 'variable-3'; 32 | 33 | if (keywords1.test(w)) { 34 | state.context = 1; 35 | return 'keyword'; 36 | } else if (keywords2.test(w)) { 37 | state.context = 2; 38 | return 'keyword'; 39 | } else if (keywords3.test(w)) { 40 | state.context = 3; 41 | return 'keyword'; 42 | } 43 | 44 | if (errors.test(w)) 45 | return 'error'; 46 | } else if (numbers.test(w)) { 47 | return 'number'; 48 | } else { 49 | return null; 50 | } 51 | } else if (stream.eat(';')) { 52 | stream.skipToEnd(); 53 | return 'comment'; 54 | } else if (stream.eat('"')) { 55 | while (w = stream.next()) { 56 | if (w == '"') 57 | break; 58 | 59 | if (w == '\\') 60 | stream.next(); 61 | } 62 | return 'string'; 63 | } else if (stream.eat('\'')) { 64 | if (stream.match(/\\?.'/)) 65 | return 'number'; 66 | } else if (stream.eat('.') || stream.sol() && stream.eat('#')) { 67 | state.context = 4; 68 | 69 | if (stream.eatWhile(/\w/)) 70 | return 'def'; 71 | } else if (stream.eat('$')) { 72 | if (stream.eatWhile(/[\da-f]/i)) 73 | return 'number'; 74 | } else if (stream.eat('%')) { 75 | if (stream.eatWhile(/[01]/)) 76 | return 'number'; 77 | } else { 78 | stream.next(); 79 | } 80 | return null; 81 | } 82 | }; 83 | }); 84 | 85 | CodeMirror.defineMIME("text/x-z80", "z80"); 86 | -------------------------------------------------------------------------------- /code-mirror/mode/fortran/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Fortran mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Fortran mode

27 | 28 | 29 |
72 | 73 | 79 | 80 |

MIME types defined: text/x-Fortran.

81 |
82 | -------------------------------------------------------------------------------- /code-mirror/mode/clojure/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Clojure mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Clojure mode

27 |
82 | 85 | 86 |

MIME types defined: text/x-clojure.

87 | 88 |
89 | -------------------------------------------------------------------------------- /code-mirror/mode/scheme/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Scheme mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Scheme mode

27 |
71 | 74 | 75 |

MIME types defined: text/x-scheme.

76 | 77 |
78 | -------------------------------------------------------------------------------- /code-mirror/mode/htmlembedded/htmlembedded.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("htmlembedded", function(config, parserConfig) { 2 | 3 | //config settings 4 | var scriptStartRegex = parserConfig.scriptStartRegex || /^<%/i, 5 | scriptEndRegex = parserConfig.scriptEndRegex || /^%>/i; 6 | 7 | //inner modes 8 | var scriptingMode, htmlMixedMode; 9 | 10 | //tokenizer when in html mode 11 | function htmlDispatch(stream, state) { 12 | if (stream.match(scriptStartRegex, false)) { 13 | state.token=scriptingDispatch; 14 | return scriptingMode.token(stream, state.scriptState); 15 | } 16 | else 17 | return htmlMixedMode.token(stream, state.htmlState); 18 | } 19 | 20 | //tokenizer when in scripting mode 21 | function scriptingDispatch(stream, state) { 22 | if (stream.match(scriptEndRegex, false)) { 23 | state.token=htmlDispatch; 24 | return htmlMixedMode.token(stream, state.htmlState); 25 | } 26 | else 27 | return scriptingMode.token(stream, state.scriptState); 28 | } 29 | 30 | 31 | return { 32 | startState: function() { 33 | scriptingMode = scriptingMode || CodeMirror.getMode(config, parserConfig.scriptingModeSpec); 34 | htmlMixedMode = htmlMixedMode || CodeMirror.getMode(config, "htmlmixed"); 35 | return { 36 | token : parserConfig.startOpen ? scriptingDispatch : htmlDispatch, 37 | htmlState : CodeMirror.startState(htmlMixedMode), 38 | scriptState : CodeMirror.startState(scriptingMode) 39 | }; 40 | }, 41 | 42 | token: function(stream, state) { 43 | return state.token(stream, state); 44 | }, 45 | 46 | indent: function(state, textAfter) { 47 | if (state.token == htmlDispatch) 48 | return htmlMixedMode.indent(state.htmlState, textAfter); 49 | else if (scriptingMode.indent) 50 | return scriptingMode.indent(state.scriptState, textAfter); 51 | }, 52 | 53 | copyState: function(state) { 54 | return { 55 | token : state.token, 56 | htmlState : CodeMirror.copyState(htmlMixedMode, state.htmlState), 57 | scriptState : CodeMirror.copyState(scriptingMode, state.scriptState) 58 | }; 59 | }, 60 | 61 | electricChars: "/{}:", 62 | 63 | innerMode: function(state) { 64 | if (state.token == scriptingDispatch) return {state: state.scriptState, mode: scriptingMode}; 65 | else return {state: state.htmlState, mode: htmlMixedMode}; 66 | } 67 | }; 68 | }, "htmlmixed"); 69 | 70 | CodeMirror.defineMIME("application/x-ejs", { name: "htmlembedded", scriptingModeSpec:"javascript"}); 71 | CodeMirror.defineMIME("application/x-aspx", { name: "htmlembedded", scriptingModeSpec:"text/x-csharp"}); 72 | CodeMirror.defineMIME("application/x-jsp", { name: "htmlembedded", scriptingModeSpec:"text/x-java"}); 73 | CodeMirror.defineMIME("application/x-erb", { name: "htmlembedded", scriptingModeSpec:"ruby"}); 74 | -------------------------------------------------------------------------------- /code-mirror/mode/rpm/spec/spec.js: -------------------------------------------------------------------------------- 1 | // Quick and dirty spec file highlighting 2 | 3 | CodeMirror.defineMode("spec", function() { 4 | var arch = /^(i386|i586|i686|x86_64|ppc64|ppc|ia64|s390x|s390|sparc64|sparcv9|sparc|noarch|alphaev6|alpha|hppa|mipsel)/; 5 | 6 | var preamble = /^(Name|Version|Release|License|Summary|Url|Group|Source|BuildArch|BuildRequires|BuildRoot|AutoReqProv|Provides|Requires(\(\w+\))?|Obsoletes|Conflicts|Recommends|Source\d*|Patch\d*|ExclusiveArch|NoSource|Supplements):/; 7 | var section = /^%(debug_package|package|description|prep|build|install|files|clean|changelog|preun|postun|pre|post|triggerin|triggerun|pretrans|posttrans|verifyscript|check|triggerpostun|triggerprein|trigger)/; 8 | var control_flow_complex = /^%(ifnarch|ifarch|if)/; // rpm control flow macros 9 | var control_flow_simple = /^%(else|endif)/; // rpm control flow macros 10 | var operators = /^(\!|\?|\<\=|\<|\>\=|\>|\=\=|\&\&|\|\|)/; // operators in control flow macros 11 | 12 | return { 13 | startState: function () { 14 | return { 15 | controlFlow: false, 16 | macroParameters: false, 17 | section: false 18 | }; 19 | }, 20 | token: function (stream, state) { 21 | var ch = stream.peek(); 22 | if (ch == "#") { stream.skipToEnd(); return "comment"; } 23 | 24 | if (stream.sol()) { 25 | if (stream.match(preamble)) { return "preamble"; } 26 | if (stream.match(section)) { return "section"; } 27 | } 28 | 29 | if (stream.match(/^\$\w+/)) { return "def"; } // Variables like '$RPM_BUILD_ROOT' 30 | if (stream.match(/^\$\{\w+\}/)) { return "def"; } // Variables like '${RPM_BUILD_ROOT}' 31 | 32 | if (stream.match(control_flow_simple)) { return "keyword"; } 33 | if (stream.match(control_flow_complex)) { 34 | state.controlFlow = true; 35 | return "keyword"; 36 | } 37 | if (state.controlFlow) { 38 | if (stream.match(operators)) { return "operator"; } 39 | if (stream.match(/^(\d+)/)) { return "number"; } 40 | if (stream.eol()) { state.controlFlow = false; } 41 | } 42 | 43 | if (stream.match(arch)) { return "number"; } 44 | 45 | // Macros like '%make_install' or '%attr(0775,root,root)' 46 | if (stream.match(/^%[\w]+/)) { 47 | if (stream.match(/^\(/)) { state.macroParameters = true; } 48 | return "macro"; 49 | } 50 | if (state.macroParameters) { 51 | if (stream.match(/^\d+/)) { return "number";} 52 | if (stream.match(/^\)/)) { 53 | state.macroParameters = false; 54 | return "macro"; 55 | } 56 | } 57 | if (stream.match(/^%\{\??[\w \-]+\}/)) { return "macro"; } // Macros like '%{defined fedora}' 58 | 59 | //TODO: Include bash script sub-parser (CodeMirror supports that) 60 | stream.next(); 61 | return null; 62 | } 63 | }; 64 | }); 65 | 66 | CodeMirror.defineMIME("text/x-rpm-spec", "spec"); 67 | -------------------------------------------------------------------------------- /code-mirror/mode/r/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: R mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 17 | 30 | 31 |
32 |

R mode

33 |
76 | 79 | 80 |

MIME types defined: text/x-rsrc.

81 | 82 |

Development of the CodeMirror R mode was kindly sponsored 83 | by Ubalo, who hold 84 | the license.

85 | 86 |
87 | -------------------------------------------------------------------------------- /code-mirror/mode/pascal/pascal.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("pascal", function() { 2 | function words(str) { 3 | var obj = {}, words = str.split(" "); 4 | for (var i = 0; i < words.length; ++i) obj[words[i]] = true; 5 | return obj; 6 | } 7 | var keywords = words("and array begin case const div do downto else end file for forward integer " + 8 | "boolean char function goto if in label mod nil not of or packed procedure " + 9 | "program record repeat set string then to type until var while with"); 10 | var atoms = {"null": true}; 11 | 12 | var isOperatorChar = /[+\-*&%=<>!?|\/]/; 13 | 14 | function tokenBase(stream, state) { 15 | var ch = stream.next(); 16 | if (ch == "#" && state.startOfLine) { 17 | stream.skipToEnd(); 18 | return "meta"; 19 | } 20 | if (ch == '"' || ch == "'") { 21 | state.tokenize = tokenString(ch); 22 | return state.tokenize(stream, state); 23 | } 24 | if (ch == "(" && stream.eat("*")) { 25 | state.tokenize = tokenComment; 26 | return tokenComment(stream, state); 27 | } 28 | if (/[\[\]{}\(\),;\:\.]/.test(ch)) { 29 | return null; 30 | } 31 | if (/\d/.test(ch)) { 32 | stream.eatWhile(/[\w\.]/); 33 | return "number"; 34 | } 35 | if (ch == "/") { 36 | if (stream.eat("/")) { 37 | stream.skipToEnd(); 38 | return "comment"; 39 | } 40 | } 41 | if (isOperatorChar.test(ch)) { 42 | stream.eatWhile(isOperatorChar); 43 | return "operator"; 44 | } 45 | stream.eatWhile(/[\w\$_]/); 46 | var cur = stream.current(); 47 | if (keywords.propertyIsEnumerable(cur)) return "keyword"; 48 | if (atoms.propertyIsEnumerable(cur)) return "atom"; 49 | return "variable"; 50 | } 51 | 52 | function tokenString(quote) { 53 | return function(stream, state) { 54 | var escaped = false, next, end = false; 55 | while ((next = stream.next()) != null) { 56 | if (next == quote && !escaped) {end = true; break;} 57 | escaped = !escaped && next == "\\"; 58 | } 59 | if (end || !escaped) state.tokenize = null; 60 | return "string"; 61 | }; 62 | } 63 | 64 | function tokenComment(stream, state) { 65 | var maybeEnd = false, ch; 66 | while (ch = stream.next()) { 67 | if (ch == ")" && maybeEnd) { 68 | state.tokenize = null; 69 | break; 70 | } 71 | maybeEnd = (ch == "*"); 72 | } 73 | return "comment"; 74 | } 75 | 76 | // Interface 77 | 78 | return { 79 | startState: function() { 80 | return {tokenize: null}; 81 | }, 82 | 83 | token: function(stream, state) { 84 | if (stream.eatSpace()) return null; 85 | var style = (state.tokenize || tokenBase)(stream, state); 86 | if (style == "comment" || style == "meta") return style; 87 | return style; 88 | }, 89 | 90 | electricChars: "{}" 91 | }; 92 | }); 93 | 94 | CodeMirror.defineMIME("text/x-pascal", "pascal"); 95 | -------------------------------------------------------------------------------- /code-mirror/addon/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(""); 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 | -------------------------------------------------------------------------------- /code-mirror/mode/haml/test.js: -------------------------------------------------------------------------------- 1 | (function() { 2 | var mode = CodeMirror.getMode({tabSize: 4}, "haml"); 3 | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); } 4 | 5 | // Requires at least one media query 6 | MT("elementName", 7 | "[tag %h1] Hey There"); 8 | 9 | MT("oneElementPerLine", 10 | "[tag %h1] Hey There %h2"); 11 | 12 | MT("idSelector", 13 | "[tag %h1][attribute #test] Hey There"); 14 | 15 | MT("classSelector", 16 | "[tag %h1][attribute .hello] Hey There"); 17 | 18 | MT("docType", 19 | "[tag !!! XML]"); 20 | 21 | MT("comment", 22 | "[comment / Hello WORLD]"); 23 | 24 | MT("notComment", 25 | "[tag %h1] This is not a / comment "); 26 | 27 | MT("attributes", 28 | "[tag %a]([variable title][operator =][string \"test\"]){[atom :title] [operator =>] [string \"test\"]}"); 29 | 30 | MT("htmlCode", 31 | "[tag

]Title[tag

]"); 32 | 33 | MT("rubyBlock", 34 | "[operator =][variable-2 @item]"); 35 | 36 | MT("selectorRubyBlock", 37 | "[tag %a.selector=] [variable-2 @item]"); 38 | 39 | MT("nestedRubyBlock", 40 | "[tag %a]", 41 | " [operator =][variable puts] [string \"test\"]"); 42 | 43 | MT("multilinePlaintext", 44 | "[tag %p]", 45 | " Hello,", 46 | " World"); 47 | 48 | MT("multilineRuby", 49 | "[tag %p]", 50 | " [comment -# this is a comment]", 51 | " [comment and this is a comment too]", 52 | " Date/Time", 53 | " [operator -] [variable now] [operator =] [tag DateTime][operator .][variable now]", 54 | " [tag %strong=] [variable now]", 55 | " [operator -] [keyword if] [variable now] [operator >] [tag DateTime][operator .][variable parse]([string \"December 31, 2006\"])", 56 | " [operator =][string \"Happy\"]", 57 | " [operator =][string \"Belated\"]", 58 | " [operator =][string \"Birthday\"]"); 59 | 60 | MT("multilineComment", 61 | "[comment /]", 62 | " [comment Multiline]", 63 | " [comment Comment]"); 64 | 65 | MT("hamlComment", 66 | "[comment -# this is a comment]"); 67 | 68 | MT("multilineHamlComment", 69 | "[comment -# this is a comment]", 70 | " [comment and this is a comment too]"); 71 | 72 | MT("multilineHTMLComment", 73 | "[comment ]"); 76 | 77 | MT("hamlAfterRubyTag", 78 | "[attribute .block]", 79 | " [tag %strong=] [variable now]", 80 | " [attribute .test]", 81 | " [operator =][variable now]", 82 | " [attribute .right]"); 83 | 84 | MT("stretchedRuby", 85 | "[operator =] [variable puts] [string \"Hello\"],", 86 | " [string \"World\"]"); 87 | 88 | MT("interpolationInHashAttribute", 89 | //"[tag %div]{[atom :id] [operator =>] [string \"#{][variable test][string }_#{][variable ting][string }\"]} test"); 90 | "[tag %div]{[atom :id] [operator =>] [string \"#{][variable test][string }_#{][variable ting][string }\"]} test"); 91 | 92 | MT("interpolationInHTMLAttribute", 93 | "[tag %div]([variable title][operator =][string \"#{][variable test][string }_#{][variable ting]()[string }\"]) Test"); 94 | })(); 95 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/addon/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 | -------------------------------------------------------------------------------- /code-mirror/mode/htmlmixed/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: HTML mixed mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 28 | 29 |
30 |

HTML mixed mode

31 |
55 | 67 | 68 |

The HTML mixed mode depends on the XML, JavaScript, and CSS modes.

69 | 70 |

It takes an optional mode configuration 71 | option, scriptTypes, which can be used to add custom 72 | behavior for specific <script type="..."> tags. If 73 | given, it should hold an array of {matches, mode} 74 | objects, where matches is a string or regexp that 75 | matches the script type, and mode is 76 | either null, for script types that should stay in 77 | HTML mode, or a mode 78 | spec corresponding to the mode that should be used for the 79 | script.

80 | 81 |

MIME types defined: text/html 82 | (redefined, only takes effect if you load this parser after the 83 | XML parser).

84 | 85 |
86 | -------------------------------------------------------------------------------- /code-mirror/mode/julia/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: Julia mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

Julia mode

27 | 28 |
175 | 185 | 186 |

MIME types defined: text/x-julia.

187 |
188 | -------------------------------------------------------------------------------- /code-mirror/mode/ocaml/ocaml.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode('ocaml', function() { 2 | 3 | var words = { 4 | 'true': 'atom', 5 | 'false': 'atom', 6 | 'let': 'keyword', 7 | 'rec': 'keyword', 8 | 'in': 'keyword', 9 | 'of': 'keyword', 10 | 'and': 'keyword', 11 | 'succ': 'keyword', 12 | 'if': 'keyword', 13 | 'then': 'keyword', 14 | 'else': 'keyword', 15 | 'for': 'keyword', 16 | 'to': 'keyword', 17 | 'while': 'keyword', 18 | 'do': 'keyword', 19 | 'done': 'keyword', 20 | 'fun': 'keyword', 21 | 'function': 'keyword', 22 | 'val': 'keyword', 23 | 'type': 'keyword', 24 | 'mutable': 'keyword', 25 | 'match': 'keyword', 26 | 'with': 'keyword', 27 | 'try': 'keyword', 28 | 'raise': 'keyword', 29 | 'begin': 'keyword', 30 | 'end': 'keyword', 31 | 'open': 'builtin', 32 | 'trace': 'builtin', 33 | 'ignore': 'builtin', 34 | 'exit': 'builtin', 35 | 'print_string': 'builtin', 36 | 'print_endline': 'builtin' 37 | }; 38 | 39 | function tokenBase(stream, state) { 40 | var ch = stream.next(); 41 | 42 | if (ch === '"') { 43 | state.tokenize = tokenString; 44 | return state.tokenize(stream, state); 45 | } 46 | if (ch === '(') { 47 | if (stream.eat('*')) { 48 | state.commentLevel++; 49 | state.tokenize = tokenComment; 50 | return state.tokenize(stream, state); 51 | } 52 | } 53 | if (ch === '~') { 54 | stream.eatWhile(/\w/); 55 | return 'variable-2'; 56 | } 57 | if (ch === '`') { 58 | stream.eatWhile(/\w/); 59 | return 'quote'; 60 | } 61 | if (/\d/.test(ch)) { 62 | stream.eatWhile(/[\d]/); 63 | if (stream.eat('.')) { 64 | stream.eatWhile(/[\d]/); 65 | } 66 | return 'number'; 67 | } 68 | if ( /[+\-*&%=<>!?|]/.test(ch)) { 69 | return 'operator'; 70 | } 71 | stream.eatWhile(/\w/); 72 | var cur = stream.current(); 73 | return words[cur] || 'variable'; 74 | } 75 | 76 | function tokenString(stream, state) { 77 | var next, end = false, escaped = false; 78 | while ((next = stream.next()) != null) { 79 | if (next === '"' && !escaped) { 80 | end = true; 81 | break; 82 | } 83 | escaped = !escaped && next === '\\'; 84 | } 85 | if (end && !escaped) { 86 | state.tokenize = tokenBase; 87 | } 88 | return 'string'; 89 | }; 90 | 91 | function tokenComment(stream, state) { 92 | var prev, next; 93 | while(state.commentLevel > 0 && (next = stream.next()) != null) { 94 | if (prev === '(' && next === '*') state.commentLevel++; 95 | if (prev === '*' && next === ')') state.commentLevel--; 96 | prev = next; 97 | } 98 | if (state.commentLevel <= 0) { 99 | state.tokenize = tokenBase; 100 | } 101 | return 'comment'; 102 | } 103 | 104 | return { 105 | startState: function() {return {tokenize: tokenBase, commentLevel: 0};}, 106 | token: function(stream, state) { 107 | if (stream.eatSpace()) return null; 108 | return state.tokenize(stream, state); 109 | }, 110 | 111 | blockCommentStart: "(*", 112 | blockCommentEnd: "*)" 113 | }; 114 | }); 115 | 116 | CodeMirror.defineMIME('text/x-ocaml', 'ocaml'); 117 | -------------------------------------------------------------------------------- /code-mirror/mode/gfm/gfm.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("gfm", function(config) { 2 | var codeDepth = 0; 3 | function blankLine(state) { 4 | state.code = false; 5 | return null; 6 | } 7 | var gfmOverlay = { 8 | startState: function() { 9 | return { 10 | code: false, 11 | codeBlock: false, 12 | ateSpace: false 13 | }; 14 | }, 15 | copyState: function(s) { 16 | return { 17 | code: s.code, 18 | codeBlock: s.codeBlock, 19 | ateSpace: s.ateSpace 20 | }; 21 | }, 22 | token: function(stream, state) { 23 | // Hack to prevent formatting override inside code blocks (block and inline) 24 | if (state.codeBlock) { 25 | if (stream.match(/^```/)) { 26 | state.codeBlock = false; 27 | return null; 28 | } 29 | stream.skipToEnd(); 30 | return null; 31 | } 32 | if (stream.sol()) { 33 | state.code = false; 34 | } 35 | if (stream.sol() && stream.match(/^```/)) { 36 | stream.skipToEnd(); 37 | state.codeBlock = true; 38 | return null; 39 | } 40 | // If this block is changed, it may need to be updated in Markdown mode 41 | if (stream.peek() === '`') { 42 | stream.next(); 43 | var before = stream.pos; 44 | stream.eatWhile('`'); 45 | var difference = 1 + stream.pos - before; 46 | if (!state.code) { 47 | codeDepth = difference; 48 | state.code = true; 49 | } else { 50 | if (difference === codeDepth) { // Must be exact 51 | state.code = false; 52 | } 53 | } 54 | return null; 55 | } else if (state.code) { 56 | stream.next(); 57 | return null; 58 | } 59 | // Check if space. If so, links can be formatted later on 60 | if (stream.eatSpace()) { 61 | state.ateSpace = true; 62 | return null; 63 | } 64 | if (stream.sol() || state.ateSpace) { 65 | state.ateSpace = false; 66 | if(stream.match(/^(?:[a-zA-Z0-9\-_]+\/)?(?:[a-zA-Z0-9\-_]+@)?(?:[a-f0-9]{7,40}\b)/)) { 67 | // User/Project@SHA 68 | // User@SHA 69 | // SHA 70 | return "link"; 71 | } else if (stream.match(/^(?:[a-zA-Z0-9\-_]+\/)?(?:[a-zA-Z0-9\-_]+)?#[0-9]+\b/)) { 72 | // User/Project#Num 73 | // User#Num 74 | // #Num 75 | return "link"; 76 | } 77 | } 78 | if (stream.match(/^((?:[a-z][\w-]+:(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\([^\s()<>]*\))+(?:\([^\s()<>]*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))/i) && 79 | stream.string.slice(stream.start - 2, stream.start) != "](") { 80 | // URLs 81 | // Taken from http://daringfireball.net/2010/07/improved_regex_for_matching_urls 82 | // And then (issue #1160) simplified to make it not crash the Chrome Regexp engine 83 | return "link"; 84 | } 85 | stream.next(); 86 | return null; 87 | }, 88 | blankLine: blankLine 89 | }; 90 | CodeMirror.defineMIME("gfmBase", { 91 | name: "markdown", 92 | underscoresBreakWords: false, 93 | taskLists: true, 94 | fencedCodeBlocks: true 95 | }); 96 | return CodeMirror.overlayMode(CodeMirror.getMode(config, "gfmBase"), gfmOverlay); 97 | }, "markdown"); 98 | -------------------------------------------------------------------------------- /code-mirror/mode/javascript/test.js: -------------------------------------------------------------------------------- 1 | (function() { 2 | var mode = CodeMirror.getMode({indentUnit: 2}, "javascript"); 3 | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); } 4 | 5 | MT("locals", 6 | "[keyword function] [variable foo]([def a], [def b]) { [keyword var] [def c] = [number 10]; [keyword return] [variable-2 a] + [variable-2 c] + [variable d]; }"); 7 | 8 | MT("comma-and-binop", 9 | "[keyword function](){ [keyword var] [def x] = [number 1] + [number 2], [def y]; }"); 10 | 11 | MT("destructuring", 12 | "([keyword function]([def a], [[[def b], [def c] ]]) {", 13 | " [keyword let] {[def d], [property foo]: [def c]=[number 10], [def x]} = [variable foo]([variable-2 a]);", 14 | " [[[variable-2 c], [variable y] ]] = [variable-2 c];", 15 | "})();"); 16 | 17 | MT("class", 18 | "[keyword class] [variable Point] [keyword extends] [variable SuperThing] {", 19 | " [[ [string-2 /expr/] ]]: [number 24],", 20 | " [property constructor]([def x], [def y]) {", 21 | " [keyword super]([string 'something']);", 22 | " [keyword this].[property x] = [variable-2 x];", 23 | " }", 24 | "}"); 25 | 26 | MT("module", 27 | "[keyword module] [string 'foo'] {", 28 | " [keyword export] [keyword let] [def x] = [number 42];", 29 | " [keyword export] [keyword *] [keyword from] [string 'somewhere'];", 30 | "}"); 31 | 32 | MT("import", 33 | "[keyword function] [variable foo]() {", 34 | " [keyword import] [def $] [keyword from] [string 'jquery'];", 35 | " [keyword module] [def crypto] [keyword from] [string 'crypto'];", 36 | " [keyword import] { [def encrypt], [def decrypt] } [keyword from] [string 'crypto'];", 37 | "}"); 38 | 39 | MT("const", 40 | "[keyword function] [variable f]() {", 41 | " [keyword const] [[ [def a], [def b] ]] = [[ [number 1], [number 2] ]];", 42 | "}"); 43 | 44 | MT("for/of", 45 | "[keyword for]([keyword let] [variable of] [keyword of] [variable something]) {}"); 46 | 47 | MT("generator", 48 | "[keyword function*] [variable repeat]([def n]) {", 49 | " [keyword for]([keyword var] [def i] = [number 0]; [variable-2 i] < [variable-2 n]; ++[variable-2 i])", 50 | " [keyword yield] [variable-2 i];", 51 | "}"); 52 | 53 | MT("fatArrow", 54 | "[variable array].[property filter]([def a] => [variable-2 a] + [number 1]);", 55 | "[variable a];", // No longer in scope 56 | "[keyword let] [variable f] = ([[ [def a], [def b] ]], [def c]) => [variable-2 a] + [variable-2 c];", 57 | "[variable c];"); 58 | 59 | MT("spread", 60 | "[keyword function] [variable f]([def a], [meta ...][def b]) {", 61 | " [variable something]([variable-2 a], [meta ...][variable-2 b]);", 62 | "}"); 63 | 64 | MT("comprehension", 65 | "[keyword function] [variable f]() {", 66 | " [[ [variable x] + [number 1] [keyword for] ([keyword var] [def x] [keyword in] [variable y]) [keyword if] [variable pred]([variable-2 x]) ]];", 67 | " ([variable u] [keyword for] ([keyword var] [def u] [keyword of] [variable generateValues]()) [keyword if] ([variable-2 u].[property color] === [string 'blue']));", 68 | "}"); 69 | 70 | MT("quasi", 71 | "[variable re][string-2 `fofdlakj${][variable x] + ([variable re][string-2 `foo`]) + [number 1][string-2 }fdsa`] + [number 2]"); 72 | })(); 73 | -------------------------------------------------------------------------------- /code-mirror/mode/yaml/yaml.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("yaml", function() { 2 | 3 | var cons = ['true', 'false', 'on', 'off', 'yes', 'no']; 4 | var keywordRegex = new RegExp("\\b(("+cons.join(")|(")+"))$", 'i'); 5 | 6 | return { 7 | token: function(stream, state) { 8 | var ch = stream.peek(); 9 | var esc = state.escaped; 10 | state.escaped = false; 11 | /* comments */ 12 | if (ch == "#" && (stream.pos == 0 || /\s/.test(stream.string.charAt(stream.pos - 1)))) { 13 | stream.skipToEnd(); return "comment"; 14 | } 15 | if (state.literal && stream.indentation() > state.keyCol) { 16 | stream.skipToEnd(); return "string"; 17 | } else if (state.literal) { state.literal = false; } 18 | if (stream.sol()) { 19 | state.keyCol = 0; 20 | state.pair = false; 21 | state.pairStart = false; 22 | /* document start */ 23 | if(stream.match(/---/)) { return "def"; } 24 | /* document end */ 25 | if (stream.match(/\.\.\./)) { return "def"; } 26 | /* array list item */ 27 | if (stream.match(/\s*-\s+/)) { return 'meta'; } 28 | } 29 | /* inline pairs/lists */ 30 | if (stream.match(/^(\{|\}|\[|\])/)) { 31 | if (ch == '{') 32 | state.inlinePairs++; 33 | else if (ch == '}') 34 | state.inlinePairs--; 35 | else if (ch == '[') 36 | state.inlineList++; 37 | else 38 | state.inlineList--; 39 | return 'meta'; 40 | } 41 | 42 | /* list seperator */ 43 | if (state.inlineList > 0 && !esc && ch == ',') { 44 | stream.next(); 45 | return 'meta'; 46 | } 47 | /* pairs seperator */ 48 | if (state.inlinePairs > 0 && !esc && ch == ',') { 49 | state.keyCol = 0; 50 | state.pair = false; 51 | state.pairStart = false; 52 | stream.next(); 53 | return 'meta'; 54 | } 55 | 56 | /* start of value of a pair */ 57 | if (state.pairStart) { 58 | /* block literals */ 59 | if (stream.match(/^\s*(\||\>)\s*/)) { state.literal = true; return 'meta'; }; 60 | /* references */ 61 | if (stream.match(/^\s*(\&|\*)[a-z0-9\._-]+\b/i)) { return 'variable-2'; } 62 | /* numbers */ 63 | if (state.inlinePairs == 0 && stream.match(/^\s*-?[0-9\.\,]+\s?$/)) { return 'number'; } 64 | if (state.inlinePairs > 0 && stream.match(/^\s*-?[0-9\.\,]+\s?(?=(,|}))/)) { return 'number'; } 65 | /* keywords */ 66 | if (stream.match(keywordRegex)) { return 'keyword'; } 67 | } 68 | 69 | /* pairs (associative arrays) -> key */ 70 | if (!state.pair && stream.match(/^\s*\S+(?=\s*:($|\s))/i)) { 71 | state.pair = true; 72 | state.keyCol = stream.indentation(); 73 | return "atom"; 74 | } 75 | if (state.pair && stream.match(/^:\s*/)) { state.pairStart = true; return 'meta'; } 76 | 77 | /* nothing found, continue */ 78 | state.pairStart = false; 79 | state.escaped = (ch == '\\'); 80 | stream.next(); 81 | return null; 82 | }, 83 | startState: function() { 84 | return { 85 | pair: false, 86 | pairStart: false, 87 | keyCol: 0, 88 | inlinePairs: 0, 89 | inlineList: 0, 90 | literal: false, 91 | escaped: false 92 | }; 93 | } 94 | }; 95 | }); 96 | 97 | CodeMirror.defineMIME("text/x-yaml", "yaml"); 98 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "js-custom-operators", 3 | "version": "1.1.12", 4 | "description": "Create your own operators in JavaScript", 5 | "main": "lib/index.js", 6 | "scripts": { 7 | "test": "echo \"Error: no test specified\" && exit 1" 8 | }, 9 | "repository": { 10 | "type": "git", 11 | "url": "git+https://github.com/IonicaBizau/js-custom-operators.git" 12 | }, 13 | "keywords": [ 14 | "custom", 15 | "operators", 16 | "js" 17 | ], 18 | "author": "Ionică Bizău (https://ionicabizau.net)", 19 | "license": "MIT", 20 | "bugs": { 21 | "url": "https://github.com/IonicaBizau/js-custom-operators/issues" 22 | }, 23 | "homepage": "https://github.com/IonicaBizau/js-custom-operators#readme", 24 | "blah": { 25 | "ex_img": "http://i.imgur.com/15IaZnT.png", 26 | "description": [ 27 | { 28 | "h2": "Introduction" 29 | }, 30 | { 31 | "p": "During the Math classes we learned how to define new operators. For example:" 32 | }, 33 | { 34 | "h4": "`(ℝ, ∘), x ∘ y = x + 2y`" 35 | }, 36 | { 37 | "p": "This defines `∘` law. For any real numbers *x* and *y*, *x ∘ y* is *x + 2y*. e.g: `2 ∘ 2 = 2 + 4 = 6`." 38 | }, 39 | { 40 | "h2": "Custom operators in JavaScript?" 41 | }, 42 | { 43 | "p": "This projects finally bring this feature in the JavaScript world! :-) Using [**esprima**](http://esprima.org/) - which takes JS code and generates the syntax tree for it - and [**escodegen**](https://github.com/Constellation/escodegen) - which does the other direction, generating JS code from the syntax tree esprima spits - we can create new JavaScript operators." 44 | }, 45 | { 46 | "h2": "Example" 47 | }, 48 | { 49 | "p": "Having two arrays:" 50 | }, 51 | { 52 | "code": { 53 | "language": "js", 54 | "content": [ 55 | "var x = [1, 2, 3, 4, 5]", 56 | " , y = [3, 5, 6, 1]", 57 | " ;" 58 | ] 59 | } 60 | }, 61 | { 62 | "p": [ 63 | "we want to find the intersection of them (that is `[1, 3, 5]`).", 64 | "We can easily create a function `function foo (x, y) { ... }`, but why not create an operator instead?", 65 | "Then `x ⋂ y` will return the same thing. :-)" 66 | ] 67 | }, 68 | { 69 | "h2": "Live demo" 70 | }, 71 | { 72 | "p": "You can try this application online [clicking here](http://ionicabizau.github.io/js-custom-operators/)." 73 | } 74 | ], 75 | "thanks": { 76 | "ul": [ 77 | "[@benjamingr](https://github.com/benjamingr) posted this great [answer](http://stackoverflow.com/a/20764137/1420197) to my [question on StackOverflow](http://stackoverflow.com/q/20762338/1420197)", 78 | "[**esprima**](http://esprima.org/)", 79 | "[**escodegen**](https://github.com/Constellation/escodegen)" 80 | ] 81 | } 82 | }, 83 | "files": [ 84 | "bin/", 85 | "app/", 86 | "lib/", 87 | "dist/", 88 | "src/", 89 | "scripts/", 90 | "resources/", 91 | "menu/", 92 | "cli.js", 93 | "index.js", 94 | "index.d.ts", 95 | "package-lock.json", 96 | "bloggify.js", 97 | "bloggify.json", 98 | "bloggify/" 99 | ] 100 | } -------------------------------------------------------------------------------- /code-mirror/mode/css/scss_test.js: -------------------------------------------------------------------------------- 1 | (function() { 2 | var mode = CodeMirror.getMode({tabSize: 1}, "text/x-scss"); 3 | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), "scss"); } 4 | function IT(name) { test.indentation(name, mode, Array.prototype.slice.call(arguments, 1), "scss"); } 5 | 6 | MT('url_with_quotation', 7 | "[tag foo] { [property background][operator :][string-2 url]([string test.jpg]) }"); 8 | 9 | MT('url_with_double_quotes', 10 | "[tag foo] { [property background][operator :][string-2 url]([string \"test.jpg\"]) }"); 11 | 12 | MT('url_with_single_quotes', 13 | "[tag foo] { [property background][operator :][string-2 url]([string \'test.jpg\']) }"); 14 | 15 | MT('string', 16 | "[def @import] [string \"compass/css3\"]"); 17 | 18 | MT('important_keyword', 19 | "[tag foo] { [property background][operator :][string-2 url]([string \'test.jpg\']) [keyword !important] }"); 20 | 21 | MT('variable', 22 | "[variable-2 $blue][operator :][atom #333]"); 23 | 24 | MT('variable_as_attribute', 25 | "[tag foo] { [property color][operator :][variable-2 $blue] }"); 26 | 27 | MT('numbers', 28 | "[tag foo] { [property padding][operator :][number 10px] [number 10] [number 10em] [number 8in] }"); 29 | 30 | MT('number_percentage', 31 | "[tag foo] { [property width][operator :][number 80%] }"); 32 | 33 | MT('selector', 34 | "[builtin #hello][qualifier .world]{}"); 35 | 36 | MT('singleline_comment', 37 | "[comment // this is a comment]"); 38 | 39 | MT('multiline_comment', 40 | "[comment /*foobar*/]"); 41 | 42 | MT('attribute_with_hyphen', 43 | "[tag foo] { [property font-size][operator :][number 10px] }"); 44 | 45 | MT('string_after_attribute', 46 | "[tag foo] { [property content][operator :][string \"::\"] }"); 47 | 48 | MT('directives', 49 | "[def @include] [qualifier .mixin]"); 50 | 51 | MT('basic_structure', 52 | "[tag p] { [property background][operator :][keyword red]; }"); 53 | 54 | MT('nested_structure', 55 | "[tag p] { [tag a] { [property color][operator :][keyword red]; } }"); 56 | 57 | MT('mixin', 58 | "[def @mixin] [tag table-base] {}"); 59 | 60 | MT('number_without_semicolon', 61 | "[tag p] {[property width][operator :][number 12]}", 62 | "[tag a] {[property color][operator :][keyword red];}"); 63 | 64 | MT('atom_in_nested_block', 65 | "[tag p] { [tag a] { [property color][operator :][atom #000]; } }"); 66 | 67 | MT('interpolation_in_property', 68 | "[tag foo] { [operator #{][variable-2 $hello][operator }:][number 2]; }"); 69 | 70 | MT('interpolation_in_selector', 71 | "[tag foo][operator #{][variable-2 $hello][operator }] { [property color][operator :][atom #000]; }"); 72 | 73 | MT('interpolation_error', 74 | "[tag foo][operator #{][error foo][operator }] { [property color][operator :][atom #000]; }"); 75 | 76 | MT("divide_operator", 77 | "[tag foo] { [property width][operator :][number 4] [operator /] [number 2] }"); 78 | 79 | MT('nested_structure_with_id_selector', 80 | "[tag p] { [builtin #hello] { [property color][operator :][keyword red]; } }"); 81 | 82 | IT('mixin', 83 | "@mixin container[1 (][2 $a: 10][1 , ][2 $b: 10][1 , ][2 $c: 10]) [1 {]}"); 84 | 85 | IT('nested', 86 | "foo [1 { bar ][2 { ][1 } ]}"); 87 | 88 | IT('comma', 89 | "foo [1 { font-family][2 : verdana, sans-serif][1 ; ]}"); 90 | 91 | IT('parentheses', 92 | "foo [1 { color][2 : darken][3 ($blue, 9%][2 )][1 ; ]}"); 93 | })(); 94 | -------------------------------------------------------------------------------- /code-mirror/mode/jade/jade.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("jade", function () { 2 | var symbol_regex1 = /^(?:~|!|%|\^|\*|\+|=|\\|:|;|,|\/|\?|&|<|>|\|)/; 3 | var open_paren_regex = /^(\(|\[)/; 4 | var close_paren_regex = /^(\)|\])/; 5 | var keyword_regex1 = /^(if|else|return|var|function|include|doctype|each)/; 6 | var keyword_regex2 = /^(#|{|}|\.)/; 7 | var keyword_regex3 = /^(in)/; 8 | var html_regex1 = /^(html|head|title|meta|link|script|body|br|div|input|span|a|img)/; 9 | var html_regex2 = /^(h1|h2|h3|h4|h5|p|strong|em)/; 10 | return { 11 | startState: function () { 12 | return { 13 | inString: false, 14 | stringType: "", 15 | beforeTag: true, 16 | justMatchedKeyword: false, 17 | afterParen: false 18 | }; 19 | }, 20 | token: function (stream, state) { 21 | //check for state changes 22 | if (!state.inString && ((stream.peek() == '"') || (stream.peek() == "'"))) { 23 | state.stringType = stream.peek(); 24 | stream.next(); // Skip quote 25 | state.inString = true; // Update state 26 | } 27 | 28 | //return state 29 | if (state.inString) { 30 | if (stream.skipTo(state.stringType)) { // Quote found on this line 31 | stream.next(); // Skip quote 32 | state.inString = false; // Clear flag 33 | } else { 34 | stream.skipToEnd(); // Rest of line is string 35 | } 36 | state.justMatchedKeyword = false; 37 | return "string"; // Token style 38 | } else if (stream.sol() && stream.eatSpace()) { 39 | if (stream.match(keyword_regex1)) { 40 | state.justMatchedKeyword = true; 41 | stream.eatSpace(); 42 | return "keyword"; 43 | } 44 | if (stream.match(html_regex1) || stream.match(html_regex2)) { 45 | state.justMatchedKeyword = true; 46 | return "variable"; 47 | } 48 | } else if (stream.sol() && stream.match(keyword_regex1)) { 49 | state.justMatchedKeyword = true; 50 | stream.eatSpace(); 51 | return "keyword"; 52 | } else if (stream.sol() && (stream.match(html_regex1) || stream.match(html_regex2))) { 53 | state.justMatchedKeyword = true; 54 | return "variable"; 55 | } else if (stream.eatSpace()) { 56 | state.justMatchedKeyword = false; 57 | if (stream.match(keyword_regex3) && stream.eatSpace()) { 58 | state.justMatchedKeyword = true; 59 | return "keyword"; 60 | } 61 | } else if (stream.match(symbol_regex1)) { 62 | state.justMatchedKeyword = false; 63 | return "atom"; 64 | } else if (stream.match(open_paren_regex)) { 65 | state.afterParen = true; 66 | state.justMatchedKeyword = true; 67 | return "def"; 68 | } else if (stream.match(close_paren_regex)) { 69 | state.afterParen = false; 70 | state.justMatchedKeyword = true; 71 | return "def"; 72 | } else if (stream.match(keyword_regex2)) { 73 | state.justMatchedKeyword = true; 74 | return "keyword"; 75 | } else if (stream.eatSpace()) { 76 | state.justMatchedKeyword = false; 77 | } else { 78 | stream.next(); 79 | if (state.justMatchedKeyword) { 80 | return "property"; 81 | } else if (state.afterParen) { 82 | return "property"; 83 | } 84 | } 85 | return null; 86 | } 87 | }; 88 | }); 89 | 90 | CodeMirror.defineMIME('text/x-jade', 'jade'); 91 | -------------------------------------------------------------------------------- /js/functions.js: -------------------------------------------------------------------------------- 1 | CodeMirror.commands.autocomplete = function(cm) { 2 | CodeMirror.showHint(cm, CodeMirror.hint.js); 3 | }; 4 | 5 | $("textarea").each(function () { 6 | 7 | this.CodeMirror = CodeMirror.fromTextArea(this, { 8 | lineNumbers: true, 9 | matchBrackets: true, 10 | continueComments: "Enter", 11 | autoCloseBrackets: true, 12 | extraKeys: { 13 | "Ctrl-Q": "toggleComment", 14 | "Ctrl-Space": "autocomplete" 15 | } 16 | }); 17 | }) 18 | 19 | 20 | var $definedOperators = $(".defined-operators") 21 | , $jsCodeToRun = $(".js-code") 22 | , $runButton = $(".run") 23 | , $output = $(".output"); 24 | 25 | /* 26 | * This overrides the console.log function 27 | * 28 | * */ 29 | console.log = function () { 30 | var outputLine = "\n"; 31 | for (var arg in arguments) { 32 | var cArg = arguments[arg]; 33 | if (!cArg || typeof cArg === "number") { 34 | outputLine += cArg; 35 | } else { 36 | outputLine += JSON.stringify(cArg); 37 | } 38 | outputLine += " "; 39 | } 40 | var c = $output[0].CodeMirror; 41 | c.setValue(c.getValue() + outputLine); 42 | }; 43 | 44 | function runCode () { 45 | 46 | // eval operators 47 | try { 48 | eval ($definedOperators[0].CodeMirror.getValue()); 49 | } catch (e) { 50 | return $output.val(e.toString()); 51 | } 52 | 53 | // support new operators 54 | var tokens = esprima.FnExprTokens 55 | , customOperators = Object.keys(operators); 56 | 57 | for (var i = 0; i < customOperators.length; ++i) { 58 | var cOp = customOperators[i]; 59 | if (tokens.indexOf(cOp) === -1) { 60 | tokens.push(cOp); 61 | } 62 | if (esprima.JohnnysProps.operators.indexOf(cOp) === -1) { 63 | esprima.JohnnysProps.operators.push(cOp); 64 | } 65 | 66 | if (esprima.JohnnysProps.custom.indexOf(cOp) === -1) { 67 | esprima.JohnnysProps.custom.push(cOp); 68 | } 69 | } 70 | 71 | 72 | var result; 73 | // eval js code 74 | try { 75 | result = eval (evalThis($jsCodeToRun[0].CodeMirror.getValue())); 76 | } catch (e) { 77 | result = e.toString() 78 | } 79 | 80 | if (result !== undefined) { 81 | console.log(result); 82 | } 83 | } 84 | 85 | $runButton.on("click", runCode); 86 | 87 | function visitor(tree,visit){ 88 | for(i in tree){ 89 | visit(tree[i]); 90 | if(typeof tree[i] === "object" && tree[i] !== null){ 91 | visitor(tree[i],visit); 92 | } 93 | } 94 | } 95 | 96 | function evalThis (input) { 97 | var syntax = esprima.parse(input); 98 | visitor(syntax,function(el){ 99 | if(el.type === "BinaryExpression"){ 100 | 101 | if (Object.keys(operators).indexOf(el.operator) !== -1){ 102 | el.type = "CallExpression"; 103 | el.callee = { 104 | name: operators[el.operator].name, 105 | type:"Identifier" 106 | }; 107 | el.arguments = [el.left, el.right]; 108 | delete el.operator; 109 | delete el.left; 110 | delete el.right; 111 | } 112 | } 113 | }); 114 | 115 | scriptToEvaluate = escodegen.generate(syntax) 116 | return eval(scriptToEvaluate); 117 | } 118 | -------------------------------------------------------------------------------- /code-mirror/mode/css/scss.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | CodeMirror: SCSS mode 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 24 | 25 |
26 |

SCSS mode

27 |
145 | 152 | 153 |

MIME types defined: text/scss.

154 | 155 |

Parsing/Highlighting Tests: normal, verbose.

156 | 157 |
158 | -------------------------------------------------------------------------------- /code-mirror/mode/pegjs/pegjs.js: -------------------------------------------------------------------------------- 1 | CodeMirror.defineMode("pegjs", function (config) { 2 | var jsMode = CodeMirror.getMode(config, "javascript"); 3 | 4 | function identifier(stream) { 5 | return stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/); 6 | } 7 | 8 | return { 9 | startState: function () { 10 | return { 11 | inString: false, 12 | stringType: null, 13 | inComment: false, 14 | inChracterClass: false, 15 | braced: 0, 16 | lhs: true, 17 | localState: null 18 | }; 19 | }, 20 | token: function (stream, state) { 21 | if (stream) 22 | 23 | //check for state changes 24 | if (!state.inString && !state.inComment && ((stream.peek() == '"') || (stream.peek() == "'"))) { 25 | state.stringType = stream.peek(); 26 | stream.next(); // Skip quote 27 | state.inString = true; // Update state 28 | } 29 | if (!state.inString && !state.inComment && stream.match(/^\/\*/)) { 30 | state.inComment = true; 31 | } 32 | 33 | //return state 34 | if (state.inString) { 35 | while (state.inString && !stream.eol()) { 36 | if (stream.peek() === state.stringType) { 37 | stream.next(); // Skip quote 38 | state.inString = false; // Clear flag 39 | } else if (stream.peek() === '\\') { 40 | stream.next(); 41 | stream.next(); 42 | } else { 43 | stream.match(/^.[^\\\"\']*/); 44 | } 45 | } 46 | return state.lhs ? "property string" : "string"; // Token style 47 | } else if (state.inComment) { 48 | while (state.inComment && !stream.eol()) { 49 | if (stream.match(/\*\//)) { 50 | state.inComment = false; // Clear flag 51 | } else { 52 | stream.match(/^.[^\*]*/); 53 | } 54 | } 55 | return "comment"; 56 | } else if (state.inChracterClass) { 57 | if (stream.match(/^[^\]\\]+/)) { 58 | return; 59 | } else if (stream.match(/^\\./)) { 60 | return; 61 | } else { 62 | stream.next(); 63 | state.inChracterClass = false; 64 | return 'bracket'; 65 | } 66 | } else if (stream.peek() === '[') { 67 | stream.next(); 68 | state.inChracterClass = true; 69 | return 'bracket'; 70 | } else if (stream.match(/^\/\//)) { 71 | stream.skipToEnd(); 72 | return "comment"; 73 | } else if (state.braced || stream.peek() === '{') { 74 | if (state.localState === null) { 75 | state.localState = jsMode.startState(); 76 | } 77 | var token = jsMode.token(stream, state.localState); 78 | var text = stream.current(); 79 | if (!token) { 80 | for (var i = 0; i < text.length; i++) { 81 | if (text[i] === '{') { 82 | state.braced++; 83 | } else if (text[i] === '}') { 84 | state.braced--; 85 | } 86 | }; 87 | } 88 | return token; 89 | } else if (identifier(stream)) { 90 | if (stream.peek() === ':') { 91 | return 'variable'; 92 | } 93 | return 'variable-2'; 94 | } else if (['[', ']', '(', ')'].indexOf(stream.peek()) != -1) { 95 | stream.next(); 96 | return 'bracket'; 97 | } else if (!stream.eatSpace()) { 98 | stream.next(); 99 | } 100 | return null; 101 | } 102 | }; 103 | }, "javascript"); 104 | -------------------------------------------------------------------------------- /code-mirror/mode/stex/test.js: -------------------------------------------------------------------------------- 1 | (function() { 2 | var mode = CodeMirror.getMode({tabSize: 4}, "stex"); 3 | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); } 4 | 5 | MT("word", 6 | "foo"); 7 | 8 | MT("twoWords", 9 | "foo bar"); 10 | 11 | MT("beginEndDocument", 12 | "[tag \\begin][bracket {][atom document][bracket }]", 13 | "[tag \\end][bracket {][atom document][bracket }]"); 14 | 15 | MT("beginEndEquation", 16 | "[tag \\begin][bracket {][atom equation][bracket }]", 17 | " E=mc^2", 18 | "[tag \\end][bracket {][atom equation][bracket }]"); 19 | 20 | MT("beginModule", 21 | "[tag \\begin][bracket {][atom module][bracket }[[]]]"); 22 | 23 | MT("beginModuleId", 24 | "[tag \\begin][bracket {][atom module][bracket }[[]id=bbt-size[bracket ]]]"); 25 | 26 | MT("importModule", 27 | "[tag \\importmodule][bracket [[][string b-b-t][bracket ]]{][builtin b-b-t][bracket }]"); 28 | 29 | MT("importModulePath", 30 | "[tag \\importmodule][bracket [[][tag \\KWARCslides][bracket {][string dmath/en/cardinality][bracket }]]{][builtin card][bracket }]"); 31 | 32 | MT("psForPDF", 33 | "[tag \\PSforPDF][bracket [[][atom 1][bracket ]]{]#1[bracket }]"); 34 | 35 | MT("comment", 36 | "[comment % foo]"); 37 | 38 | MT("tagComment", 39 | "[tag \\item][comment % bar]"); 40 | 41 | MT("commentTag", 42 | " [comment % \\item]"); 43 | 44 | MT("commentLineBreak", 45 | "[comment %]", 46 | "foo"); 47 | 48 | MT("tagErrorCurly", 49 | "[tag \\begin][error }][bracket {]"); 50 | 51 | MT("tagErrorSquare", 52 | "[tag \\item][error ]]][bracket {]"); 53 | 54 | MT("commentCurly", 55 | "[comment % }]"); 56 | 57 | MT("tagHash", 58 | "the [tag \\#] key"); 59 | 60 | MT("tagNumber", 61 | "a [tag \\$][atom 5] stetson"); 62 | 63 | MT("tagPercent", 64 | "[atom 100][tag \\%] beef"); 65 | 66 | MT("tagAmpersand", 67 | "L [tag \\&] N"); 68 | 69 | MT("tagUnderscore", 70 | "foo[tag \\_]bar"); 71 | 72 | MT("tagBracketOpen", 73 | "[tag \\emph][bracket {][tag \\{][bracket }]"); 74 | 75 | MT("tagBracketClose", 76 | "[tag \\emph][bracket {][tag \\}][bracket }]"); 77 | 78 | MT("tagLetterNumber", 79 | "section [tag \\S][atom 1]"); 80 | 81 | MT("textTagNumber", 82 | "para [tag \\P][atom 2]"); 83 | 84 | MT("thinspace", 85 | "x[tag \\,]y"); 86 | 87 | MT("thickspace", 88 | "x[tag \\;]y"); 89 | 90 | MT("negativeThinspace", 91 | "x[tag \\!]y"); 92 | 93 | MT("periodNotSentence", 94 | "J.\\ L.\\ is"); 95 | 96 | MT("periodSentence", 97 | "X[tag \\@]. The"); 98 | 99 | MT("italicCorrection", 100 | "[bracket {][tag \\em] If[tag \\/][bracket }] I"); 101 | 102 | MT("tagBracket", 103 | "[tag \\newcommand][bracket {][tag \\pop][bracket }]"); 104 | 105 | MT("inlineMathTagFollowedByNumber", 106 | "[keyword $][tag \\pi][number 2][keyword $]"); 107 | 108 | MT("inlineMath", 109 | "[keyword $][number 3][variable-2 x][tag ^][number 2.45]-[tag \\sqrt][bracket {][tag \\$\\alpha][bracket }] = [number 2][keyword $] other text"); 110 | 111 | MT("displayMath", 112 | "More [keyword $$]\t[variable-2 S][tag ^][variable-2 n][tag \\sum] [variable-2 i][keyword $$] other text"); 113 | 114 | MT("mathWithComment", 115 | "[keyword $][variable-2 x] [comment % $]", 116 | "[variable-2 y][keyword $] other text"); 117 | 118 | MT("lineBreakArgument", 119 | "[tag \\\\][bracket [[][atom 1cm][bracket ]]]"); 120 | })(); 121 | --------------------------------------------------------------------------------