prism-rails 1.19.0 → 1.29.0

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

@@ -1,25 +1,148 @@
-// issues: nested multiline comments
-Prism.languages.swift = Prism.languages.extend('clike', {
-	'string': {
-		pattern: /("|')(?:\\(?:\((?:[^()]|\([^)]+\))+\)|\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-		greedy: true,
-		inside: {
-			'interpolation': {
-				pattern: /\\\((?:[^()]|\([^)]+\))+\)/,
-				inside: {
-					delimiter: {
-						pattern: /^\\\(|\)$/,
-						alias: 'variable'
-					}
-					// See rest below
-				}
+Prism.languages.swift = {
+	'comment': {
+		// Nested comments are supported up to 2 levels
+		pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+		lookbehind: true,
+		greedy: true
+	},
+	'string-literal': [
+		// https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
+		{
+			pattern: RegExp(
+				/(^|[^"#])/.source
+				+ '(?:'
+				// single-line string
+				+ /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source
+				+ '|'
+				// multi-line string
+				+ /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source
+				+ ')'
+				+ /(?!["#])/.source
+			),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				'interpolation': {
+					pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+					lookbehind: true,
+					inside: null // see below
+				},
+				'interpolation-punctuation': {
+					pattern: /^\)|\\\($/,
+					alias: 'punctuation'
+				},
+				'punctuation': /\\(?=[\r\n])/,
+				'string': /[\s\S]+/
+			}
+		},
+		{
+			pattern: RegExp(
+				/(^|[^"#])(#+)/.source
+				+ '(?:'
+				// single-line string
+				+ /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source
+				+ '|'
+				// multi-line string
+				+ /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source
+				+ ')'
+				+ '\\2'
+			),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				'interpolation': {
+					pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+					lookbehind: true,
+					inside: null // see below
+				},
+				'interpolation-punctuation': {
+					pattern: /^\)|\\#+\($/,
+					alias: 'punctuation'
+				},
+				'string': /[\s\S]+/
 			}
+		},
+	],
+
+	'directive': {
+		// directives with conditions
+		pattern: RegExp(
+			/#/.source
+			+ '(?:'
+			+ (
+				/(?:elseif|if)\b/.source
+				+ '(?:[ \t]*'
+				// This regex is a little complex. It's equivalent to this:
+				//   (?:![ \t]*)?(?:\b\w+\b(?:[ \t]*<round>)?|<round>)(?:[ \t]*(?:&&|\|\|))?
+				// where <round> is a general parentheses expression.
+				+ /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source
+				+ ')+'
+			)
+			+ '|'
+			+ /(?:else|endif)\b/.source
+			+ ')'
+		),
+		alias: 'property',
+		inside: {
+			'directive-name': /^#\w+/,
+			'boolean': /\b(?:false|true)\b/,
+			'number': /\b\d+(?:\.\d+)*\b/,
+			'operator': /!|&&|\|\||[<>]=?/,
+			'punctuation': /[(),]/
 		}
 	},
-	'keyword': /\b(?:as|associativity|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic(?:Type)?|else|enum|extension|fallthrough|final|for|func|get|guard|if|import|in|infix|init|inout|internal|is|lazy|left|let|mutating|new|none|nonmutating|operator|optional|override|postfix|precedence|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|Self|set|static|struct|subscript|super|switch|throws?|try|Type|typealias|unowned|unsafe|var|weak|where|while|willSet|__(?:COLUMN__|FILE__|FUNCTION__|LINE__))\b/,
+	'literal': {
+		pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+		alias: 'constant'
+	},
+	'other-directive': {
+		pattern: /#\w+\b/,
+		alias: 'property'
+	},
+
+	'attribute': {
+		pattern: /@\w+/,
+		alias: 'atrule'
+	},
+
+	'function-definition': {
+		pattern: /(\bfunc\s+)\w+/,
+		lookbehind: true,
+		alias: 'function'
+	},
+	'label': {
+		// https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
+		pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+		lookbehind: true,
+		alias: 'important'
+	},
+
+	'keyword': /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+	'boolean': /\b(?:false|true)\b/,
+	'nil': {
+		pattern: /\bnil\b/,
+		alias: 'constant'
+	},
+
+	'short-argument': /\$\d+\b/,
+	'omit': {
+		pattern: /\b_\b/,
+		alias: 'keyword'
+	},
 	'number': /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
-	'constant': /\b(?:nil|[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
-	'atrule': /@\b(?:IB(?:Outlet|Designable|Action|Inspectable)|class_protocol|exported|noreturn|NS(?:Copying|Managed)|objc|UIApplicationMain|auto_closure)\b/,
-	'builtin': /\b(?:[A-Z]\S+|abs|advance|alignof(?:Value)?|assert|contains|count(?:Elements)?|debugPrint(?:ln)?|distance|drop(?:First|Last)|dump|enumerate|equal|filter|find|first|getVaList|indices|isEmpty|join|last|lexicographicalCompare|map|max(?:Element)?|min(?:Element)?|numericCast|overlaps|partition|print(?:ln)?|reduce|reflect|reverse|sizeof(?:Value)?|sort(?:ed)?|split|startsWith|stride(?:of(?:Value)?)?|suffix|swap|toDebugString|toString|transcode|underestimateCount|unsafeBitCast|with(?:ExtendedLifetime|Unsafe(?:MutablePointers?|Pointers?)|VaList))\b/
+
+	// A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
+	'class-name': /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+	'function': /\b[a-z_]\w*(?=\s*\()/i,
+	'constant': /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+
+	// Operators are generic in Swift. Developers can even create new operators (e.g. +++).
+	// https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
+	// This regex only supports ASCII operators.
+	'operator': /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+	'punctuation': /[{}[\]();,.:\\]/
+};
+
+Prism.languages.swift['string-literal'].forEach(function (rule) {
+	rule.inside['interpolation'].inside = Prism.languages.swift;
 });
-Prism.languages.swift['string'].inside['interpolation'].inside.rest = Prism.languages.swift;

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

@@ -0,0 +1,74 @@
+// https://www.freedesktop.org/software/systemd/man/systemd.syntax.html
+
+(function (Prism) {
+
+	var comment = {
+		pattern: /^[;#].*/m,
+		greedy: true
+	};
+
+	var quotesSource = /"(?:[^\r\n"\\]|\\(?:[^\r]|\r\n?))*"(?!\S)/.source;
+
+	Prism.languages.systemd = {
+		'comment': comment,
+
+		'section': {
+			pattern: /^\[[^\n\r\[\]]*\](?=[ \t]*$)/m,
+			greedy: true,
+			inside: {
+				'punctuation': /^\[|\]$/,
+				'section-name': {
+					pattern: /[\s\S]+/,
+					alias: 'selector'
+				},
+			}
+		},
+
+		'key': {
+			pattern: /^[^\s=]+(?=[ \t]*=)/m,
+			greedy: true,
+			alias: 'attr-name'
+		},
+		'value': {
+			// This pattern is quite complex because of two properties:
+			//  1) Quotes (strings) must be preceded by a space. Since we can't use lookbehinds, we have to "resolve"
+			//     the lookbehind. You will see this in the main loop where spaces are handled separately.
+			//  2) Line continuations.
+			//     After line continuations, empty lines and comments are ignored so we have to consume them.
+			pattern: RegExp(
+				/(=[ \t]*(?!\s))/.source +
+				// the value either starts with quotes or not
+				'(?:' + quotesSource + '|(?=[^"\r\n]))' +
+				// main loop
+				'(?:' + (
+					/[^\s\\]/.source +
+					// handle spaces separately because of quotes
+					'|' + '[ \t]+(?:(?![ \t"])|' + quotesSource + ')' +
+					// line continuation
+					'|' + /\\[\r\n]+(?:[#;].*[\r\n]+)*(?![#;])/.source
+				) +
+				')*'
+			),
+			lookbehind: true,
+			greedy: true,
+			alias: 'attr-value',
+			inside: {
+				'comment': comment,
+				'quoted': {
+					pattern: RegExp(/(^|\s)/.source + quotesSource),
+					lookbehind: true,
+					greedy: true,
+				},
+				'punctuation': /\\$/m,
+
+				'boolean': {
+					pattern: /^(?:false|no|off|on|true|yes)$/,
+					greedy: true
+				}
+			}
+		},
+
+		'punctuation': /=/
+	};
+
+}(Prism));

data/vendor/assets/javascripts/languages/prism-t4-templating.js

@@ -33,8 +33,8 @@
 								'punctuation': /^=|^["']|["']$/
 							}
 						},
-						'keyword': /\w+(?=\s)/,
-						'attr-name': /\w+/
+						'keyword': /\b\w+(?=\s)/,
+						'attr-name': /\b\w+/
 					}),
 					'expression': createBlock('=', grammar, className),
 					'class-feature': createBlock('\\+', grammar, className),

data/vendor/assets/javascripts/languages/prism-t4-vb.js

@@ -1 +1 @@
-Prism.languages['t4-vb'] = Prism.languages['t4-templating'].createT4('visual-basic');
+Prism.languages['t4-vb'] = Prism.languages['t4-templating'].createT4('vbnet');

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

@@ -1,18 +1,20 @@
+// https://en.wikipedia.org/wiki/Test_Anything_Protocol
+
 Prism.languages.tap = {
-	fail: /not ok[^#{\n\r]*/,
-	pass: /ok[^#{\n\r]*/,
-	pragma: /pragma [+-][a-z]+/,
-	bailout: /bail out!.*/i,
-	version: /TAP version \d+/i,
-	plan: /\d+\.\.\d+(?: +#.*)?/,
-	subtest: {
+	'fail': /not ok[^#{\n\r]*/,
+	'pass': /ok[^#{\n\r]*/,
+	'pragma': /pragma [+-][a-z]+/,
+	'bailout': /bail out!.*/i,
+	'version': /TAP version \d+/i,
+	'plan': /\b\d+\.\.\d+(?: +#.*)?/,
+	'subtest': {
 		pattern: /# Subtest(?:: .*)?/,
 		greedy: true
 	},
-	punctuation: /[{}]/,
-	directive: /#.*/,
-	yamlish: {
-		pattern: /(^[^\S\r\n]*)---(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?[^\S\r\n]*\.\.\.$/m,
+	'punctuation': /[{}]/,
+	'directive': /#.*/,
+	'yamlish': {
+		pattern: /(^[ \t]*)---[\s\S]*?[\r\n][ \t]*\.\.\.$/m,
 		lookbehind: true,
 		inside: Prism.languages.yaml,
 		alias: 'language-yaml'

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

@@ -13,34 +13,34 @@ Prism.languages.tcl = {
 			lookbehind: true
 		},
 		{
-			pattern: /(\$){[^}]+}/,
+			pattern: /(\$)\{[^}]+\}/,
 			lookbehind: true
 		},
 		{
-			pattern: /(^\s*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
+			pattern: /(^[\t ]*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
 			lookbehind: true
 		}
 	],
 	'function': {
-		pattern: /(^\s*proc[ \t]+)[^\s]+/m,
+		pattern: /(^[\t ]*proc[ \t]+)\S+/m,
 		lookbehind: true
 	},
 	'builtin': [
 		{
-			pattern: /(^\s*)(?:proc|return|class|error|eval|exit|for|foreach|if|switch|while|break|continue)\b/m,
+			pattern: /(^[\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\b/m,
 			lookbehind: true
 		},
-		/\b(?:elseif|else)\b/
+		/\b(?:else|elseif)\b/
 	],
 	'scope': {
-		pattern: /(^\s*)(?:global|upvar|variable)\b/m,
+		pattern: /(^[\t ]*)(?:global|upvar|variable)\b/m,
 		lookbehind: true,
 		alias: 'constant'
 	},
 	'keyword': {
-		pattern: /(^\s*|\[)(?:after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|Safe_Base|scan|seek|set|socket|source|split|string|subst|Tcl|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|wordBreak(?:After|Before)|test|vars)|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
+		pattern: /(^[\t ]*|\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
 		lookbehind: true
 	},
-	'operator': /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|ne|in|ni)\b/,
+	'operator': /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|in|ne|ni)\b/,
 	'punctuation': /[{}()\[\]]/
 };

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

@@ -1,21 +1,36 @@
 (function (Prism) {
 	// We don't allow for pipes inside parentheses
 	// to not break table pattern |(. foo |). bar |
-	var modifierRegex = /(?:\([^|)]+\)|\[[^\]]+\]|\{[^}]+\})+/.source;
+	var modifierRegex = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source;
+	// Opening and closing parentheses which are not a modifier
+	// This pattern is necessary to prevent exponential backtracking
+	var parenthesesRegex = /\)|\((?![^|()\n]+\))/.source;
+	/**
+	 * @param {string} source
+	 * @param {string} [flags]
+	 */
+	function withModifier(source, flags) {
+		return RegExp(
+			source
+				.replace(/<MOD>/g, function () { return '(?:' + modifierRegex + ')'; })
+				.replace(/<PAR>/g, function () { return '(?:' + parenthesesRegex + ')'; }),
+			flags || '');
+	}
+
 	var modifierTokens = {
 		'css': {
-			pattern: /\{[^}]+\}/,
+			pattern: /\{[^{}]+\}/,
 			inside: {
 				rest: Prism.languages.css
 			}
 		},
 		'class-id': {
-			pattern: /(\()[^)]+(?=\))/,
+			pattern: /(\()[^()]+(?=\))/,
 			lookbehind: true,
 			alias: 'attr-value'
 		},
 		'lang': {
-			pattern: /(\[)[^\]]+(?=\])/,
+			pattern: /(\[)[^\[\]]+(?=\])/,
 			lookbehind: true,
 			alias: 'attr-value'
 		},
@@ -32,10 +47,10 @@
 
 				// h1. Header 1
 				'block-tag': {
-					pattern: RegExp('^[a-z]\\w*(?:' + modifierRegex + '|[<>=()])*\\.'),
+					pattern: withModifier(/^[a-z]\w*(?:<MOD>|<PAR>|[<>=])*\./.source),
 					inside: {
 						'modifier': {
-							pattern: RegExp('(^[a-z]\\w*)(?:' + modifierRegex + '|[<>=()])+(?=\\.)'),
+							pattern: withModifier(/(^[a-z]\w*)(?:<MOD>|<PAR>|[<>=])+(?=\.)/.source),
 							lookbehind: true,
 							inside: modifierTokens
 						},
@@ -47,10 +62,10 @@
 				// # List item
 				// * List item
 				'list': {
-					pattern: RegExp('^[*#]+(?:' + modifierRegex + ')?\\s+.+', 'm'),
+					pattern: withModifier(/^[*#]+<MOD>*\s+\S.*/.source, 'm'),
 					inside: {
 						'modifier': {
-							pattern: RegExp('(^[*#]+)' + modifierRegex),
+							pattern: withModifier(/(^[*#]+)<MOD>+/.source),
 							lookbehind: true,
 							inside: modifierTokens
 						},
@@ -62,12 +77,12 @@
 				'table': {
 					// Modifiers can be applied to the row: {color:red}.|1|2|3|
 					// or the cell: |{color:red}.1|2|3|
-					pattern: RegExp('^(?:(?:' + modifierRegex + '|[<>=()^~])+\\.\\s*)?(?:\\|(?:(?:' + modifierRegex + '|[<>=()^~_]|[\\\\/]\\d+)+\\.)?[^|]*)+\\|', 'm'),
+					pattern: withModifier(/^(?:(?:<MOD>|<PAR>|[<>=^~])+\.\s*)?(?:\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.))[^|]*)+\|/.source, 'm'),
 					inside: {
 						'modifier': {
 							// Modifiers for rows after the first one are
 							// preceded by a pipe and a line feed
-							pattern: RegExp('(^|\\|(?:\\r?\\n|\\r)?)(?:' + modifierRegex + '|[<>=()^~_]|[\\\\/]\\d+)+(?=\\.)'),
+							pattern: withModifier(/(^|\|(?:\r?\n|\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+(?=\.)/.source),
 							lookbehind: true,
 							inside: modifierTokens
 						},
@@ -76,56 +91,65 @@
 				},
 
 				'inline': {
-					pattern: RegExp('(\\*\\*|__|\\?\\?|[*_%@+\\-^~])(?:' + modifierRegex + ')?.+?\\1'),
+					// eslint-disable-next-line regexp/no-super-linear-backtracking
+					pattern: withModifier(/(^|[^a-zA-Z\d])(\*\*|__|\?\?|[*_%@+\-^~])<MOD>*.+?\2(?![a-zA-Z\d])/.source),
+					lookbehind: true,
 					inside: {
 						// Note: superscripts and subscripts are not handled specifically
 
 						// *bold*, **bold**
 						'bold': {
-							pattern: RegExp('(^(\\*\\*?)(?:' + modifierRegex + ')?).+?(?=\\2)'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^(\*\*?)<MOD>*).+?(?=\2)/.source),
 							lookbehind: true
 						},
 
 						// _italic_, __italic__
 						'italic': {
-							pattern: RegExp('(^(__?)(?:' + modifierRegex + ')?).+?(?=\\2)'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^(__?)<MOD>*).+?(?=\2)/.source),
 							lookbehind: true
 						},
 
 						// ??cite??
 						'cite': {
-							pattern: RegExp('(^\\?\\?(?:' + modifierRegex + ')?).+?(?=\\?\\?)'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^\?\?<MOD>*).+?(?=\?\?)/.source),
 							lookbehind: true,
 							alias: 'string'
 						},
 
 						// @code@
 						'code': {
-							pattern: RegExp('(^@(?:' + modifierRegex + ')?).+?(?=@)'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^@<MOD>*).+?(?=@)/.source),
 							lookbehind: true,
 							alias: 'keyword'
 						},
 
 						// +inserted+
 						'inserted': {
-							pattern: RegExp('(^\\+(?:' + modifierRegex + ')?).+?(?=\\+)'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^\+<MOD>*).+?(?=\+)/.source),
 							lookbehind: true
 						},
 
 						// -deleted-
 						'deleted': {
-							pattern: RegExp('(^-(?:' + modifierRegex + ')?).+?(?=-)'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^-<MOD>*).+?(?=-)/.source),
 							lookbehind: true
 						},
 
 						// %span%
 						'span': {
-							pattern: RegExp('(^%(?:' + modifierRegex + ')?).+?(?=%)'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^%<MOD>*).+?(?=%)/.source),
 							lookbehind: true
 						},
 
 						'modifier': {
-							pattern: RegExp('(^\\*\\*|__|\\?\\?|[*_%@+\\-^~])' + modifierRegex),
+							pattern: withModifier(/(^\*\*|__|\?\?|[*_%@+\-^~])<MOD>+/.source),
 							lookbehind: true,
 							inside: modifierTokens
 						},
@@ -138,11 +162,11 @@
 					pattern: /^\[[^\]]+\]\S+$/m,
 					inside: {
 						'string': {
-							pattern: /(\[)[^\]]+(?=\])/,
+							pattern: /(^\[)[^\]]+(?=\])/,
 							lookbehind: true
 						},
 						'url': {
-							pattern: /(\])\S+$/,
+							pattern: /(^\])\S+$/,
 							lookbehind: true
 						},
 						'punctuation': /[\[\]]/
@@ -152,14 +176,16 @@
 				// "text":http://example.com
 				// "text":link-ref
 				'link': {
-					pattern: RegExp('"(?:' + modifierRegex + ')?[^"]+":.+?(?=[^\\w/]?(?:\\s|$))'),
+					// eslint-disable-next-line regexp/no-super-linear-backtracking
+					pattern: withModifier(/"<MOD>*[^"]+":.+?(?=[^\w/]?(?:\s|$))/.source),
 					inside: {
 						'text': {
-							pattern: RegExp('(^"(?:' + modifierRegex + ')?)[^"]+(?=")'),
+							// eslint-disable-next-line regexp/no-super-linear-backtracking
+							pattern: withModifier(/(^"<MOD>*)[^"]+(?=")/.source),
 							lookbehind: true
 						},
 						'modifier': {
-							pattern: RegExp('(^")' + modifierRegex),
+							pattern: withModifier(/(^")<MOD>+/.source),
 							lookbehind: true,
 							inside: modifierTokens
 						},
@@ -174,15 +200,15 @@
 				// !image.jpg!
 				// !image.jpg(Title)!:http://example.com
 				'image': {
-					pattern: RegExp('!(?:' + modifierRegex + '|[<>=()])*[^!\\s()]+(?:\\([^)]+\\))?!(?::.+?(?=[^\\w/]?(?:\\s|$)))?'),
+					pattern: withModifier(/!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\s()]+(?:\([^)]+\))?!(?::.+?(?=[^\w/]?(?:\s|$)))?/.source),
 					inside: {
 						'source': {
-							pattern: RegExp('(^!(?:' + modifierRegex + '|[<>=()])*)[^!\\s()]+(?:\\([^)]+\\))?(?=!)'),
+							pattern: withModifier(/(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\s()]+(?:\([^)]+\))?(?=!)/.source),
 							lookbehind: true,
 							alias: 'url'
 						},
 						'modifier': {
-							pattern: RegExp('(^!)(?:' + modifierRegex + '|[<>=()])+'),
+							pattern: withModifier(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),
 							lookbehind: true,
 							inside: modifierTokens
 						},
@@ -208,7 +234,7 @@
 					pattern: /\b[A-Z\d]+\([^)]+\)/,
 					inside: {
 						'comment': {
-							pattern: /(\()[^)]+(?=\))/,
+							pattern: /(\()[^()]+(?=\))/,
 							lookbehind: true
 						},
 						'punctuation': /[()]/
@@ -217,7 +243,7 @@
 
 				// Prism(C)
 				'mark': {
-					pattern: /\b\((?:TM|R|C)\)/,
+					pattern: /\b\((?:C|R|TM)\)/,
 					alias: 'comment',
 					inside: {
 						'punctuation': /[()]/

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

@@ -1,7 +1,13 @@
 (function (Prism) {
 
-	// pattern: /(?:[\w-]+|'[^'\n\r]*'|"(?:\.|[^\\"\r\n])*")/
-	var key = "(?:[\\w-]+|'[^'\n\r]*'|\"(?:\\.|[^\\\\\"\r\n])*\")";
+	var key = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
+
+	/**
+	 * @param {string} pattern
+	 */
+	function insertKey(pattern) {
+		return pattern.replace(/__/g, function () { return key; });
+	}
 
 	Prism.languages.toml = {
 		'comment': {
@@ -9,13 +15,13 @@
 			greedy: true
 		},
 		'table': {
-			pattern: RegExp("(^\\s*\\[\\s*(?:\\[\\s*)?)" + key + "(?:\\s*\\.\\s*" + key + ")*(?=\\s*\\])", "m"),
+			pattern: RegExp(insertKey(/(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source), 'm'),
 			lookbehind: true,
 			greedy: true,
 			alias: 'class-name'
 		},
 		'key': {
-			pattern: RegExp("(^\\s*|[{,]\\s*)" + key + "(?:\\s*\\.\\s*" + key + ")*(?=\\s*=)", "m"),
+			pattern: RegExp(insertKey(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source), 'm'),
 			lookbehind: true,
 			greedy: true,
 			alias: 'property'
@@ -27,17 +33,17 @@
 		'date': [
 			{
 				// Offset Date-Time, Local Date-Time, Local Date
-				pattern: /\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?/i,
+				pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
 				alias: 'number'
 			},
 			{
 				// Local Time
-				pattern: /\d{2}:\d{2}:\d{2}(?:\.\d+)?/i,
+				pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
 				alias: 'number'
 			}
 		],
-		'number': /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?(?:inf|nan)\b/,
-		'boolean': /\b(?:true|false)\b/,
+		'number': /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
+		'boolean': /\b(?:false|true)\b/,
 		'punctuation': /[.,=[\]{}]/
 	};
 }(Prism));