markdown-xblock 2.4.0__py3-none-any.whl

markdown_xblock/public/plugins/codemirror/codemirror-4.8/mode/xml/xml.js

@@ -0,0 +1,384 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("xml", function(config, parserConfig) {
+  var indentUnit = config.indentUnit;
+  var multilineTagIndentFactor = parserConfig.multilineTagIndentFactor || 1;
+  var multilineTagIndentPastTag = parserConfig.multilineTagIndentPastTag;
+  if (multilineTagIndentPastTag == null) multilineTagIndentPastTag = true;
+
+  var Kludges = parserConfig.htmlMode ? {
+    autoSelfClosers: {'area': true, 'base': true, 'br': true, 'col': true, 'command': true,
+                      'embed': true, 'frame': true, 'hr': true, 'img': true, 'input': true,
+                      'keygen': true, 'link': true, 'meta': true, 'param': true, 'source': true,
+                      'track': true, 'wbr': true, 'menuitem': true},
+    implicitlyClosed: {'dd': true, 'li': true, 'optgroup': true, 'option': true, 'p': true,
+                       'rp': true, 'rt': true, 'tbody': true, 'td': true, 'tfoot': true,
+                       'th': true, 'tr': true},
+    contextGrabbers: {
+      'dd': {'dd': true, 'dt': true},
+      'dt': {'dd': true, 'dt': true},
+      'li': {'li': true},
+      'option': {'option': true, 'optgroup': true},
+      'optgroup': {'optgroup': true},
+      'p': {'address': true, 'article': true, 'aside': true, 'blockquote': true, 'dir': true,
+            'div': true, 'dl': true, 'fieldset': true, 'footer': true, 'form': true,
+            'h1': true, 'h2': true, 'h3': true, 'h4': true, 'h5': true, 'h6': true,
+            'header': true, 'hgroup': true, 'hr': true, 'menu': true, 'nav': true, 'ol': true,
+            'p': true, 'pre': true, 'section': true, 'table': true, 'ul': true},
+      'rp': {'rp': true, 'rt': true},
+      'rt': {'rp': true, 'rt': true},
+      'tbody': {'tbody': true, 'tfoot': true},
+      'td': {'td': true, 'th': true},
+      'tfoot': {'tbody': true},
+      'th': {'td': true, 'th': true},
+      'thead': {'tbody': true, 'tfoot': true},
+      'tr': {'tr': true}
+    },
+    doNotIndent: {"pre": true},
+    allowUnquoted: true,
+    allowMissing: true,
+    caseFold: true
+  } : {
+    autoSelfClosers: {},
+    implicitlyClosed: {},
+    contextGrabbers: {},
+    doNotIndent: {},
+    allowUnquoted: false,
+    allowMissing: false,
+    caseFold: false
+  };
+  var alignCDATA = parserConfig.alignCDATA;
+
+  // Return variables for tokenizers
+  var type, setStyle;
+
+  function inText(stream, state) {
+    function chain(parser) {
+      state.tokenize = parser;
+      return parser(stream, state);
+    }
+
+    var ch = stream.next();
+    if (ch == "<") {
+      if (stream.eat("!")) {
+        if (stream.eat("[")) {
+          if (stream.match("CDATA[")) return chain(inBlock("atom", "]]>"));
+          else return null;
+        } else if (stream.match("--")) {
+          return chain(inBlock("comment", "-->"));
+        } else if (stream.match("DOCTYPE", true, true)) {
+          stream.eatWhile(/[\w\._\-]/);
+          return chain(doctype(1));
+        } else {
+          return null;
+        }
+      } else if (stream.eat("?")) {
+        stream.eatWhile(/[\w\._\-]/);
+        state.tokenize = inBlock("meta", "?>");
+        return "meta";
+      } else {
+        type = stream.eat("/") ? "closeTag" : "openTag";
+        state.tokenize = inTag;
+        return "tag bracket";
+      }
+    } else if (ch == "&") {
+      var ok;
+      if (stream.eat("#")) {
+        if (stream.eat("x")) {
+          ok = stream.eatWhile(/[a-fA-F\d]/) && stream.eat(";");
+        } else {
+          ok = stream.eatWhile(/[\d]/) && stream.eat(";");
+        }
+      } else {
+        ok = stream.eatWhile(/[\w\.\-:]/) && stream.eat(";");
+      }
+      return ok ? "atom" : "error";
+    } else {
+      stream.eatWhile(/[^&<]/);
+      return null;
+    }
+  }
+
+  function inTag(stream, state) {
+    var ch = stream.next();
+    if (ch == ">" || (ch == "/" && stream.eat(">"))) {
+      state.tokenize = inText;
+      type = ch == ">" ? "endTag" : "selfcloseTag";
+      return "tag bracket";
+    } else if (ch == "=") {
+      type = "equals";
+      return null;
+    } else if (ch == "<") {
+      state.tokenize = inText;
+      state.state = baseState;
+      state.tagName = state.tagStart = null;
+      var next = state.tokenize(stream, state);
+      return next ? next + " tag error" : "tag error";
+    } else if (/[\'\"]/.test(ch)) {
+      state.tokenize = inAttribute(ch);
+      state.stringStartCol = stream.column();
+      return state.tokenize(stream, state);
+    } else {
+      stream.match(/^[^\s\u00a0=<>\"\']*[^\s\u00a0=<>\"\'\/]/);
+      return "word";
+    }
+  }
+
+  function inAttribute(quote) {
+    var closure = function(stream, state) {
+      while (!stream.eol()) {
+        if (stream.next() == quote) {
+          state.tokenize = inTag;
+          break;
+        }
+      }
+      return "string";
+    };
+    closure.isInAttribute = true;
+    return closure;
+  }
+
+  function inBlock(style, terminator) {
+    return function(stream, state) {
+      while (!stream.eol()) {
+        if (stream.match(terminator)) {
+          state.tokenize = inText;
+          break;
+        }
+        stream.next();
+      }
+      return style;
+    };
+  }
+  function doctype(depth) {
+    return function(stream, state) {
+      var ch;
+      while ((ch = stream.next()) != null) {
+        if (ch == "<") {
+          state.tokenize = doctype(depth + 1);
+          return state.tokenize(stream, state);
+        } else if (ch == ">") {
+          if (depth == 1) {
+            state.tokenize = inText;
+            break;
+          } else {
+            state.tokenize = doctype(depth - 1);
+            return state.tokenize(stream, state);
+          }
+        }
+      }
+      return "meta";
+    };
+  }
+
+  function Context(state, tagName, startOfLine) {
+    this.prev = state.context;
+    this.tagName = tagName;
+    this.indent = state.indented;
+    this.startOfLine = startOfLine;
+    if (Kludges.doNotIndent.hasOwnProperty(tagName) || (state.context && state.context.noIndent))
+      this.noIndent = true;
+  }
+  function popContext(state) {
+    if (state.context) state.context = state.context.prev;
+  }
+  function maybePopContext(state, nextTagName) {
+    var parentTagName;
+    while (true) {
+      if (!state.context) {
+        return;
+      }
+      parentTagName = state.context.tagName;
+      if (!Kludges.contextGrabbers.hasOwnProperty(parentTagName) ||
+          !Kludges.contextGrabbers[parentTagName].hasOwnProperty(nextTagName)) {
+        return;
+      }
+      popContext(state);
+    }
+  }
+
+  function baseState(type, stream, state) {
+    if (type == "openTag") {
+      state.tagStart = stream.column();
+      return tagNameState;
+    } else if (type == "closeTag") {
+      return closeTagNameState;
+    } else {
+      return baseState;
+    }
+  }
+  function tagNameState(type, stream, state) {
+    if (type == "word") {
+      state.tagName = stream.current();
+      setStyle = "tag";
+      return attrState;
+    } else {
+      setStyle = "error";
+      return tagNameState;
+    }
+  }
+  function closeTagNameState(type, stream, state) {
+    if (type == "word") {
+      var tagName = stream.current();
+      if (state.context && state.context.tagName != tagName &&
+          Kludges.implicitlyClosed.hasOwnProperty(state.context.tagName))
+        popContext(state);
+      if (state.context && state.context.tagName == tagName) {
+        setStyle = "tag";
+        return closeState;
+      } else {
+        setStyle = "tag error";
+        return closeStateErr;
+      }
+    } else {
+      setStyle = "error";
+      return closeStateErr;
+    }
+  }
+
+  function closeState(type, _stream, state) {
+    if (type != "endTag") {
+      setStyle = "error";
+      return closeState;
+    }
+    popContext(state);
+    return baseState;
+  }
+  function closeStateErr(type, stream, state) {
+    setStyle = "error";
+    return closeState(type, stream, state);
+  }
+
+  function attrState(type, _stream, state) {
+    if (type == "word") {
+      setStyle = "attribute";
+      return attrEqState;
+    } else if (type == "endTag" || type == "selfcloseTag") {
+      var tagName = state.tagName, tagStart = state.tagStart;
+      state.tagName = state.tagStart = null;
+      if (type == "selfcloseTag" ||
+          Kludges.autoSelfClosers.hasOwnProperty(tagName)) {
+        maybePopContext(state, tagName);
+      } else {
+        maybePopContext(state, tagName);
+        state.context = new Context(state, tagName, tagStart == state.indented);
+      }
+      return baseState;
+    }
+    setStyle = "error";
+    return attrState;
+  }
+  function attrEqState(type, stream, state) {
+    if (type == "equals") return attrValueState;
+    if (!Kludges.allowMissing) setStyle = "error";
+    return attrState(type, stream, state);
+  }
+  function attrValueState(type, stream, state) {
+    if (type == "string") return attrContinuedState;
+    if (type == "word" && Kludges.allowUnquoted) {setStyle = "string"; return attrState;}
+    setStyle = "error";
+    return attrState(type, stream, state);
+  }
+  function attrContinuedState(type, stream, state) {
+    if (type == "string") return attrContinuedState;
+    return attrState(type, stream, state);
+  }
+
+  return {
+    startState: function() {
+      return {tokenize: inText,
+              state: baseState,
+              indented: 0,
+              tagName: null, tagStart: null,
+              context: null};
+    },
+
+    token: function(stream, state) {
+      if (!state.tagName && stream.sol())
+        state.indented = stream.indentation();
+
+      if (stream.eatSpace()) return null;
+      type = null;
+      var style = state.tokenize(stream, state);
+      if ((style || type) && style != "comment") {
+        setStyle = null;
+        state.state = state.state(type || style, stream, state);
+        if (setStyle)
+          style = setStyle == "error" ? style + " error" : setStyle;
+      }
+      return style;
+    },
+
+    indent: function(state, textAfter, fullLine) {
+      var context = state.context;
+      // Indent multi-line strings (e.g. css).
+      if (state.tokenize.isInAttribute) {
+        if (state.tagStart == state.indented)
+          return state.stringStartCol + 1;
+        else
+          return state.indented + indentUnit;
+      }
+      if (context && context.noIndent) return CodeMirror.Pass;
+      if (state.tokenize != inTag && state.tokenize != inText)
+        return fullLine ? fullLine.match(/^(\s*)/)[0].length : 0;
+      // Indent the starts of attribute names.
+      if (state.tagName) {
+        if (multilineTagIndentPastTag)
+          return state.tagStart + state.tagName.length + 2;
+        else
+          return state.tagStart + indentUnit * multilineTagIndentFactor;
+      }
+      if (alignCDATA && /<!\[CDATA\[/.test(textAfter)) return 0;
+      var tagAfter = textAfter && /^<(\/)?([\w_:\.-]*)/.exec(textAfter);
+      if (tagAfter && tagAfter[1]) { // Closing tag spotted
+        while (context) {
+          if (context.tagName == tagAfter[2]) {
+            context = context.prev;
+            break;
+          } else if (Kludges.implicitlyClosed.hasOwnProperty(context.tagName)) {
+            context = context.prev;
+          } else {
+            break;
+          }
+        }
+      } else if (tagAfter) { // Opening tag spotted
+        while (context) {
+          var grabbers = Kludges.contextGrabbers[context.tagName];
+          if (grabbers && grabbers.hasOwnProperty(tagAfter[2]))
+            context = context.prev;
+          else
+            break;
+        }
+      }
+      while (context && !context.startOfLine)
+        context = context.prev;
+      if (context) return context.indent + indentUnit;
+      else return 0;
+    },
+
+    electricInput: /<\/[\s\w:]+>$/,
+    blockCommentStart: "<!--",
+    blockCommentEnd: "-->",
+
+    configuration: parserConfig.htmlMode ? "html" : "xml",
+    helperType: parserConfig.htmlMode ? "html" : "xml"
+  };
+});
+
+CodeMirror.defineMIME("text/xml", "xml");
+CodeMirror.defineMIME("application/xml", "xml");
+if (!CodeMirror.mimeModes.hasOwnProperty("text/html"))
+  CodeMirror.defineMIME("text/html", {name: "xml", htmlMode: true});
+
+});

markdown_xblock/public/plugins/codemirror/langs/en.js

@@ -0,0 +1,8 @@
+tinymce.addI18n('en',{
+	'HTML source code': 'HTML source code',
+	'Start search': 'Start search',
+	'Find next': 'Find next',
+	'Find previous': 'Find previous',
+	'Replace': 'Replace',
+	'Replace all': 'Replace all'
+});

markdown_xblock/public/plugins/codemirror/plugin.min.js

@@ -0,0 +1 @@
+tinymce.PluginManager.requireLangPack("codemirror");tinymce.PluginManager.add("codemirror",function(e,r){function o(){e.focus();e.selection.collapse(true);if(e.settings.codemirror.saveCursorPosition){e.selection.setContent('<span style="display: none;" class="CmCaReT">&#x0;</span>')}codemirrorWidth=800;if(e.settings.codemirror.width){codemirrorWidth=e.settings.codemirror.width}codemirrorHeight=550;if(e.settings.codemirror.width){codemirrorHeight=e.settings.codemirror.height}var o={title:"HTML source code",url:r+"/source.html",width:codemirrorWidth,height:codemirrorHeight,resizable:true,maximizable:true,fullScreen:e.settings.codemirror.fullscreen,buttons:[{text:"Ok",subtype:"primary",onclick:function(){var e=document.querySelectorAll(".mce-container-body>iframe")[0];e.contentWindow.submit();i.close()}},{text:"Cancel",onclick:"close"}]};var i=e.windowManager.open(o);if(e.settings.codemirror.fullscreen){i.fullscreen(true)}}e.addButton("code",{title:"Source code",icon:"code",onclick:o});e.addMenuItem("code",{icon:"code",text:"Source code",context:"tools",onclick:o})});

markdown_xblock/public/plugins/codemirror/source.html

@@ -0,0 +1,270 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script>
+
+/**
+ * source.html
+ *
+ * Copyright 2013-2014 Web Power, www.webpower.nl
+ * @author Arjan Haverkamp
+ */
+
+// Global vars:
+var tinymce,     // Reference to TinyMCE
+	editor,      // Reference to TinyMCE editor
+	codemirror,  // CodeMirror instance
+	chr = 0,     // Unused utf-8 character, placeholder for cursor
+	isMac = /macintosh|mac os/i.test(navigator.userAgent),
+	CMsettings;  // CodeMirror settings
+
+function inArray(key, arr)
+{
+	"use strict";
+	arr = '|' + arr.join('|') + '|';
+	return arr.indexOf('|'+key+'|') != -1;
+}
+
+(function()
+{// Initialise (before load)
+	"use strict";
+
+	tinymce = parent.tinymce;
+	editor = tinymce.activeEditor;
+	var i, userSettings = editor.settings.codemirror ? editor.settings.codemirror : {};
+	CMsettings = {
+		path: userSettings.path || 'codemirror-4.8',
+		indentOnInit: userSettings.indentOnInit || false,
+		config: {// Default config
+			mode: 'htmlmixed',
+			theme: 'default',
+			lineNumbers: true,
+			lineWrapping: true,
+			indentUnit: 2,
+			tabSize: 2,
+			indentWithTabs: true,
+			matchBrackets: true,
+            saveCursorPosition: true,
+			styleActiveLine: true
+		},
+		jsFiles: [// Default JS files
+			'lib/codemirror.js',
+			'addon/edit/matchbrackets.js',
+			'mode/xml/xml.js',
+			'mode/javascript/javascript.js',
+			'mode/css/css.js',
+			'mode/htmlmixed/htmlmixed.js',
+			'addon/dialog/dialog.js',
+			'addon/search/searchcursor.js',
+			'addon/search/search.js',
+			'addon/selection/active-line.js'
+		],
+		cssFiles: [// Default CSS files
+			'lib/codemirror.css',
+			'addon/dialog/dialog.css'
+		]
+	};
+
+	if (userSettings.fullscreen) {
+		CMsettings.jsFiles.push('addon/display/fullscreen.js');
+		CMsettings.cssFiles.push('addon/display/fullscreen.css');
+	}
+
+	// Merge config
+	for (i in userSettings.config) {
+		CMsettings.config[i] = userSettings.config[i];
+	}
+
+	// Merge jsFiles
+	for (i in userSettings.jsFiles) {
+		if (!inArray(userSettings.jsFiles[i], CMsettings.jsFiles)) {
+			CMsettings.jsFiles.push(userSettings.jsFiles[i]);
+		}
+	}
+
+	// Merge cssFiles
+	for (i in userSettings.cssFiles) {
+		if (!inArray(userSettings.cssFiles[i], CMsettings.cssFiles)) {
+			CMsettings.cssFiles.push(userSettings.cssFiles[i]);
+		}
+	}
+
+	// Add trailing slash to path
+	if (!/\/$/.test(CMsettings.path)) {
+		CMsettings.path += '/';
+	}
+
+	// Write stylesheets
+	for (i = 0; i < CMsettings.cssFiles.length; i++) {
+		document.write('<li'+'nk rel="stylesheet" type="text/css" href="' + CMsettings.path + CMsettings.cssFiles[i] + '" />');
+	}
+
+	// Write JS source files
+	for (i = 0; i < CMsettings.jsFiles.length; i++) {
+		document.write('<scr'+'ipt type="text/javascript" src="' + CMsettings.path + CMsettings.jsFiles[i] + '"></scr'+'ipt>');
+	}
+
+	// Borrowed from codemirror.js themeChanged function. Sets the theme's class names to the html element.
+	// Without this, the background color outside of the codemirror wrapper element remains white.
+    // [TMP] commented temporary, cause JS error: Uncaught TypeError: Cannot read property 'replace' of undefined
+    if(CMsettings.config.theme) {
+    	document.documentElement.className += CMsettings.config.theme.replace(/(^|\s)\s*/g, " cm-s-");
+    }
+
+	window.onload = start;
+}());
+
+function start()
+{// Initialise (on load)
+	"use strict";
+
+	if (typeof(window.CodeMirror) !== 'function') {
+		alert('CodeMirror not found in "' + CMsettings.path + '", aborting...');
+		return;
+	}
+
+	// Create legend for keyboard shortcuts for find & replace:
+	var head = parent.document.querySelectorAll('.mce-foot')[0],
+		div = parent.document.createElement('div'),
+		td1 = '<td style="font-size:11px;background:#777;color:#fff;padding:0 4px">',
+		td2 = '<td style="font-size:11px;padding-right:5px">';
+	div.innerHTML = '<table cellspacing="0" cellpadding="0" style="border-spacing:4px"><tr>' + td1 + (isMac ? '&#8984;-F' : 'Ctrl-F</td>') + td2 + tinymce.translate('Start search') + '</td>' + td1 + (isMac ? '&#8984;-G' : 'Ctrl-G') + '</td>' + td2 + tinymce.translate('Find next') + '</td>' + td1 + (isMac ? '&#8984;-Alt-F' : 'Shift-Ctrl-F') + '</td>' + td2 + tinymce.translate('Find previous') + '</td></tr>' + '<tr>' + td1 + (isMac ? '&#8984;-Alt-F' : 'Shift-Ctrl-F') + '</td>' + td2 + tinymce.translate('Replace') + '</td>' + td1 + (isMac ? 'Shift-&#8984;-Alt-F' : 'Shift-Ctrl-R') +'</td>' + td2 + tinymce.translate('Replace all') + '</td></tr></table>';
+	div.style.position = 'absolute';
+	div.style.left = div.style.bottom = '5px';
+	head.appendChild(div);
+
+	// Set CodeMirror cursor and bookmark to same position as cursor was in TinyMCE:
+	var html = editor.getContent({source_view: true});
+
+    // [FIX] #6 z-index issue with table panel and source code dialog
+    //	editor.selection.getBookmark();
+    
+	html = html.replace(/<span\s+style="display: none;"\s+class="CmCaReT"([^>]*)>([^<]*)<\/span>/gm, String.fromCharCode(chr));
+	editor.dom.remove(editor.dom.select('.CmCaReT'));
+    
+    // Hide TinyMCE toolbar panels, [FIX] #6 z-index issue with table panel and source code dialog
+    // https://github.com/christiaan/tinymce-codemirror/issues/6
+    tinymce.each(editor.contextToolbars, function(toolbar) { if (toolbar.panel) { toolbar.panel.hide(); } });
+    
+	CodeMirror.defineInitHook(function(inst)
+	{
+		// Move cursor to correct position:
+		inst.focus();
+		var cursor = inst.getSearchCursor(String.fromCharCode(chr), false);
+		if (cursor.findNext()) {
+			inst.setCursor(cursor.to());
+			cursor.replace('');
+		}
+
+		// Indent all code, if so requested:
+		if (editor.settings.codemirror.indentOnInit) {
+			var last = inst.lineCount();
+			inst.operation(function() {
+				for (var i = 0; i < last; ++i) {
+					inst.indentLine(i);
+				}
+			});
+		}
+	});
+
+	CMsettings.config.value = html;
+
+	// Instantiante CodeMirror:
+	codemirror = CodeMirror(document.body, CMsettings.config);
+	codemirror.isDirty = false;
+	codemirror.on('change', function(inst) {
+		inst.isDirty = true;
+	});
+}
+
+function findDepth(haystack, needle)
+{
+	"use strict";
+
+	var idx = haystack.indexOf(needle), depth = 0, x;
+	for (x = idx -1; x >= 0; x--) {
+		switch(haystack.charAt(x)) {
+			case '<': depth--; break;
+			case '>': depth++; break;
+			case '&': depth++; break;
+		}
+	}
+	return depth;
+}
+
+// This function is called by plugin.js, when user clicks 'Ok' button
+function submit()
+{
+	"use strict";
+
+	var cc = '&#x0;', isDirty = codemirror.isDirty, doc = codemirror.doc;
+
+	if (doc.somethingSelected()) {
+		// Clear selection:
+		doc.setCursor(doc.getCursor());
+	}
+
+	// Insert cursor placeholder (&#x0;)
+	doc.replaceSelection(cc);
+
+	var pos = codemirror.getCursor(),
+		curLineHTML = doc.getLine(pos.line);
+
+	if (findDepth(curLineHTML, cc) !== 0) {
+		// Cursor is inside a <tag>, don't set cursor:
+		curLineHTML = curLineHTML.replace(cc, '');
+		doc.replaceRange(curLineHTML, CodeMirror.Pos(pos.line, 0), CodeMirror.Pos(pos.line));
+	}
+
+	// Submit HTML to TinyMCE:
+    // [FIX] Cursor position inside JS, style or &nbps;
+    // Workaround to fix cursor position if inside script tag
+    var code = codemirror.getValue();
+    if(code.search(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi) !== -1 || code.search(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi) !== -1)
+    {
+    	editor.setContent(codemirror.getValue().replace(cc, ''));
+    }
+    else
+    {
+        editor.setContent(codemirror.getValue().replace(cc, '<span id="CmCaReT"></span>'));
+    }
+    
+	editor.isNotDirty = !isDirty;
+	if (isDirty) {
+		editor.nodeChanged();
+	}
+
+	// Set cursor:
+	var el = editor.dom.select('span#CmCaReT')[0];
+	if (el) {
+		editor.selection.scrollIntoView(el);
+		editor.selection.setCursorLocation(el,0);
+		editor.dom.remove(el);
+	}
+}
+
+</script>
+<style type="text/css">
+body {
+	margin: 0;
+}
+
+.CodeMirror {
+	height: 100%;
+	font-size: 12px;
+	line-height: 18px;
+}
+
+.CodeMirror-activeline-background {
+	background: #e8f2ff !important;
+}
+
+.cm-trailingspace {
+	background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAYAAAB/qH1jAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QUXCToH00Y1UgAAACFJREFUCNdjPMDBUc/AwNDAAAFMTAwMDA0OP34wQgX/AQBYgwYEx4f9lQAAAABJRU5ErkJggg==);
+	background-position: bottom left;
+	background-repeat: repeat-x;
+}
+</style>
+</head>
+<body></body>
+</html>