prism-rails 1.6.0.3 → 1.29.0

data/vendor/assets/javascripts/prism/prism-http.js

@@ -1,50 +0,0 @@
-Prism.languages.http = {
-	'request-line': {
-		pattern: /^(POST|GET|PUT|DELETE|OPTIONS|PATCH|TRACE|CONNECT)\b\shttps?:\/\/\S+\sHTTP\/[0-9.]+/m,
-		inside: {
-			// HTTP Verb
-			property: /^(POST|GET|PUT|DELETE|OPTIONS|PATCH|TRACE|CONNECT)\b/,
-			// Path or query argument
-			'attr-name': /:\w+/
-		}
-	},
-	'response-status': {
-		pattern: /^HTTP\/1.[01] [0-9]+.*/m,
-		inside: {
-			// Status, e.g. 200 OK
-			property: {
-                pattern: /(^HTTP\/1.[01] )[0-9]+.*/i,
-                lookbehind: true
-            }
-		}
-	},
-	// HTTP header name
-	'header-name': {
-        pattern: /^[\w-]+:(?=.)/m,
-        alias: 'keyword'
-    }
-};
-
-// Create a mapping of Content-Type headers to language definitions
-var httpLanguages = {
-	'application/json': Prism.languages.javascript,
-	'application/xml': Prism.languages.markup,
-	'text/xml': Prism.languages.markup,
-	'text/html': Prism.languages.markup
-};
-
-// Insert each content type parser that has its associated language
-// currently loaded.
-for (var contentType in httpLanguages) {
-	if (httpLanguages[contentType]) {
-		var options = {};
-		options[contentType] = {
-			pattern: new RegExp('(content-type:\\s*' + contentType + '[\\w\\W]*?)(?:\\r?\\n|\\r){2}[\\w\\W]*', 'i'),
-			lookbehind: true,
-			inside: {
-				rest: httpLanguages[contentType]
-			}
-		};
-		Prism.languages.insertBefore('http', 'header-name', options);
-	}
-}

data/vendor/assets/javascripts/prism/prism-ini.js

@@ -1,11 +0,0 @@
-Prism.languages.ini= {
-	'comment': /^[ \t]*;.*$/m,
-	'selector': /^[ \t]*\[.*?\]/m,
-	'constant': /^[ \t]*[^\s=]+?(?=[ \t]*=)/m,
-	'attr-value': {
-		pattern: /=.*/,
-		inside: {
-			'punctuation': /^[=]/
-		}
-	}
-};

data/vendor/assets/javascripts/prism/prism-java.js

@@ -1,16 +0,0 @@
-Prism.languages.java = Prism.languages.extend('clike', {
-	'keyword': /\b(abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while)\b/,
-	'number': /\b0b[01]+\b|\b0x[\da-f]*\.?[\da-fp\-]+\b|\b\d*\.?\d+(?:e[+-]?\d+)?[df]?\b/i,
-	'operator': {
-		pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|!=?|<<?=?|>>?>?=?|==?|&[&=]?|\|[|=]?|\*=?|\/=?|%=?|\^=?|[?:~])/m,
-		lookbehind: true
-	}
-});
-
-Prism.languages.insertBefore('java','function', {
-	'annotation': {
-		alias: 'punctuation',
-		pattern: /(^|[^.])@\w+/,
-		lookbehind: true
-	}
-});

data/vendor/assets/javascripts/prism/prism-javascript.js

@@ -1,48 +0,0 @@
-Prism.languages.javascript = Prism.languages.extend('clike', {
-	'keyword': /\b(as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|var|void|while|with|yield)\b/,
-	'number': /\b-?(0x[\dA-Fa-f]+|0b[01]+|0o[0-7]+|\d*\.?\d+([Ee][+-]?\d+)?|NaN|Infinity)\b/,
-	// Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-	'function': /[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*(?=\()/i,
-	'operator': /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*\*?|\/|~|\^|%|\.{3}/
-});
-
-Prism.languages.insertBefore('javascript', 'keyword', {
-	'regex': {
-		pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\\\r\n])+\/[gimyu]{0,5}(?=\s*($|[\r\n,.;})]))/,
-		lookbehind: true,
-		greedy: true
-	}
-});
-
-Prism.languages.insertBefore('javascript', 'string', {
-	'template-string': {
-		pattern: /`(?:\\\\|\\?[^\\])*?`/,
-		greedy: true,
-		inside: {
-			'interpolation': {
-				pattern: /\$\{[^}]+\}/,
-				inside: {
-					'interpolation-punctuation': {
-						pattern: /^\$\{|\}$/,
-						alias: 'punctuation'
-					},
-					rest: Prism.languages.javascript
-				}
-			},
-			'string': /[\s\S]+/
-		}
-	}
-});
-
-if (Prism.languages.markup) {
-	Prism.languages.insertBefore('markup', 'tag', {
-		'script': {
-			pattern: /(<script[\w\W]*?>)[\w\W]*?(?=<\/script>)/i,
-			lookbehind: true,
-			inside: Prism.languages.javascript,
-			alias: 'language-javascript'
-		}
-	});
-}
-
-Prism.languages.js = Prism.languages.javascript;

data/vendor/assets/javascripts/prism/prism-jolie.js

@@ -1,56 +0,0 @@
-Prism.languages.jolie = Prism.languages.extend('clike', {
-	'keyword': /\b(?:include|define|is_defined|undef|main|init|outputPort|inputPort|Location|Protocol|Interfaces|RequestResponse|OneWay|type|interface|extender|throws|cset|csets|forward|Aggregates|Redirects|embedded|courier|extender|execution|sequential|concurrent|single|scope|install|throw|comp|cH|default|global|linkIn|linkOut|synchronized|this|new|for|if|else|while|in|Jolie|Java|Javascript|nullProcess|spawn|constants|with|provide|until|exit|foreach|instanceof|over|service)\b/g,
-	'builtin': /\b(?:undefined|string|int|void|long|Byte|bool|double|float|char|any)\b/,
-	'number': /\b\d*\.?\d+(?:e[+-]?\d+)?l?\b/i,
-	'operator': /->|<<|[!+-<>=*]?=|[:<>!?*\/%^]|&&|\|\||--?|\+\+?/g,
-	'symbol': /[|;@]/,
-	'punctuation': /[,.]/,
-	'string': {
-		pattern: /(["'])(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-		greedy: true
-	},
-});
-
-delete Prism.languages.jolie['class-name'];
-delete Prism.languages.jolie['function'];
-
-Prism.languages.insertBefore( 'jolie', 'keyword', {
-	'function':
-	{
-		pattern: /((?:\b(?:outputPort|inputPort|in|service|courier)\b|@)\s*)\w+/,
-		lookbehind: true
-	},
-	'aggregates': {
-		pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/,
-		lookbehind: true,
-		inside: {
-			'withExtension': {
-				pattern: /\bwith\s+\w+/,
-				inside: {
-					'keyword' : /\bwith\b/
-				}
-			},
-			'function': {
-				pattern: /\w+/
-			},
-			'punctuation': {
-				pattern: /,/
-			}
-		}
-	},
-	'redirects': {
-		pattern: /(\bRedirects\s*:\s*)(?:\w+\s*=>\s*\w+\s*,\s*)*(?:\w+\s*=>\s*\w+)/,
-		lookbehind: true,
-		inside: {
-			'punctuation': {
-				pattern: /,/
-			},
-			'function': {
-				pattern: /\w+/g
-			},
-			'symbol': {
-				pattern: /=>/g
-			}
-		}
-	}
-});

data/vendor/assets/javascripts/prism/prism-json.js

@@ -1,11 +0,0 @@
-Prism.languages.json = {
-    'property': /"(?:\\.|[^|"])*"(?=\s*:)/ig,
-    'string': /"(?!:)(?:\\.|[^|"])*"(?!:)/g,
-    'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee][+-]?\d+)?)\b/g,
-    'punctuation': /[{}[\]);,]/g,
-    'operator': /:/g,
-    'boolean': /\b(true|false)\b/gi,
-    'null': /\bnull\b/gi
-};
-
-Prism.languages.jsonp = Prism.languages.json;

data/vendor/assets/javascripts/prism/prism-jsx.js

@@ -1,27 +0,0 @@
-(function(Prism) {
-
-var javascript = Prism.util.clone(Prism.languages.javascript);
-
-Prism.languages.jsx = Prism.languages.extend('markup', javascript);
-Prism.languages.jsx.tag.pattern= /<\/?[\w\.:-]+\s*(?:\s+[\w\.:-]+(?:=(?:("|')(\\?[\w\W])*?\1|[^\s'">=]+|(\{[\w\W]*?\})))?\s*)*\/?>/i;
-
-Prism.languages.jsx.tag.inside['attr-value'].pattern = /=[^\{](?:('|")[\w\W]*?(\1)|[^\s>]+)/i;
-
-var jsxExpression = Prism.util.clone(Prism.languages.jsx);
-
-delete jsxExpression.punctuation
-
-jsxExpression = Prism.languages.insertBefore('jsx', 'operator', {
-  'punctuation': /=(?={)|[{}[\];(),.:]/
-}, { jsx: jsxExpression });
-
-Prism.languages.insertBefore('inside', 'attr-value',{
-	'script': {
-		// Allow for one level of nesting
-		pattern: /=(\{(?:\{[^}]*\}|[^}])+\})/i,
-		inside: jsxExpression,
-		'alias': 'language-javascript'
-	}
-}, Prism.languages.jsx.tag);
-
-}(Prism));

data/vendor/assets/javascripts/prism/prism-julia.js

@@ -1,12 +0,0 @@
-Prism.languages.julia= {
-	'comment': {
-		pattern: /(^|[^\\])#.*/,
-		lookbehind: true
-	},
-	'string': /"""[\s\S]+?"""|'''[\s\S]+?'''|("|')(\\?.)*?\1/,
-	'keyword' : /\b(abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|let|local|macro|module|print|println|quote|return|try|type|typealias|using|while)\b/,
-	'boolean' : /\b(true|false)\b/,
-	'number' : /\b-?(0[box])?(?:[\da-f]+\.?\d*|\.\d+)(?:[efp][+-]?\d+)?j?\b/i,
-	'operator': /\+=?|-=?|\*=?|\/[\/=]?|\\=?|\^=?|%=?|÷=?|!=?=?|&=?|\|[=>]?|\$=?|<(?:<=?|[=:])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥]/,
-	'punctuation' : /[{}[\];(),.:]/
-};

data/vendor/assets/javascripts/prism/prism-keyman.js

@@ -1,14 +0,0 @@
-Prism.languages.keyman = {
-	'comment': /\bc\s.*/i,
-	'function': /\[\s*((CTRL|SHIFT|ALT|LCTRL|RCTRL|LALT|RALT|CAPS|NCAPS)\s+)*([TKU]_[a-z0-9_?]+|".+?"|'.+?')\s*\]/i,  // virtual key
-	'string': /("|')((?!\1).)*\1/,
-	'bold': [   // header statements, system stores and variable system stores
-		/&(baselayout|bitmap|capsononly|capsalwaysoff|shiftfreescaps|copyright|ethnologuecode|hotkey|includecodes|keyboardversion|kmw_embedcss|kmw_embedjs|kmw_helpfile|kmw_helptext|kmw_rtl|language|layer|layoutfile|message|mnemoniclayout|name|oldcharposmatching|platform|targets|version|visualkeyboard|windowslanguages)\b/i,
-		/\b(bitmap|bitmaps|caps on only|caps always off|shift frees caps|copyright|hotkey|language|layout|message|name|version)\b/i
-	],
-	'keyword': /\b(any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|return|reset|save|set|store|use)\b/i,  // rule keywords
-	'atrule': /\b(ansi|begin|unicode|group|using keys|match|nomatch)\b/i,   // structural keywords
-	'number': /\b(U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i, // U+####, x###, d### characters and numbers
-	'operator': /[+>\\,()]/,
-	'tag': /\$(keyman|kmfl|weaver|keymanweb|keymanonly):/i   // prefixes
-};

data/vendor/assets/javascripts/prism/prism-kotlin.js

@@ -1,62 +0,0 @@
-(function (Prism) {
-	Prism.languages.kotlin = Prism.languages.extend('clike', {
-		'keyword': {
-			// The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
-			pattern: /(^|[^.])\b(?:abstract|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|else|enum|final|finally|for|fun|get|if|import|in|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|out|override|package|private|protected|public|reified|return|sealed|set|super|tailrec|this|throw|to|try|val|var|when|where|while)\b/,
-			lookbehind: true
-		},
-		'function': [
-			/\w+(?=\s*\()/,
-			{
-				pattern: /(\.)\w+(?=\s*\{)/,
-				lookbehind: true
-			}
-		],
-		'number': /\b(?:0[bx][\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?[fFL]?)\b/,
-		'operator': /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
-	});
-
-	delete Prism.languages.kotlin["class-name"];
-
-	Prism.languages.insertBefore('kotlin', 'string', {
-		'raw-string': {
-			pattern: /(["'])\1\1[\s\S]*?\1{3}/,
-			alias: 'string'
-			// See interpolation below
-		}
-	});
-	Prism.languages.insertBefore('kotlin', 'keyword', {
-		'annotation': {
-			pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
-			alias: 'builtin'
-		}
-	});
-	Prism.languages.insertBefore('kotlin', 'function', {
-		'label': {
-			pattern: /\w+@|@\w+/,
-			alias: 'symbol'
-		}
-	});
-
-	var interpolation = [
-		{
-			pattern: /\$\{[^}]+\}/,
-			inside: {
-				delimiter: {
-					pattern: /^\$\{|\}$/,
-					alias: 'variable'
-				},
-				rest: Prism.util.clone(Prism.languages.kotlin)
-			}
-		},
-		{
-			pattern: /\$\w+/,
-			alias: 'variable'
-		}
-	];
-
-	Prism.languages.kotlin['string'].inside = Prism.languages.kotlin['raw-string'].inside = {
-		interpolation: interpolation
-	};
-
-}(Prism));

data/vendor/assets/javascripts/prism/prism-latex.js

@@ -1,61 +0,0 @@
-(function(Prism) {
-	var funcPattern = /\\([^a-z()[\]]|[a-z\*]+)/i,
-	    insideEqu = {
-		    'equation-command': {
-			    pattern: funcPattern,
-			    alias: 'regex'
-		    }
-	    };
-
-	Prism.languages.latex = {
-		'comment': /%.*/m,
-		// the verbatim environment prints whitespace to the document
-		'cdata':  {
-			pattern: /(\\begin\{((?:verbatim|lstlisting)\*?)\})([\w\W]*?)(?=\\end\{\2\})/,
-			lookbehind: true
-		},
-		/*
-		 * equations can be between $ $ or \( \) or \[ \]
-		 * (all are multiline)
-		 */
-		'equation': [
-			{
-				pattern: /\$(?:\\?[\w\W])*?\$|\\\((?:\\?[\w\W])*?\\\)|\\\[(?:\\?[\w\W])*?\\\]/,
-				inside: insideEqu,
-				alias: 'string'
-			},
-			{
-				pattern: /(\\begin\{((?:equation|math|eqnarray|align|multline|gather)\*?)\})([\w\W]*?)(?=\\end\{\2\})/,
-				lookbehind: true,
-				inside: insideEqu,
-				alias: 'string'
-			}
-		],
-		/*
-		 * arguments which are keywords or references are highlighted
-		 * as keywords
-		 */
-		'keyword': {
-			pattern: /(\\(?:begin|end|ref|cite|label|usepackage|documentclass)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
-			lookbehind: true
-		},
-		'url': {
-			pattern: /(\\url\{)[^}]+(?=\})/,
-			lookbehind: true
-		},
-		/*
-		 * section or chapter headlines are highlighted as bold so that
-		 * they stand out more
-		 */
-		'headline': {
-			pattern: /(\\(?:part|chapter|section|subsection|frametitle|subsubsection|paragraph|subparagraph|subsubparagraph|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\}(?:\[[^\]]+\])?)/,
-			lookbehind: true,
-			alias: 'class-name'
-		},
-		'function': {
-			pattern: funcPattern,
-			alias: 'selector'
-		},
-		'punctuation': /[[\]{}&]/
-	};
-})(Prism);

data/vendor/assets/javascripts/prism/prism-lolcode.js

@@ -1,54 +0,0 @@
-Prism.languages.lolcode = {
-	'comment': [
-		/\bOBTW\s+[\s\S]*?\s+TLDR\b/,
-		/\bBTW.+/
-	],
-	'string': {
-		pattern: /"(?::.|[^"])*"/,
-		inside: {
-			'variable': /:\{[^}]+\}/,
-			'symbol': [
-				/:\([a-f\d]+\)/i,
-				/:\[[^\]]+\]/,
-				/:[)>o":]/
-			]
-		}
-	},
-	'number': /(-|\b)\d*\.?\d+/,
-	'symbol': {
-		pattern: /(^|\s)(?:A )?(?:YARN|NUMBR|NUMBAR|TROOF|BUKKIT|NOOB)(?=\s|,|$)/,
-		lookbehind: true,
-		inside: {
-			'keyword': /A(?=\s)/
-		}
-	},
-	'label': {
-		pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
-		lookbehind: true,
-		alias: 'string'
-	},
-	'function': {
-		pattern: /((?:^|\s)(?:I IZ|HOW IZ I|IZ) )[a-zA-Z]\w*/,
-		lookbehind: true
-	},
-	'keyword': [
-		{
-			pattern: /(^|\s)(?:O HAI IM|KTHX|HAI|KTHXBYE|I HAS A|ITZ(?: A)?|R|AN|MKAY|SMOOSH|MAEK|IS NOW(?: A)?|VISIBLE|GIMMEH|O RLY\?|YA RLY|NO WAI|OIC|MEBBE|WTF\?|OMG|OMGWTF|GTFO|IM IN YR|IM OUTTA YR|FOUND YR|YR|TIL|WILE|UPPIN|NERFIN|I IZ|HOW IZ I|IF U SAY SO|SRS|HAS A|LIEK(?: A)?|IZ)(?=\s|,|$)/,
-			lookbehind: true
-		},
-		/'Z(?=\s|,|$)/
-	],
-	'boolean': {
-		pattern: /(^|\s)(?:WIN|FAIL)(?=\s|,|$)/,
-		lookbehind: true
-	},
-	'variable': {
-		pattern: /(^|\s)IT(?=\s|,|$)/,
-		lookbehind: true
-	},
-	'operator': {
-		pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:SUM|DIFF|PRODUKT|QUOSHUNT|MOD|BIGGR|SMALLR|BOTH|EITHER|WON|ALL|ANY) OF)(?=\s|,|$)/,
-		lookbehind: true
-	},
-	'punctuation': /\.{3}|…|,|!/
-};

data/vendor/assets/javascripts/prism/prism-makefile.js

@@ -1,31 +0,0 @@
-Prism.languages.makefile = {
-	'comment': {
-		pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|.)*/,
-		lookbehind: true
-	},
-	'string': /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-
-	// Built-in target names
-	'builtin': /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
-
-	// Targets
-	'symbol': {
-		pattern: /^[^:=\r\n]+(?=\s*:(?!=))/m,
-		inside: {
-			'variable': /\$+(?:[^(){}:#=\s]+|(?=[({]))/
-		}
-	},
-	'variable': /\$+(?:[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
-
-	'keyword': [
-		// Directives
-		/-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
-		// Functions
-		{
-			pattern: /(\()(?:addsuffix|abspath|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:s|list)?)(?=[ \t])/,
-			lookbehind: true
-		}
-	],
-	'operator': /(?:::|[?:+!])?=|[|@]/,
-	'punctuation': /[:;(){}]/
-};

data/vendor/assets/javascripts/prism/prism-markdown.js

@@ -1,120 +0,0 @@
-Prism.languages.markdown = Prism.languages.extend('markup', {});
-Prism.languages.insertBefore('markdown', 'prolog', {
-	'blockquote': {
-		// > ...
-		pattern: /^>(?:[\t ]*>)*/m,
-		alias: 'punctuation'
-	},
-	'code': [
-		{
-			// Prefixed by 4 spaces or 1 tab
-			pattern: /^(?: {4}|\t).+/m,
-			alias: 'keyword'
-		},
-		{
-			// `code`
-			// ``code``
-			pattern: /``.+?``|`[^`\n]+`/,
-			alias: 'keyword'
-		}
-	],
-	'title': [
-		{
-			// title 1
-			// =======
-
-			// title 2
-			// -------
-			pattern: /\w+.*(?:\r?\n|\r)(?:==+|--+)/,
-			alias: 'important',
-			inside: {
-				punctuation: /==+$|--+$/
-			}
-		},
-		{
-			// # title 1
-			// ###### title 6
-			pattern: /(^\s*)#+.+/m,
-			lookbehind: true,
-			alias: 'important',
-			inside: {
-				punctuation: /^#+|#+$/
-			}
-		}
-	],
-	'hr': {
-		// ***
-		// ---
-		// * * *
-		// -----------
-		pattern: /(^\s*)([*-])([\t ]*\2){2,}(?=\s*$)/m,
-		lookbehind: true,
-		alias: 'punctuation'
-	},
-	'list': {
-		// * item
-		// + item
-		// - item
-		// 1. item
-		pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
-		lookbehind: true,
-		alias: 'punctuation'
-	},
-	'url-reference': {
-		// [id]: http://example.com "Optional title"
-		// [id]: http://example.com 'Optional title'
-		// [id]: http://example.com (Optional title)
-		// [id]: <http://example.com> "Optional title"
-		pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
-		inside: {
-			'variable': {
-				pattern: /^(!?\[)[^\]]+/,
-				lookbehind: true
-			},
-			'string': /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
-			'punctuation': /^[\[\]!:]|[<>]/
-		},
-		alias: 'url'
-	},
-	'bold': {
-		// **strong**
-		// __strong__
-
-		// Allow only one line break
-		pattern: /(^|[^\\])(\*\*|__)(?:(?:\r?\n|\r)(?!\r?\n|\r)|.)+?\2/,
-		lookbehind: true,
-		inside: {
-			'punctuation': /^\*\*|^__|\*\*$|__$/
-		}
-	},
-	'italic': {
-		// *em*
-		// _em_
-
-		// Allow only one line break
-		pattern: /(^|[^\\])([*_])(?:(?:\r?\n|\r)(?!\r?\n|\r)|.)+?\2/,
-		lookbehind: true,
-		inside: {
-			'punctuation': /^[*_]|[*_]$/
-		}
-	},
-	'url': {
-		// [example](http://example.com "Optional title")
-		// [example] [id]
-		pattern: /!?\[[^\]]+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)| ?\[[^\]\n]*\])/,
-		inside: {
-			'variable': {
-				pattern: /(!?\[)[^\]]+(?=\]$)/,
-				lookbehind: true
-			},
-			'string': {
-				pattern: /"(?:\\.|[^"\\])*"(?=\)$)/
-			}
-		}
-	}
-});
-
-Prism.languages.markdown['bold'].inside['url'] = Prism.util.clone(Prism.languages.markdown['url']);
-Prism.languages.markdown['italic'].inside['url'] = Prism.util.clone(Prism.languages.markdown['url']);
-Prism.languages.markdown['bold'].inside['italic'] = Prism.util.clone(Prism.languages.markdown['italic']);
-Prism.languages.markdown['italic'].inside['bold'] = Prism.util.clone(Prism.languages.markdown['bold']);

data/vendor/assets/javascripts/prism/prism-markup.js

@@ -1,46 +0,0 @@
-Prism.languages.markup = {
-	'comment': /<!--[\w\W]*?-->/,
-	'prolog': /<\?[\w\W]+?\?>/,
-	'doctype': /<!DOCTYPE[\w\W]+?>/i,
-	'cdata': /<!\[CDATA\[[\w\W]*?]]>/i,
-	'tag': {
-		pattern: /<\/?(?!\d)[^\s>\/=$<]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\\1|\\?(?!\1)[\w\W])*\1|[^\s'">=]+))?)*\s*\/?>/i,
-		inside: {
-			'tag': {
-				pattern: /^<\/?[^\s>\/]+/i,
-				inside: {
-					'punctuation': /^<\/?/,
-					'namespace': /^[^\s>\/:]+:/
-				}
-			},
-			'attr-value': {
-				pattern: /=(?:('|")[\w\W]*?(\1)|[^\s>]+)/i,
-				inside: {
-					'punctuation': /[=>"']/
-				}
-			},
-			'punctuation': /\/?>/,
-			'attr-name': {
-				pattern: /[^\s>\/]+/,
-				inside: {
-					'namespace': /^[^\s>\/:]+:/
-				}
-			}
-
-		}
-	},
-	'entity': /&#?[\da-z]{1,8};/i
-};
-
-// Plugin to make entity title show the real entity, idea by Roman Komarov
-Prism.hooks.add('wrap', function(env) {
-
-	if (env.type === 'entity') {
-		env.attributes['title'] = env.content.replace(/&amp;/, '&');
-	}
-});
-
-Prism.languages.xml = Prism.languages.markup;
-Prism.languages.html = Prism.languages.markup;
-Prism.languages.mathml = Prism.languages.markup;
-Prism.languages.svg = Prism.languages.markup;

data/vendor/assets/javascripts/prism/prism-matlab.js

@@ -1,14 +0,0 @@
-Prism.languages.matlab = {
-	// We put string before comment, because of printf() patterns that contain "%"
-	'string': /\B'(?:''|[^'\n])*'/,
-	'comment': [
-		/%\{[\s\S]*?\}%/,
-		/%.+/
-	],
-	// FIXME We could handle imaginary numbers as a whole
-	'number': /\b-?(?:\d*\.?\d+(?:[eE][+-]?\d+)?(?:[ij])?|[ij])\b/,
-	'keyword': /\b(?:break|case|catch|continue|else|elseif|end|for|function|if|inf|NaN|otherwise|parfor|pause|pi|return|switch|try|while)\b/,
-	'function': /(?!\d)\w+(?=\s*\()/,
-	'operator': /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/,
-	'punctuation': /\.{3}|[.,;\[\](){}!]/
-};