prism-rails 1.19.0 → 1.29.0

data/vendor/assets/javascripts/languages/prism-kusto.js

@@ -0,0 +1,44 @@
+Prism.languages.kusto = {
+	'comment': {
+		pattern: /\/\/.*/,
+		greedy: true
+	},
+	'string': {
+		pattern: /```[\s\S]*?```|[hH]?(?:"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\.)*'|@(?:"[^\r\n"]*"|'[^\r\n']*'))/,
+		greedy: true
+	},
+
+	'verb': {
+		pattern: /(\|\s*)[a-z][\w-]*/i,
+		lookbehind: true,
+		alias: 'keyword'
+	},
+
+	'command': {
+		pattern: /\.[a-z][a-z\d-]*\b/,
+		alias: 'keyword'
+	},
+
+	'class-name': /\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\b/,
+	'keyword': /\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\s+regex|nulls\s+(?:first|last))(?![\w-])/,
+	'boolean': /\b(?:false|null|true)\b/,
+
+	'function': /\b[a-z_]\w*(?=\s*\()/,
+
+	'datetime': [
+		{
+			// RFC 822 + RFC 850
+			pattern: /\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\s*,\s*)?\d{1,2}(?:\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\s+|-)\d{2}\s+\d{2}:\d{2}(?::\d{2})?(?:\s*(?:\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\d{4}))?\b/,
+			alias: 'number'
+		},
+		{
+			// ISO 8601
+			pattern: /[+-]?\b(?:\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)Z?/,
+			alias: 'number'
+		}
+	],
+	'number': /\b(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?)(?:(?:min|sec|[mnµ]s|[dhms]|microsecond|tick)\b)?|[+-]?\binf\b/,
+
+	'operator': /=>|[!=]~|[!=<>]=?|[-+*/%|]|\.\./,
+	'punctuation': /[()\[\]{},;.:]/
+};

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

@@ -8,10 +8,10 @@
 	};
 
 	Prism.languages.latex = {
-		'comment': /%.*/m,
+		'comment': /%.*/,
 		// the verbatim environment prints whitespace to the document
 		'cdata': {
-			pattern: /(\\begin\{((?:verbatim|lstlisting)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+			pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
 			lookbehind: true
 		},
 		/*
@@ -25,7 +25,7 @@
 				alias: 'string'
 			},
 			{
-				pattern: /(\\begin\{((?:equation|math|eqnarray|align|multline|gather)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+				pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
 				lookbehind: true,
 				inside: insideEqu,
 				alias: 'string'
@@ -36,7 +36,7 @@
 		 * as keywords
 		 */
 		'keyword': {
-			pattern: /(\\(?:begin|end|ref|cite|label|usepackage|documentclass)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+			pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
 			lookbehind: true
 		},
 		'url': {
@@ -48,7 +48,7 @@
 		 * they stand out more
 		 */
 		'headline': {
-			pattern: /(\\(?:part|chapter|section|subsection|frametitle|subsubsection|paragraph|subparagraph|subsubparagraph|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\}(?:\[[^\]]+\])?)/,
+			pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
 			lookbehind: true,
 			alias: 'class-name'
 		},
@@ -61,4 +61,4 @@
 
 	Prism.languages.tex = Prism.languages.latex;
 	Prism.languages.context = Prism.languages.latex;
-})(Prism);
+}(Prism));

data/vendor/assets/javascripts/languages/prism-latte.js

@@ -1,21 +1,15 @@
 (function (Prism) {
 	Prism.languages.latte = {
 		'comment': /^\{\*[\s\S]*/,
-		'ld': {
-			pattern: /^\{(?:[=_]|\/?(?!\d|\w+\()\w+|)/,
-			inside: {
-				'punctuation': /^\{\/?/,
-				'tag': {
-					pattern: /.+/,
-					alias: 'important'
-				}
-			}
+		'latte-tag': {
+			// https://latte.nette.org/en/tags
+			pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i,
+			lookbehind: true,
+			alias: 'important'
 		},
-		'rd': {
-			pattern: /\}$/,
-			inside: {
-				'punctuation': /.+/
-			}
+		'delimiter': {
+			pattern: /^\{\/?|\}$/,
+			alias: 'punctuation'
 		},
 		'php': {
 			pattern: /\S(?:[\s\S]*\S)?/,
@@ -53,16 +47,16 @@
 		},
 	}, markupLatte.tag);
 
-	Prism.hooks.add('before-tokenize', function(env) {
+	Prism.hooks.add('before-tokenize', function (env) {
 		if (env.language !== 'latte') {
 			return;
 		}
-		var lattePattern = /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*[\s\S]*?\*\/)*?\}/g;
+		var lattePattern = /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g;
 		Prism.languages['markup-templating'].buildPlaceholders(env, 'latte', lattePattern);
 		env.grammar = markupLatte;
 	});
 
-	Prism.hooks.add('after-tokenize', function(env) {
+	Prism.hooks.add('after-tokenize', function (env) {
 		Prism.languages['markup-templating'].tokenizePlaceholders(env, 'latte');
 	});
 

data/vendor/assets/javascripts/languages/prism-less.js

@@ -15,21 +15,21 @@ Prism.languages.less = Prism.languages.extend('css', {
 		}
 	],
 	'atrule': {
-		pattern: /@[\w-]+?(?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};])*?(?=\s*\{)/,
+		pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
 		inside: {
 			'punctuation': /[:()]/
 		}
 	},
 	// selectors and mixins are considered the same
 	'selector': {
-		pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@])*?(?=\s*\{)/,
+		pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
 		inside: {
 			// mixin parameters
 			'variable': /@+[\w-]+/
 		}
 	},
 
-	'property': /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/i,
+	'property': /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
 	'operator': /[+\-*\/]/
 });
 
@@ -39,7 +39,7 @@ Prism.languages.insertBefore('less', 'property', {
 		{
 			pattern: /@[\w-]+\s*:/,
 			inside: {
-				"punctuation": /:/
+				'punctuation': /:/
 			}
 		},
 
@@ -47,7 +47,7 @@ Prism.languages.insertBefore('less', 'property', {
 		/@@?[\w-]+/
 	],
 	'mixin-usage': {
-		pattern: /([{;]\s*)[.#](?!\d)[\w-]+.*?(?=[(;])/,
+		pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
 		lookbehind: true,
 		alias: 'function'
 	}

data/vendor/assets/javascripts/languages/prism-lilypond.js

@@ -1,11 +1,11 @@
 (function (Prism) {
 
-	var schemeExpression = /\((?:[^();"#\\]|\\[\s\S]|;.*|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source;
+	var schemeExpression = /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source;
 	// allow for up to pow(2, recursivenessLog2) many levels of recursive brace expressions
 	// For some reason, this can't be 4
 	var recursivenessLog2 = 5;
 	for (var i = 0; i < recursivenessLog2; i++) {
-		schemeExpression = schemeExpression.replace(/<expr>/g, schemeExpression);
+		schemeExpression = schemeExpression.replace(/<expr>/g, function () { return schemeExpression; });
 	}
 	schemeExpression = schemeExpression.replace(/<expr>/g, /[^\s\S]/.source);
 
@@ -13,7 +13,7 @@
 	var lilypond = Prism.languages.lilypond = {
 		'comment': /%(?:(?!\{).*|\{[\s\S]*?%\})/,
 		'embedded-scheme': {
-			pattern: RegExp(/(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(/<expr>/g, schemeExpression), 'm'),
+			pattern: RegExp(/(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(/<expr>/g, function () { return schemeExpression; }), 'm'),
 			lookbehind: true,
 			greedy: true,
 			inside: {

data/vendor/assets/javascripts/languages/prism-linker-script.js

@@ -0,0 +1,30 @@
+Prism.languages['linker-script'] = {
+	'comment': {
+		pattern: /(^|\s)\/\*[\s\S]*?(?:$|\*\/)/,
+		lookbehind: true,
+		greedy: true
+	},
+	'identifier': {
+		pattern: /"[^"\r\n]*"/,
+		greedy: true
+	},
+
+	'location-counter': {
+		pattern: /\B\.\B/,
+		alias: 'important'
+	},
+
+	'section': {
+		pattern: /(^|[^\w*])\.\w+\b/,
+		lookbehind: true,
+		alias: 'keyword'
+	},
+	'function': /\b[A-Z][A-Z_]*(?=\s*\()/,
+
+	'number': /\b(?:0[xX][a-fA-F0-9]+|\d+)[KM]?\b/,
+
+	'operator': />>=?|<<=?|->|\+\+|--|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?/,
+	'punctuation': /[(){},;]/
+};
+
+Prism.languages['ld'] = Prism.languages['linker-script'];

data/vendor/assets/javascripts/languages/prism-liquid.js

@@ -1,12 +1,66 @@
 Prism.languages.liquid = {
-	'keyword': /\b(?:comment|endcomment|if|elsif|else|endif|unless|endunless|for|endfor|case|endcase|when|in|break|assign|continue|limit|offset|range|reversed|raw|endraw|capture|endcapture|tablerow|endtablerow)\b/,
-	'number': /\b0b[01]+\b|\b0x[\da-f]*\.?[\da-fp-]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?[df]?/i,
-	'operator': {
-		pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|!=?|<<?=?|>>?>?=?|==?|&[&=]?|\|[|=]?|\*=?|\/=?|%=?|\^=?|[?:~])/m,
+	'comment': {
+		pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
 		lookbehind: true
 	},
-	'function': {
-		pattern: /(^|[\s;|&])(?:append|prepend|capitalize|cycle|cols|increment|decrement|abs|at_least|at_most|ceil|compact|concat|date|default|divided_by|downcase|escape|escape_once|first|floor|join|last|lstrip|map|minus|modulo|newline_to_br|plus|remove|remove_first|replace|replace_first|reverse|round|rstrip|size|slice|sort|sort_natural|split|strip|strip_html|strip_newlines|times|truncate|truncatewords|uniq|upcase|url_decode|url_encode|include|paginate)(?=$|[\s;|&])/,
-		lookbehind: true
-	}
+	'delimiter': {
+		pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/,
+		alias: 'punctuation'
+	},
+	'string': {
+		pattern: /"[^"]*"|'[^']*'/,
+		greedy: true
+	},
+	'keyword': /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/,
+	'object': /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/,
+	'function': [
+		{
+			pattern: /(\|\s*)\w+/,
+			lookbehind: true,
+			alias: 'filter'
+		},
+		{
+			// array functions
+			pattern: /(\.\s*)(?:first|last|size)/,
+			lookbehind: true
+		}
+	],
+	'boolean': /\b(?:false|nil|true)\b/,
+	'range': {
+		pattern: /\.\./,
+		alias: 'operator'
+	},
+	// https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21
+	'number': /\b\d+(?:\.\d+)?\b/,
+	'operator': /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/,
+	'punctuation': /[.,\[\]()]/,
+	'empty': {
+		pattern: /\bempty\b/,
+		alias: 'keyword'
+	},
 };
+
+Prism.hooks.add('before-tokenize', function (env) {
+	var liquidPattern = /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g;
+	var insideRaw = false;
+
+	Prism.languages['markup-templating'].buildPlaceholders(env, 'liquid', liquidPattern, function (match) {
+		var tagMatch = /^\{%-?\s*(\w+)/.exec(match);
+		if (tagMatch) {
+			var tag = tagMatch[1];
+			if (tag === 'raw' && !insideRaw) {
+				insideRaw = true;
+				return true;
+			} else if (tag === 'endraw') {
+				insideRaw = false;
+				return true;
+			}
+		}
+
+		return !insideRaw;
+	});
+});
+
+Prism.hooks.add('after-tokenize', function (env) {
+	Prism.languages['markup-templating'].tokenizePlaceholders(env, 'liquid');
+});

data/vendor/assets/javascripts/languages/prism-lisp.js

@@ -1,20 +1,29 @@
 (function (Prism) {
-	// Functions to construct regular expressions
-	// simple form
-	// e.g. (interactive ... or (interactive)
+	/**
+	 * Functions to construct regular expressions
+	 * e.g. (interactive ... or (interactive)
+	 *
+	 * @param {string} name
+	 * @returns {RegExp}
+	 */
 	function simple_form(name) {
-		return RegExp('(\\()' + name + '(?=[\\s\\)])');
+		return RegExp(/(\()/.source + '(?:' + name + ')' + /(?=[\s\)])/.source);
 	}
-	// booleans and numbers
+	/**
+	 * booleans and numbers
+	 *
+	 * @param {string} pattern
+	 * @returns {RegExp}
+	 */
 	function primitive(pattern) {
-		return RegExp('([\\s([])' + pattern + '(?=[\\s)])');
+		return RegExp(/([\s([])/.source + '(?:' + pattern + ')' + /(?=[\s)])/.source);
 	}
 
 	// Patterns in regular expressions
 
 	// Symbol name. See https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Type.html
 	// & and : are excluded as they are usually used for special purposes
-	var symbol = '[-+*/_~!@$%^=<>{}\\w]+';
+	var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source;
 	// symbol starting with & used in function arguments
 	var marker = '&' + symbol;
 	// Open parenthesis for look-behind
@@ -22,6 +31,7 @@
 	var endpar = '(?=\\))';
 	// End the pattern with look-ahead space
 	var space = '(?=\\s)';
+	var nestedPar = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source;
 
 	var language = {
 		// Three or four semicolons are considered a heading.
@@ -55,38 +65,38 @@
 			{
 				pattern: RegExp(
 					par +
-						'(?:(?:lexical-)?let\\*?|(?:cl-)?letf|if|when|while|unless|cons|cl-loop|and|or|not|cond|setq|error|message|null|require|provide|use-package)' +
+						'(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)' +
 						space
 				),
 				lookbehind: true
 			},
 			{
 				pattern: RegExp(
-					par + '(?:for|do|collect|return|finally|append|concat|in|by)' + space
+					par + '(?:append|by|collect|concat|do|finally|for|in|return)' + space
 				),
 				lookbehind: true
 			},
 		],
 		declare: {
-			pattern: simple_form('declare'),
+			pattern: simple_form(/declare/.source),
 			lookbehind: true,
 			alias: 'keyword'
 		},
 		interactive: {
-			pattern: simple_form('interactive'),
+			pattern: simple_form(/interactive/.source),
 			lookbehind: true,
 			alias: 'keyword'
 		},
 		boolean: {
-			pattern: primitive('(?:t|nil)'),
+			pattern: primitive(/nil|t/.source),
 			lookbehind: true
 		},
 		number: {
-			pattern: primitive('[-+]?\\d+(?:\\.\\d*)?'),
+			pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source),
 			lookbehind: true
 		},
 		defvar: {
-			pattern: RegExp(par + 'def(?:var|const|custom|group)\\s+' + symbol),
+			pattern: RegExp(par + 'def(?:const|custom|group|var)\\s+' + symbol),
 			lookbehind: true,
 			inside: {
 				keyword: /^def[a-z]+/,
@@ -94,13 +104,9 @@
 			}
 		},
 		defun: {
-			pattern: RegExp(
-				par +
-					'(?:cl-)?(?:defun\\*?|defmacro)\\s+' +
-					symbol +
-					'\\s+\\([\\s\\S]*?\\)'
-			),
+			pattern: RegExp(par + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + symbol + /\s+\(/.source + nestedPar + /\)/.source),
 			lookbehind: true,
+			greedy: true,
 			inside: {
 				keyword: /^(?:cl-)?def\S+/,
 				// See below, this property needs to be defined later so that it can
@@ -114,8 +120,9 @@
 			}
 		},
 		lambda: {
-			pattern: RegExp(par + 'lambda\\s+\\((?:&?' + symbol + '\\s*)*\\)'),
+			pattern: RegExp(par + 'lambda\\s+\\(\\s*(?:&?' + symbol + '(?:\\s+&?' + symbol + ')*\\s*)?\\)'),
 			lookbehind: true,
+			greedy: true,
 			inside: {
 				keyword: /^lambda/,
 				// See below, this property needs to be defined later so that it can
@@ -141,37 +148,30 @@
 
 	var arg = {
 		'lisp-marker': RegExp(marker),
-		rest: {
-			argument: {
-				pattern: RegExp(symbol),
-				alias: 'variable'
-			},
-			varform: {
-				pattern: RegExp(par + symbol + '\\s+\\S[\\s\\S]*' + endpar),
-				lookbehind: true,
-				inside: {
-					string: language.string,
-					boolean: language.boolean,
-					number: language.number,
-					symbol: language.symbol,
-					punctuation: /[()]/
-				}
-			}
-		}
+		'varform': {
+			pattern: RegExp(/\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source),
+			inside: language
+		},
+		'argument': {
+			pattern: RegExp(/(^|[\s(])/.source + symbol),
+			lookbehind: true,
+			alias: 'variable'
+		},
+		rest: language
 	};
 
 	var forms = '\\S+(?:\\s+\\S+)*';
 
 	var arglist = {
-		pattern: RegExp(par + '[\\s\\S]*' + endpar),
+		pattern: RegExp(par + nestedPar + endpar),
 		lookbehind: true,
 		inside: {
 			'rest-vars': {
-				pattern: RegExp('&(?:rest|body)\\s+' + forms),
+				pattern: RegExp('&(?:body|rest)\\s+' + forms),
 				inside: arg
 			},
 			'other-marker-vars': {
-				pattern: RegExp('&(?:optional|aux)\\s+' + forms),
+				pattern: RegExp('&(?:aux|optional)\\s+' + forms),
 				inside: arg
 			},
 			keys: {

data/vendor/assets/javascripts/languages/prism-livescript.js

@@ -47,7 +47,7 @@ Prism.languages.livescript = {
 	],
 	'regex': [
 		{
-			pattern: /\/\/(?:\[.+?]|\\.|(?!\/\/)[^\\])+\/\/[gimyu]{0,5}/,
+			pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,
 			greedy: true,
 			inside: {
 				'comment': {
@@ -57,7 +57,7 @@ Prism.languages.livescript = {
 			}
 		},
 		{
-			pattern: /\/(?:\[.+?]|\\.|[^/\\\r\n])+\/[gimyu]{0,5}/,
+			pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,
 			greedy: true
 		}
 	],
@@ -66,7 +66,7 @@ Prism.languages.livescript = {
 		lookbehind: true
 	},
 	'keyword-operator': {
-		pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?:nt| not)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
+		pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
 		lookbehind: true,
 		alias: 'operator'
 	},

data/vendor/assets/javascripts/languages/prism-llvm.js

@@ -0,0 +1,19 @@
+(function (Prism) {
+	Prism.languages.llvm = {
+		'comment': /;.*/,
+		'string': {
+			pattern: /"[^"]*"/,
+			greedy: true,
+		},
+		'boolean': /\b(?:false|true)\b/,
+		'variable': /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i,
+		'label': /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i,
+		'type': {
+			pattern: /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/,
+			alias: 'class-name',
+		},
+		'keyword': /\b[a-z_][a-z_0-9]*\b/,
+		'number': /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/,
+		'punctuation': /[{}[\];(),.!*=<>]/,
+	};
+}(Prism));

data/vendor/assets/javascripts/languages/prism-log.js

@@ -0,0 +1,120 @@
+// This is a language definition for generic log files.
+// Since there is no one log format, this language definition has to support all formats to some degree.
+//
+// Based on https://github.com/MTDL9/vim-log-highlighting
+
+Prism.languages.log = {
+	'string': {
+		// Single-quoted strings must not be confused with plain text. E.g. Can't isn't Susan's Chris' toy
+		pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/,
+		greedy: true,
+	},
+
+	'exception': {
+		pattern: /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/,
+		lookbehind: true,
+		greedy: true,
+		alias: ['javastacktrace', 'language-javastacktrace'],
+		inside: Prism.languages['javastacktrace'] || {
+			'keyword': /\bat\b/,
+			'function': /[a-z_][\w$]*(?=\()/,
+			'punctuation': /[.:()]/
+		}
+	},
+
+	'level': [
+		{
+			pattern: /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/,
+			alias: ['error', 'important']
+		},
+		{
+			pattern: /\b(?:WARN|WARNING|WRN)\b/,
+			alias: ['warning', 'important']
+		},
+		{
+			pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/,
+			alias: ['info', 'keyword']
+		},
+		{
+			pattern: /\b(?:DBG|DEBUG|FINE)\b/,
+			alias: ['debug', 'keyword']
+		},
+		{
+			pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/,
+			alias: ['trace', 'comment']
+		}
+	],
+
+	'property': {
+		pattern: /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im,
+		lookbehind: true
+	},
+
+	'separator': {
+		pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m,
+		lookbehind: true,
+		alias: 'comment'
+	},
+
+	'url': /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/,
+	'email': {
+		pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/,
+		lookbehind: true,
+		alias: 'url'
+	},
+
+	'ip-address': {
+		pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/,
+		alias: 'constant'
+	},
+	'mac-address': {
+		pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i,
+		alias: 'constant'
+	},
+	'domain': {
+		pattern: /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/,
+		lookbehind: true,
+		alias: 'constant'
+	},
+
+	'uuid': {
+		pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i,
+		alias: 'constant'
+	},
+	'hash': {
+		pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i,
+		alias: 'constant'
+	},
+
+	'file-path': {
+		pattern: /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i,
+		lookbehind: true,
+		greedy: true,
+		alias: 'string'
+	},
+
+	'date': {
+		pattern: RegExp(
+			/\b\d{4}[-/]\d{2}[-/]\d{2}(?:T(?=\d{1,2}:)|(?=\s\d{1,2}:))/.source +
+			'|' +
+			/\b\d{1,4}[-/ ](?:\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\d{2,4}T?\b/.source +
+			'|' +
+			/\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\s{1,2}\d{1,2}\b/.source,
+			'i'
+		),
+		alias: 'number'
+	},
+	'time': {
+		pattern: /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/,
+		alias: 'number'
+	},
+
+	'boolean': /\b(?:false|null|true)\b/i,
+	'number': {
+		pattern: /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i,
+		lookbehind: true
+	},
+
+	'operator': /[;:?<=>~/@!$%&+\-|^(){}*#]/,
+	'punctuation': /[\[\].,]/
+};