prism-rails 1.19.0 → 1.29.0

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

@@ -13,24 +13,21 @@ Prism.languages.eiffel = {
 		},
 		// Single-line string
 		{
-			pattern: /"(?:%\s+%|%.|[^%"\r\n])*"/,
+			pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
 			greedy: true
 		}
 	],
 	// normal char | special char | char code
 	'char': /'(?:%.|[^%'\r\n])+'/,
-	'keyword': /\b(?:across|agent|alias|all|and|attached|as|assign|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
-	'boolean': /\b(?:True|False)\b/i,
+	'keyword': /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
+	'boolean': /\b(?:False|True)\b/i,
 	// Convention: class-names are always all upper-case characters
-	'class-name': {
-		'pattern': /\b[A-Z][\dA-Z_]*\b/,
-		'alias': 'builtin'
-	},
+	'class-name': /\b[A-Z][\dA-Z_]*\b/,
 	'number': [
 		// hexa | octal | bin
 		/\b0[xcb][\da-f](?:_*[\da-f])*\b/i,
 		// Decimal
-		/(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/i
+		/(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
 	],
 	'punctuation': /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
 	'operator': /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/

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

@@ -12,13 +12,15 @@
 		}
 	};
 
-	Prism.hooks.add('before-tokenize', function(env) {
+	Prism.hooks.add('before-tokenize', function (env) {
 		var ejsPattern = /<%(?!%)[\s\S]+?%>/g;
 		Prism.languages['markup-templating'].buildPlaceholders(env, 'ejs', ejsPattern);
 	});
 
-	Prism.hooks.add('after-tokenize', function(env) {
+	Prism.hooks.add('after-tokenize', function (env) {
 		Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs');
 	});
 
+	Prism.languages.eta = Prism.languages.ejs;
+
 }(Prism));

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

@@ -1,5 +1,15 @@
 Prism.languages.elixir = {
-	'comment': /#.*/m,
+	'doc': {
+		pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
+		inside: {
+			'attribute': /^@\w+/,
+			'string': /['"][\s\S]+/
+		}
+	},
+	'comment': {
+		pattern: /#.*/,
+		greedy: true
+	},
 	// ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
 	'regex': {
 		pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
@@ -8,7 +18,7 @@ Prism.languages.elixir = {
 	'string': [
 		{
 			// ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
-			pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
+			pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
 			greedy: true,
 			inside: {
 				// See interpolation below
@@ -36,14 +46,12 @@ Prism.languages.elixir = {
 		lookbehind: true,
 		alias: 'symbol'
 	},
-	// Look-ahead prevents bad highlighting of the :: operator
-	'attr-name': /\w+\??:(?!:)/,
-	'capture': {
-		// Look-behind prevents bad highlighting of the && operator
-		pattern: /(^|[^&])&(?:[^&\s\d()][^\s()]*|(?=\())/,
-		lookbehind: true,
-		alias: 'function'
+	'module': {
+		pattern: /\b[A-Z]\w*\b/,
+		alias: 'class-name'
 	},
+	// Look-ahead prevents bad highlighting of the :: operator
+	'attr-name': /\b\w+\??:(?!:)/,
 	'argument': {
 		// Look-behind prevents bad highlighting of the && operator
 		pattern: /(^|[^&])&\d+/,
@@ -54,9 +62,10 @@ Prism.languages.elixir = {
 		pattern: /@\w+/,
 		alias: 'variable'
 	},
+	'function': /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
 	'number': /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
-	'keyword': /\b(?:after|alias|and|case|catch|cond|def(?:callback|exception|impl|module|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|require|rescue|try|unless|use|when)\b/,
-	'boolean': /\b(?:true|false|nil)\b/,
+	'keyword': /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
+	'boolean': /\b(?:false|nil|true)\b/,
 	'operator': [
 		/\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
 		{
@@ -73,7 +82,7 @@ Prism.languages.elixir = {
 	'punctuation': /<<|>>|[.,%\[\]{}()]/
 };
 
-Prism.languages.elixir.string.forEach(function(o) {
+Prism.languages.elixir.string.forEach(function (o) {
 	o.inside = {
 		'interpolation': {
 			pattern: /#\{[^}]+\}/,

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

@@ -1,34 +1,35 @@
 Prism.languages.elm = {
-	comment: /--.*|{-[\s\S]*?-}/,
-	char: {
-		pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+))'/,
+	'comment': /--.*|\{-[\s\S]*?-\}/,
+	'char': {
+		pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
 		greedy: true
 	},
-	string: [
+	'string': [
 		{
 			// Multiline strings are wrapped in triple ". Quotes may appear unescaped.
 			pattern: /"""[\s\S]*?"""/,
 			greedy: true
 		},
 		{
-			pattern: /"(?:[^\\"\r\n]|\\(?:[abfnrtv\\"]|\d+|x[0-9a-fA-F]+))*"/,
+			pattern: /"(?:[^\\"\r\n]|\\.)*"/,
 			greedy: true
 		}
 	],
-	import_statement: {
+	'import-statement': {
 		// The imported or hidden names are not included in this import
 		// statement. This is because we want to highlight those exactly like
 		// we do for the names in the program.
-		pattern: /^\s*import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
+		pattern: /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
+		lookbehind: true,
 		inside: {
-			keyword: /\b(?:import|as|exposing)\b/
+			'keyword': /\b(?:as|exposing|import)\b/
 		}
 	},
-	keyword: /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
+	'keyword': /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
 	// These are builtin variables only. Constructors are highlighted later as a constant.
-	builtin: /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
+	'builtin': /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
 	// decimal integers and floating point numbers | hexadecimal integers
-	number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
+	'number': /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
 	// Most of this is needed because of the meaning of a single '.'.
 	// If it stands alone freely, it is the function composition.
 	// It may also be a separator between a module name and an identifier => no
@@ -36,9 +37,9 @@ Prism.languages.elm = {
 	// operator too.
 	// Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!
 	// Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ
-	operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
+	'operator': /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
 	// In Elm, nearly everything is a variable, do not highlight these.
-	hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
-	constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
-	punctuation: /[{}[\]|(),.:]/
+	'hvariable': /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
+	'constant': /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
+	'punctuation': /[{}[\]|(),.:]/
 };

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

@@ -1,19 +1,24 @@
 (function (Prism) {
 
-	Prism.languages.erb = Prism.languages.extend('ruby', {});
-	Prism.languages.insertBefore('erb', 'comment', {
+	Prism.languages.erb = {
 		'delimiter': {
-			pattern: /^<%=?|%>$/,
+			pattern: /^(\s*)<%=?|%>(?=\s*$)/,
+			lookbehind: true,
 			alias: 'punctuation'
+		},
+		'ruby': {
+			pattern: /\s*\S[\s\S]*/,
+			alias: 'language-ruby',
+			inside: Prism.languages.ruby
 		}
-	});
+	};
 
-	Prism.hooks.add('before-tokenize', function(env) {
-		var erbPattern = /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s[\s\S]*?^=end)+?%>/gm;
+	Prism.hooks.add('before-tokenize', function (env) {
+		var erbPattern = /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
 		Prism.languages['markup-templating'].buildPlaceholders(env, 'erb', erbPattern);
 	});
 
-	Prism.hooks.add('after-tokenize', function(env) {
+	Prism.hooks.add('after-tokenize', function (env) {
 		Prism.languages['markup-templating'].tokenizePlaceholders(env, 'erb');
 	});
 

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

@@ -12,12 +12,12 @@ Prism.languages.erlang = {
 		pattern: /'(?:\\.|[^\\'\r\n])+'/,
 		alias: 'atom'
 	},
-	'boolean': /\b(?:true|false)\b/,
-	'keyword': /\b(?:fun|when|case|of|end|if|receive|after|try|catch)\b/,
+	'boolean': /\b(?:false|true)\b/,
+	'keyword': /\b(?:after|begin|case|catch|end|fun|if|of|receive|try|when)\b/,
 	'number': [
 		/\$\\?./,
-		/\d+#[a-z0-9]+/i,
-		/(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i
+		/\b\d+#[a-z0-9]+/i,
+		/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
 	],
 	'function': /\b[a-z][\w@]*(?=\()/,
 	'variable': {
@@ -26,7 +26,7 @@ Prism.languages.erlang = {
 		lookbehind: true
 	},
 	'operator': [
-		/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:bnot|div|rem|band|bor|bxor|bsl|bsr|not|and|or|xor|orelse|andalso)\b/,
+		/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
 		{
 			// We don't want to match <<
 			pattern: /(^|[^<])<(?!<)/,
@@ -41,4 +41,4 @@ Prism.languages.erlang = {
 	'atom': /\b[a-z][\w@]*/,
 	'punctuation': /[()[\]{}:;,.#|]|<<|>>/
 
-};
+};

data/vendor/assets/javascripts/languages/prism-excel-formula.js

@@ -0,0 +1,66 @@
+Prism.languages['excel-formula'] = {
+	'comment': {
+		pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
+		lookbehind: true,
+		greedy: true
+	},
+	'string': {
+		pattern: /"(?:[^"]|"")*"(?!")/,
+		greedy: true
+	},
+	'reference': {
+		// https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/
+
+		// Sales!B2
+		// 'Winter sales'!B2
+		// [Sales.xlsx]Jan!B2:B5
+		// D:\Reports\[Sales.xlsx]Jan!B2:B5
+		// '[Sales.xlsx]Jan sales'!B2:B5
+		// 'D:\Reports\[Sales.xlsx]Jan sales'!B2:B5
+
+		pattern: /(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,
+		greedy: true,
+		alias: 'string',
+		inside: {
+			'operator': /!$/,
+			'punctuation': /'/,
+			'sheet': {
+				pattern: /[^[\]]+$/,
+				alias: 'function'
+			},
+			'file': {
+				pattern: /\[[^[\]]+\]$/,
+				inside: {
+					'punctuation': /[[\]]/
+				}
+			},
+			'path': /[\s\S]+/
+		}
+	},
+	'function-name': {
+		pattern: /\b[A-Z]\w*(?=\()/i,
+		alias: 'builtin'
+	},
+	'range': {
+		pattern: /\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,
+		alias: 'selector',
+		inside: {
+			'operator': /:/,
+			'cell': /\$?[A-Z]+\$?\d+/i,
+			'column': /\$?[A-Z]+/i,
+			'row': /\$?\d+/
+		}
+	},
+	'cell': {
+		// Excel is case insensitive, so the string "foo1" could be either a variable or a cell.
+		// To combat this, we match cells case insensitive, if the contain at least one "$", and case sensitive otherwise.
+		pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,
+		alias: 'selector'
+	},
+	'number': /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,
+	'boolean': /\b(?:FALSE|TRUE)\b/i,
+	'operator': /[-+*/^%=&,]|<[=>]?|>=?/,
+	'punctuation': /[[\]();{}|]/
+};
+
+Prism.languages['xlsx'] = Prism.languages['xls'] = Prism.languages['excel-formula'];

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

@@ -1,7 +1,7 @@
 (function (Prism) {
 
 	var comment_inside = {
-		'function': /\b(?:TODOS?|FIX(?:MES?)?|NOTES?|BUGS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/
+		'function': /\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/
 	};
 	var string_inside = {
 		'number': /\\[^\s']|%\w/
@@ -84,7 +84,7 @@
 
 		// R/ regexp?\/\\/
 		'regexp': {
-			pattern: /(^|\s)R\/\s+(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,
+			pattern: /(^|\s)R\/\s(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,
 			lookbehind: true,
 			alias: 'number',
 			inside: {
@@ -124,7 +124,7 @@
 					'number': string_inside.number,
 					// trailing semicolon on its own line
 					'semicolon-or-setlocal': {
-						pattern: /((?:\n|\r\n)\s*);(?=\s|$)/,
+						pattern: /([\r\n][ \t]*);(?=\s|$)/,
 						lookbehind: true,
 						alias: 'function'
 					}
@@ -182,7 +182,7 @@
 		'stack-effect-delimiter': [
 			{
 				// opening parenthesis
-				pattern: /(^|\s)(?:call|execute|eval)?\((?=\s)/,
+				pattern: /(^|\s)(?:call|eval|execute)?\((?=\s)/,
 				lookbehind: true,
 				alias: 'operator'
 			},
@@ -265,7 +265,7 @@
 			see <https://docs.factorcode.org/content/article-conventions.html>
 		*/
 		'conventionally-named-word': {
-			pattern: /(^|\s)(?!")(?:(?:set|change|with|new)-\S+|\$\S+|>[^>\s]+|[^:>\s]+>|[^>\s]+>[^>\s]+|\+[^+\s]+\+|[^?\s]+\?|\?[^?\s]+|[^>\s]+>>|>>[^>\s]+|[^<\s]+<<|\([^()\s]+\)|[^!\s]+!|[^*\s]\S*\*|[^.\s]\S*\.)(?=\s|$)/,
+			pattern: /(^|\s)(?!")(?:(?:change|new|set|with)-\S+|\$\S+|>[^>\s]+|[^:>\s]+>|[^>\s]+>[^>\s]+|\+[^+\s]+\+|[^?\s]+\?|\?[^?\s]+|[^>\s]+>>|>>[^>\s]+|[^<\s]+<<|\([^()\s]+\)|[^!\s]+!|[^*\s]\S*\*|[^.\s]\S*\.)(?=\s|$)/,
 			lookbehind: true,
 			alias: 'keyword'
 		},
@@ -346,7 +346,7 @@
 	};
 
 	var escape = function (str) {
-		return (str+'').replace(/([.?*+\^$\[\]\\(){}|\-])/g, '\\$1');
+		return (str + '').replace(/([.?*+\^$\[\]\\(){}|\-])/g, '\\$1');
 	};
 
 	var arrToWordsRegExp = function (arr) {
@@ -375,7 +375,7 @@
 	};
 
 	Object.keys(builtins).forEach(function (k) {
-		factor[k].pattern = arrToWordsRegExp( builtins[k] );
+		factor[k].pattern = arrToWordsRegExp(builtins[k]);
 	});
 
 	var combinators = [
@@ -400,4 +400,4 @@
 
 	Prism.languages.factor = factor;
 
-})(Prism);
+}(Prism));

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

@@ -0,0 +1,32 @@
+(function (Prism) {
+	/**
+	 * Based on the manual by Wouter van Oortmerssen.
+	 *
+	 * @see {@link https://github.com/PrismJS/prism/issues/2801#issue-829717504}
+	 */
+	Prism.languages['false'] = {
+		'comment': {
+			pattern: /\{[^}]*\}/
+		},
+		'string': {
+			pattern: /"[^"]*"/,
+			greedy: true
+		},
+		'character-code': {
+			pattern: /'(?:[^\r]|\r\n?)/,
+			alias: 'number'
+		},
+		'assembler-code': {
+			pattern: /\d+`/,
+			alias: 'important'
+		},
+		'number': /\d+/,
+		'operator': /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
+		'punctuation': /\[|\]/,
+		'variable': /[a-z]/,
+		'non-standard': {
+			pattern: /[()<BDO®]/,
+			alias: 'bold'
+		}
+	};
+}(Prism));

data/vendor/assets/javascripts/languages/prism-firestore-security-rules.js

@@ -1,7 +1,7 @@
 Prism.languages['firestore-security-rules'] = Prism.languages.extend('clike', {
 	'comment': /\/\/.*/,
 	'keyword': /\b(?:allow|function|if|match|null|return|rules_version|service)\b/,
-	'operator': /&&|\|\||[<>!=]=?|[-+*/%=]|\b(?:in|is)\b/,
+	'operator': /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/,
 });
 
 delete Prism.languages['firestore-security-rules']['class-name'];
@@ -20,7 +20,7 @@ Prism.languages.insertBefore('firestore-security-rules', 'keyword', {
 					'punctuation': /[.$(){}]/
 				}
 			},
-			'punctuation': /[/]/
+			'punctuation': /\//
 		}
 	},
 	'method': {

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

@@ -4,12 +4,12 @@
 	Prism.languages.insertBefore('flow', 'keyword', {
 		'type': [
 			{
-				pattern: /\b(?:[Nn]umber|[Ss]tring|[Bb]oolean|Function|any|mixed|null|void)\b/,
-				alias: 'tag'
+				pattern: /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|[Ss]ymbol|any|mixed|null|void)\b/,
+				alias: 'class-name'
 			}
 		]
 	});
-	Prism.languages.flow['function-variable'].pattern = /[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/i;
+	Prism.languages.flow['function-variable'].pattern = /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i;
 	delete Prism.languages.flow['parameter'];
 
 	Prism.languages.insertBefore('flow', 'operator', {
@@ -24,11 +24,11 @@
 	}
 	Prism.languages.flow.keyword.unshift(
 		{
-			pattern: /(^|[^$]\b)(?:type|opaque|declare|Class)\b(?!\$)/,
+			pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/,
 			lookbehind: true
 		},
 		{
-			pattern: /(^|[^$]\B)\$(?:await|Diff|Exact|Keys|ObjMap|PropertyType|Shape|Record|Supertype|Subtype|Enum)\b(?!\$)/,
+			pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/,
 			lookbehind: true
 		}
 	);

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

@@ -4,7 +4,7 @@ Prism.languages.fortran = {
 		alias: 'number'
 	},
 	'string': {
-		pattern: /(?:\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:\s*!.+(?:\r\n?|\n))?|(?!\1).)*(?:\1|&)/,
+		pattern: /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
 		inside: {
 			'comment': {
 				pattern: /(&(?:\r\n?|\n)\s*)!.*/,
@@ -16,20 +16,20 @@ Prism.languages.fortran = {
 		pattern: /!.*/,
 		greedy: true
 	},
-	'boolean': /\.(?:TRUE|FALSE)\.(?:_\w+)?/i,
+	'boolean': /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
 	'number': /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
 	'keyword': [
 		// Types
-		/\b(?:INTEGER|REAL|DOUBLE ?PRECISION|COMPLEX|CHARACTER|LOGICAL)\b/i,
+		/\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i,
 		// END statements
 		/\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i,
 		// Statements
 		/\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i,
 		// Others
-		/\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEWHERE|ELSEIF|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
+		/\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
 	],
 	'operator': [
-		/\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.(?:EQ|NE|LT|LE|GT|GE|NOT|AND|OR|EQV|NEQV)\.|\.[A-Z]+\./i,
+		/\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
 		{
 			// Use lookbehind to prevent confusion with (/ /)
 			pattern: /(^|(?!\().)\/(?!\))/,
@@ -37,4 +37,4 @@ Prism.languages.fortran = {
 		}
 	],
 	'punctuation': /\(\/|\/\)|[(),;:&]/
-};
+};

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

@@ -1,16 +1,18 @@
 Prism.languages.fsharp = Prism.languages.extend('clike', {
 	'comment': [
 		{
-			pattern: /(^|[^\\])\(\*[\s\S]*?\*\)/,
-			lookbehind: true
+			pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
+			lookbehind: true,
+			greedy: true
 		},
 		{
 			pattern: /(^|[^\\:])\/\/.*/,
-			lookbehind: true
+			lookbehind: true,
+			greedy: true
 		}
 	],
 	'string': {
-		pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?|'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
+		pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/,
 		greedy: true
 	},
 	'class-name': {
@@ -21,22 +23,23 @@ Prism.languages.fsharp = Prism.languages.extend('clike', {
 			'punctuation': /\./
 		}
 	},
-	'keyword': /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|assert|base|begin|class|default|delegate|do|done|downcast|downto|elif|else|end|exception|extern|false|finally|for|fun|function|global|if|in|inherit|inline|interface|internal|lazy|match|member|module|mutable|namespace|new|not|null|of|open|or|override|private|public|rec|select|static|struct|then|to|true|try|type|upcast|val|void|when|while|with|asr|land|lor|lsl|lsr|lxor|mod|sig|atomic|break|checked|component|const|constraint|constructor|continue|eager|event|external|fixed|functor|include|method|mixin|object|parallel|process|protected|pure|sealed|tailcall|trait|virtual|volatile)\b/,
+	'keyword': /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/,
 	'number': [
-		/\b0x[\da-fA-F]+(?:un|lf|LF)?\b/,
-		/\b0b[01]+(?:y|uy)?\b/,
-		/(?:\b\d+\.?\d*|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
-		/\b\d+(?:[IlLsy]|u[lsy]?|UL)?\b/
+		/\b0x[\da-fA-F]+(?:LF|lf|un)?\b/,
+		/\b0b[01]+(?:uy|y)?\b/,
+		/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
+		/\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
 	],
 	'operator': /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
 });
 Prism.languages.insertBefore('fsharp', 'keyword', {
 	'preprocessor': {
-		pattern: /^[^\r\n\S]*#.*/m,
+		pattern: /(^[\t ]*)#.*/m,
+		lookbehind: true,
 		alias: 'property',
 		inside: {
 			'directive': {
-				pattern: /(\s*#)\b(?:else|endif|if|light|line|nowarn)\b/,
+				pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/,
 				lookbehind: true,
 				alias: 'keyword'
 			}
@@ -45,13 +48,14 @@ Prism.languages.insertBefore('fsharp', 'keyword', {
 });
 Prism.languages.insertBefore('fsharp', 'punctuation', {
 	'computation-expression': {
-		pattern: /[_a-z]\w*(?=\s*\{)/i,
+		pattern: /\b[_a-z]\w*(?=\s*\{)/i,
 		alias: 'keyword'
 	}
 });
 Prism.languages.insertBefore('fsharp', 'string', {
 	'annotation': {
 		pattern: /\[<.+?>\]/,
+		greedy: true,
 		inside: {
 			'punctuation': /^\[<|>\]$/,
 			'class-name': {
@@ -63,5 +67,9 @@ Prism.languages.insertBefore('fsharp', 'string', {
 				inside: Prism.languages.fsharp
 			}
 		}
+	},
+	'char': {
+		pattern: /'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
+		greedy: true
 	}
 });

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

@@ -3,11 +3,11 @@
 	// https://freemarker.apache.org/docs/dgui_template_exp.html
 
 	// FTL expression with 4 levels of nesting supported
-	var FTL_EXPR = /(?!<#--)[^()"']|\((?:<expr>)*\)|<#--[\s\S]*?-->|"(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'/.source;
+	var FTL_EXPR = /[^<()"']|\((?:<expr>)*\)|<(?!#--)|<#--(?:[^-]|-(?!->))*-->|"(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'/.source;
 	for (var i = 0; i < 2; i++) {
-		FTL_EXPR = FTL_EXPR.replace(/<expr>/g, FTL_EXPR);
+		FTL_EXPR = FTL_EXPR.replace(/<expr>/g, function () { return FTL_EXPR; });
 	}
-	FTL_EXPR = FTL_EXPR.replace(/<expr>/g, '[^\s\S]');
+	FTL_EXPR = FTL_EXPR.replace(/<expr>/g, /[^\s\S]/.source);
 
 	var ftl = {
 		'comment': /<#--[\s\S]*?-->/,
@@ -18,11 +18,11 @@
 				greedy: true
 			},
 			{
-				pattern: RegExp(/("|')(?:(?!\1|\$\{)[^\\]|\\.|\$\{(?:<expr>)*?\})*\1/.source.replace(/<expr>/g, FTL_EXPR)),
+				pattern: RegExp(/("|')(?:(?!\1|\$\{)[^\\]|\\.|\$\{(?:(?!\})(?:<expr>))*\})*\1/.source.replace(/<expr>/g, function () { return FTL_EXPR; })),
 				greedy: true,
 				inside: {
 					'interpolation': {
-						pattern: RegExp(/((?:^|[^\\])(?:\\\\)*)\$\{(?:<expr>)*?\}/.source.replace(/<expr>/g, FTL_EXPR)),
+						pattern: RegExp(/((?:^|[^\\])(?:\\\\)*)\$\{(?:(?!\})(?:<expr>))*\}/.source.replace(/<expr>/g, function () { return FTL_EXPR; })),
 						lookbehind: true,
 						inside: {
 							'interpolation-punctuation': {
@@ -36,14 +36,14 @@
 			}
 		],
 		'keyword': /\b(?:as)\b/,
-		'boolean': /\b(?:true|false)\b/,
+		'boolean': /\b(?:false|true)\b/,
 		'builtin-function': {
 			pattern: /((?:^|[^?])\?\s*)\w+/,
 			lookbehind: true,
 			alias: 'function'
 		},
-		'function': /\w+(?=\s*\()/,
-		'number': /\d+(?:\.\d+)?/,
+		'function': /\b\w+(?=\s*\()/,
+		'number': /\b\d+(?:\.\d+)?\b/,
 		'operator': /\.\.[<*!]?|->|--|\+\+|&&|\|\||\?{1,2}|[-+*/%!=<>]=?|\b(?:gt|gte|lt|lte)\b/,
 		'punctuation': /[,;.:()[\]{}]/
 	};
@@ -66,7 +66,7 @@
 				},
 				'punctuation': /^<\/?|\/?>$/,
 				'content': {
-					pattern: /[\s\S]*\S[\s\S]*/,
+					pattern: /\s*\S[\s\S]*/,
 					alias: 'ftl',
 					inside: ftl
 				}
@@ -77,7 +77,7 @@
 			inside: {
 				'punctuation': /^\$\{|\}$/,
 				'content': {
-					pattern: /[\s\S]*\S[\s\S]*/,
+					pattern: /\s*\S[\s\S]*/,
 					alias: 'ftl',
 					inside: ftl
 				}
@@ -86,7 +86,8 @@
 	};
 
 	Prism.hooks.add('before-tokenize', function (env) {
-		var pattern = RegExp(/<#--[\s\S]*?-->|<\/?[#@][a-zA-Z](?:<expr>)*?>|\$\{(?:<expr>)*?\}/.source.replace(/<expr>/g, FTL_EXPR), 'gi');
+		// eslint-disable-next-line regexp/no-useless-lazy
+		var pattern = RegExp(/<#--[\s\S]*?-->|<\/?[#@][a-zA-Z](?:<expr>)*?>|\$\{(?:<expr>)*?\}/.source.replace(/<expr>/g, function () { return FTL_EXPR; }), 'gi');
 		Prism.languages['markup-templating'].buildPlaceholders(env, 'ftl', pattern);
 	});