prism-rails 1.6.0.3 → 1.19.0

data/vendor/assets/javascripts/{prism → languages}/prism-puppet.js

@@ -16,6 +16,7 @@
 			{
 				pattern: /(@\(([^"\r\n\/):]+)(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r))*?[ \t]*\|?[ \t]*-?[ \t]*\2/,
 				lookbehind: true,
+				greedy: true,
 				alias: 'string',
 				inside: {
 					// Matches the end tag
@@ -37,12 +38,14 @@
 		'multiline-comment': {
 			pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
 			lookbehind: true,
+			greedy: true,
 			alias: 'comment'
 		},
 		'regex': {
 			// Must be prefixed with the keyword "node" or a non-word char
 			pattern: /((?:\bnode\s+|[~=\(\[\{,]\s*|[=+]>\s*|^\s*))\/(?:[^\/\\]|\\[\s\S])+\/(?:[imx]+\b|\B)/,
 			lookbehind: true,
+			greedy: true,
 			inside: {
 				// Extended regexes must have the x flag. They can contain single-line comments.
 				'extended-regex': {
@@ -55,11 +58,13 @@
 		},
 		'comment': {
 			pattern: /(^|[^\\])#.*/,
-			lookbehind: true
+			lookbehind: true,
+			greedy: true,
 		},
 		'string': {
 			// Allow for one nested level of double quotes inside interpolation
 			pattern: /(["'])(?:\$\{(?:[^'"}]|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}|(?!\1)[^\\]|\\[\s\S])*\1/,
+			greedy: true,
 			inside: {
 				'double-quoted': {
 					pattern: /^"[\s\S]*"$/,
@@ -114,7 +119,7 @@
 					pattern: /^\$/,
 					alias: 'variable'
 				},
-				rest: Prism.util.clone(Prism.languages.puppet)
+				rest: Prism.languages.puppet
 			}
 		},
 		{

data/vendor/assets/javascripts/{prism → languages}/prism-pure.js

@@ -1,7 +1,19 @@
 (function (Prism) {
 	Prism.languages.pure = {
+		'comment': [
+			{
+				pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+				lookbehind: true
+			},
+			{
+				pattern: /(^|[^\\:])\/\/.*/,
+				lookbehind: true
+			},
+			/#!.+/
+		],
 		'inline-lang': {
 			pattern: /%<[\s\S]+?%>/,
+			greedy: true,
 			inside: {
 				'lang': {
 					pattern: /(^%< *)-\*-.+?-\*-/,
@@ -14,18 +26,10 @@
 				}
 			}
 		},
-		'comment': [
-			{
-				pattern: /(^|[^\\])\/\*[\w\W]*?\*\//,
-				lookbehind: true
-			},
-			{
-				pattern: /(^|[^\\:])\/\/.*/,
-				lookbehind: true
-			},
-			/#!.+/
-		],
-		'string': /"(?:\\.|[^"\\\r\n])*"/,
+		'string': {
+			pattern: /"(?:\\.|[^"\\\r\n])*"/,
+			greedy: true
+		},
 		'number': {
 			// The look-behind prevents wrong highlighting of the .. operator
 			pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d)?|\B\.\d)\d*(?:e[+-]?\d+)?L?)/i,
@@ -46,11 +50,9 @@
 	var inlineLanguages = [
 		'c',
 		{ lang: 'c++', alias: 'cpp' },
-		'fortran',
-		'ats',
-		'dsp'
+		'fortran'
 	];
-	var inlineLanguageRe = '%< *-\\*- *{lang}\\d* *-\\*-[\\s\\S]+?%>';
+	var inlineLanguageRe = /%< *-\*- *{lang}\d* *-\*-[\s\S]+?%>/.source;
 
 	inlineLanguages.forEach(function (lang) {
 		var alias = lang;
@@ -74,4 +76,4 @@
 		Prism.languages.pure['inline-lang'].inside.rest = Prism.util.clone(Prism.languages.c);
 	}
 
-}(Prism));
+}(Prism));

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

@@ -0,0 +1,64 @@
+Prism.languages.python = {
+	'comment': {
+		pattern: /(^|[^\\])#.*/,
+		lookbehind: true
+	},
+	'string-interpolation': {
+		pattern: /(?:f|rf|fr)(?:("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+		greedy: true,
+		inside: {
+			'interpolation': {
+				// "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+				pattern: /((?:^|[^{])(?:{{)*){(?!{)(?:[^{}]|{(?!{)(?:[^{}]|{(?!{)(?:[^{}])+})+})+}/,
+				lookbehind: true,
+				inside: {
+					'format-spec': {
+						pattern: /(:)[^:(){}]+(?=}$)/,
+						lookbehind: true
+					},
+					'conversion-option': {
+						pattern: /![sra](?=[:}]$)/,
+						alias: 'punctuation'
+					},
+					rest: null
+				}
+			},
+			'string': /[\s\S]+/
+		}
+	},
+	'triple-quoted-string': {
+		pattern: /(?:[rub]|rb|br)?("""|''')[\s\S]+?\1/i,
+		greedy: true,
+		alias: 'string'
+	},
+	'string': {
+		pattern: /(?:[rub]|rb|br)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+		greedy: true
+	},
+	'function': {
+		pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+		lookbehind: true
+	},
+	'class-name': {
+		pattern: /(\bclass\s+)\w+/i,
+		lookbehind: true
+	},
+	'decorator': {
+		pattern: /(^\s*)@\w+(?:\.\w+)*/im,
+		lookbehind: true,
+		alias: ['annotation', 'punctuation'],
+		inside: {
+			'punctuation': /\./
+		}
+	},
+	'keyword': /\b(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+	'builtin': /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+	'boolean': /\b(?:True|False|None)\b/,
+	'number': /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
+	'operator': /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+	'punctuation': /[{}[\];(),.:]/
+};
+
+Prism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python;
+
+Prism.languages.py = Prism.languages.python;

data/vendor/assets/javascripts/{prism → languages}/prism-q.js

@@ -6,7 +6,8 @@ Prism.languages.q = {
 		{
 
 			pattern: /([\t )\]}])\/.*/,
-			lookbehind: true
+			lookbehind: true,
+			greedy: true
 		},
 		// From http://code.kx.com/wiki/Reference/Slash:
 		// A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.
@@ -15,13 +16,19 @@ Prism.languages.q = {
 		// The / and \ must be the first char on the line, but may be followed by any amount of whitespace.
 		{
 			pattern: /(^|\r?\n|\r)\/[\t ]*(?:(?:\r?\n|\r)(?:.*(?:\r?\n|\r))*?(?:\\(?=[\t ]*(?:\r?\n|\r))|$)|\S.*)/,
-			lookbehind: true
+			lookbehind: true,
+			greedy: true
 		},
 		// From http://code.kx.com/wiki/Reference/Slash:
 		// A \ on a line by itself with no preceding matching / will comment to end of file.
-		/^\\[\t ]*(?:\r?\n|\r)[\s\S]+/m,
-
-		/^#!.+/m
+		{
+			pattern: /^\\[\t ]*(?:\r?\n|\r)[\s\S]+/m,
+			greedy: true
+		},
+		{
+			pattern: /^#!.+/m,
+			greedy: true
+		}
 	],
 	'symbol': /`(?::\S+|[\w.]*)/,
 	'datetime': {
@@ -30,7 +37,7 @@ Prism.languages.q = {
 	},
 	// The negative look-ahead prevents bad highlighting
 	// of verbs 0: and 1:
-	'number': /\b-?(?![01]:)(?:0[wn]|0W[hj]?|0N[hje]?|0x[\da-fA-F]+|\d+\.?\d*(?:e[+-]?\d+)?[hjfeb]?)/,
+	'number': /\b(?![01]:)(?:0[wn]|0W[hj]?|0N[hje]?|0x[\da-fA-F]+|\d+\.?\d*(?:e[+-]?\d+)?[hjfeb]?)/,
 	'keyword': /\\\w+\b|\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\b/,
 	'adverb': {
 		pattern: /['\/\\]:?|\beach\b/,

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

@@ -0,0 +1,58 @@
+(function (Prism) {
+
+	var jsString = /"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*'/.source;
+	var jsComment = /\/\/.*|\/\*(?:(?!\*\/)[\s\S])*\*\//.source;
+
+	var jsExpr = /(?:[^\\()[\]{}"'/]|<string>|\/(?![*/])|<comment>|\(<expr>*\)|\[<expr>*\]|\{<expr>*\}|\\[\s\S])/
+		.source.replace(/<string>/g, jsString).replace(/<comment>/g, jsComment);
+
+	// the pattern will blow up, so only a few iterations
+	for (var i = 0; i < 2; i++) {
+		jsExpr = jsExpr.replace(/<expr>/g, jsExpr);
+	}
+	jsExpr = jsExpr.replace(/<expr>/g, '[^\\s\\S]');
+
+
+	Prism.languages.qml = {
+		'comment': {
+			pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+			greedy: true
+		},
+		'javascript-function': {
+			pattern: RegExp(/((?:^|;)[ \t]*)function\s+[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\s*\(<js>*\)\s*\{<js>*\}/.source.replace(/<js>/g, jsExpr), 'm'),
+			lookbehind: true,
+			greedy: true,
+			alias: 'language-javascript',
+			inside: Prism.languages.javascript
+		},
+		'class-name': {
+			pattern: /((?:^|[:;])[ \t]*)(?!\d)\w+(?=[ \t]*\{|[ \t]+on\b)/m,
+			lookbehind: true
+		},
+		'property': [
+			{
+				pattern: /((?:^|[;{])[ \t]*)(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+				lookbehind: true
+			},
+			{
+				pattern: /((?:^|[;{])[ \t]*)property[ \t]+(?!\d)\w+(?:\.\w+)*[ \t]+(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+				lookbehind: true,
+				inside: {
+					'keyword': /^property/,
+					'property': /\w+(?:\.\w+)*/
+				}
+			}
+		],
+		'javascript-expression': {
+			pattern: RegExp(/(:[ \t]*)(?![\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(/<js>/g, jsExpr), 'm'),
+			lookbehind: true,
+			greedy: true,
+			alias: 'language-javascript',
+			inside: Prism.languages.javascript
+		},
+		'string': /"(?:\\.|[^\\"\r\n])*"/,
+		'keyword': /\b(?:as|import|on)\b/,
+		'punctuation': /[{}[\]:;,]/
+	};
+
+}(Prism));

data/vendor/assets/javascripts/{prism → languages}/prism-qore.js

@@ -1,17 +1,20 @@
 Prism.languages.qore = Prism.languages.extend('clike', {
 	'comment': {
-		pattern: /(^|[^\\])(?:\/\*[\w\W]*?\*\/|(?:\/\/|#).*)/,
+		pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
 		lookbehind: true
 	},
 	// Overridden to allow unescaped multi-line strings
-	'string': /("|')(\\(?:\r\n|[\s\S])|(?!\1)[^\\])*\1/,
+	'string': {
+		pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+		greedy: true
+	},
 	'variable': /\$(?!\d)\w+\b/,
 	'keyword': /\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:int|float|number|bool|string|date|list)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\b/,
 	'number': /\b(?:0b[01]+|0x[\da-f]*\.?[\da-fp\-]+|\d*\.?\d+e?\d*[df]|\d*\.?\d+)\b/i,
 	'boolean': /\b(?:true|false)\b/i,
 	'operator': {
-		pattern: /(^|[^\.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
+		pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
 		lookbehind: true
 	},
 	'function': /\$?\b(?!\d)\w+(?=\()/
-});
+});

data/vendor/assets/javascripts/{prism → languages}/prism-r.js

@@ -1,6 +1,9 @@
 Prism.languages.r = {
 	'comment': /#.*/,
-	'string': /(['"])(?:\\?.)*?\1/,
+	'string': {
+		pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+		greedy: true
+	},
 	'percent-operator': {
 		// Includes user-defined operators
 		// and %%, %*%, %/%, %in%, %o%, %x%
@@ -11,7 +14,7 @@ Prism.languages.r = {
 	'ellipsis': /\.\.(?:\.|\d+)/,
 	'number': [
 		/\b(?:NaN|Inf)\b/,
-		/\b(?:0x[\dA-Fa-f]+(?:\.\d*)?|\d*\.?\d+)(?:[EePp][+-]?\d+)?[iL]?\b/
+		/(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+\.?\d*|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/
 	],
 	'keyword': /\b(?:if|else|repeat|while|function|for|in|next|break|NULL|NA|NA_integer_|NA_real_|NA_complex_|NA_character_)\b/,
 	'operator': /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,

data/vendor/assets/javascripts/{prism → languages}/prism-reason.js

@@ -1,20 +1,16 @@
 Prism.languages.reason = Prism.languages.extend('clike', {
-	'comment': {
-		pattern: /(^|[^\\])\/\*[\w\W]*?\*\//,
-		lookbehind: true
-	},
 	'string': {
-		pattern: /"(\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
+		pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
 		greedy: true
 	},
 	// 'class-name' must be matched *after* 'constructor' defined below
 	'class-name': /\b[A-Z]\w*/,
 	'keyword': /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/,
-	'operator': /\.{3}|:[:=]|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:mod|land|lor|lxor|lsl|lsr|asr)\b/
+	'operator': /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:mod|land|lor|lxor|lsl|lsr|asr)\b/
 });
 Prism.languages.insertBefore('reason', 'class-name', {
 	'character': {
-		pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'])'/,
+		pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/,
 		alias: 'string'
 	},
 	'constructor': {
@@ -29,4 +25,4 @@ Prism.languages.insertBefore('reason', 'class-name', {
 });
 
 // We can't match functions property, so let's not even try.
-delete Prism.languages.reason.function;
+delete Prism.languages.reason.function;

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

@@ -0,0 +1,97 @@
+(function (Prism) {
+
+	var specialEscape = {
+		pattern: /\\[\\(){}[\]^$+*?|.]/,
+		alias: 'escape'
+	};
+	var escape = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|c[a-zA-Z]|0[0-7]{0,2}|[123][0-7]{2}|.)/
+	var charClass = /\\[wsd]|\.|\\p{[^{}]+}/i
+
+	var rangeChar = '(?:[^\\\\-]|' + escape.source + ')';
+	var range = RegExp(rangeChar + '-' + rangeChar);
+
+	// the name of a capturing group
+	var groupName = {
+		pattern: /(<|')[^<>']+(?=[>']$)/,
+		lookbehind: true,
+		alias: 'variable'
+	};
+
+	var backreference = [
+		/\\(?![123][0-7]{2})[1-9]/, // a backreference which is not an octal escape
+		{
+			pattern: /\\k<[^<>']+>/,
+			inside: {
+				'group-name': groupName
+			}
+		}
+	];
+
+	Prism.languages.regex = {
+		'charset': {
+			pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+			lookbehind: true,
+			inside: {
+				'charset-negation': {
+					pattern: /(^\[)\^/,
+					lookbehind: true,
+				},
+				'charset-punctuation': /^\[|\]$/,
+				'range': {
+					pattern: range,
+					inside: {
+						'escape': escape,
+						'range-punctuation': /-/
+					}
+				},
+				'special-escape': specialEscape,
+				'charclass': charClass,
+				'backreference': backreference,
+				'escape': escape
+			}
+		},
+		'special-escape': specialEscape,
+		'charclass': charClass,
+		'backreference': backreference,
+		'anchor': /[$^]|\\[ABbGZz]/,
+		'escape': escape,
+		'group': [
+			{
+				// https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+				// https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+
+				// (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+				pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+				inside: {
+					'group-name': groupName
+				}
+			},
+			/\)/
+		],
+		'quantifier': /[+*?]|\{(?:\d+,?\d*)\}/,
+		'alternation': /\|/
+	};
+
+
+	[
+		'actionscript',
+		'coffescript',
+		'flow',
+		'javascript',
+		'typescript',
+		'vala'
+	].forEach(function (lang) {
+		var grammar = Prism.languages[lang];
+		if (grammar) {
+			grammar['regex'].inside = {
+				'regex-flags': /[a-z]+$/,
+				'regex-delimiter': /^\/|\/$/,
+				'language-regex': {
+					pattern: /[\s\S]+/,
+					inside: Prism.languages.regex
+				}
+			};
+		}
+	});
+
+}(Prism))