prism-rails 1.19.0 → 1.29.0

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

@@ -0,0 +1,199 @@
+// Docs:
+// https://docs.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-5.0&tabs=visual-studio
+// https://docs.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-5.0
+
+(function (Prism) {
+
+	var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source;
+	var stringLike =
+		/@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source +
+		'|' +
+		/'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
+
+	/**
+	 * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+	 *
+	 * @param {string} pattern
+	 * @param {number} depthLog2
+	 * @returns {string}
+	 */
+	function nested(pattern, depthLog2) {
+		for (var i = 0; i < depthLog2; i++) {
+			pattern = pattern.replace(/<self>/g, function () { return '(?:' + pattern + ')'; });
+		}
+		return pattern
+			.replace(/<self>/g, '[^\\s\\S]')
+			.replace(/<str>/g, '(?:' + stringLike + ')')
+			.replace(/<comment>/g, '(?:' + commentLike + ')');
+	}
+
+	var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
+	var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 1);
+	var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
+	var angle = nested(/<(?:[^<>'"@/]|<comment>|<self>)*>/.source, 1);
+
+	var inlineCs = /@/.source +
+		/(?:await\b\s*)?/.source +
+		'(?:' + /(?!await\b)\w+\b/.source + '|' + round + ')' +
+		'(?:' + /[?!]?\.\w+\b/.source + '|' + '(?:' + angle + ')?' + round + '|' + square + ')*' +
+		/(?![?!\.(\[]|<(?!\/))/.source;
+
+	// Note about the above bracket patterns:
+	// They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and
+	// comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which
+	// messes up the bracket and string counting implemented by the above patterns.
+	//
+	// This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect
+	// and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the
+	// complexity of an HTML expression.
+	//
+	// To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also
+	// allows invalid characters to support HTML expressions like this: <p>That's it!</p>.
+
+	var tagAttrInlineCs = /@(?![\w()])/.source + '|' + inlineCs;
+	var tagAttrValue = '(?:' +
+		/"[^"@]*"|'[^'@]*'|[^\s'"@>=]+(?=[\s>])/.source +
+		'|' +
+		'["\'][^"\'@]*(?:(?:' + tagAttrInlineCs + ')[^"\'@]*)+["\']' +
+		')';
+
+	var tagAttrs = /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*<tagAttrValue>|(?=[\s/>])))+)?/.source.replace(/<tagAttrValue>/, tagAttrValue);
+	var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
+	var tagRegion =
+		/\B@?/.source +
+		'(?:' +
+		/<([a-zA-Z][\w:]*)/.source + tagAttrs + /\s*>/.source +
+		'(?:' +
+		(
+			/[^<]/.source +
+			'|' +
+			// all tags that are not the start tag
+			// eslint-disable-next-line regexp/strict
+			/<\/?(?!\1\b)/.source + tagContent +
+			'|' +
+			// nested start tag
+			nested(
+				// eslint-disable-next-line regexp/strict
+				/<\1/.source + tagAttrs + /\s*>/.source +
+				'(?:' +
+				(
+					/[^<]/.source +
+					'|' +
+					// all tags that are not the start tag
+					// eslint-disable-next-line regexp/strict
+					/<\/?(?!\1\b)/.source + tagContent +
+					'|' +
+					'<self>'
+				) +
+				')*' +
+				// eslint-disable-next-line regexp/strict
+				/<\/\1\s*>/.source,
+				2
+			)
+		) +
+		')*' +
+		// eslint-disable-next-line regexp/strict
+		/<\/\1\s*>/.source +
+		'|' +
+		/</.source + tagContent +
+		')';
+
+	// Now for the actual language definition(s):
+	//
+	// Razor as a language has 2 parts:
+	//  1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.
+	//  2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.
+	//
+	// In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each
+	// other. However, only CSHTML will be exported via `Prism.languages`.
+
+	Prism.languages.cshtml = Prism.languages.extend('markup', {});
+
+	var csharpWithHtml = Prism.languages.insertBefore('csharp', 'string', {
+		'html': {
+			pattern: RegExp(tagRegion),
+			greedy: true,
+			inside: Prism.languages.cshtml
+		},
+	}, { csharp: Prism.languages.extend('csharp', {}) });
+
+	var cs = {
+		pattern: /\S[\s\S]*/,
+		alias: 'language-csharp',
+		inside: csharpWithHtml
+	};
+
+	var inlineValue = {
+		pattern: RegExp(/(^|[^@])/.source + inlineCs),
+		lookbehind: true,
+		greedy: true,
+		alias: 'variable',
+		inside: {
+			'keyword': /^@/,
+			'csharp': cs
+		}
+	};
+
+	Prism.languages.cshtml.tag.pattern = RegExp(/<\/?/.source + tagContent);
+	Prism.languages.cshtml.tag.inside['attr-value'].pattern = RegExp(/=\s*/.source + tagAttrValue);
+	Prism.languages.insertBefore('inside', 'punctuation', { 'value': inlineValue }, Prism.languages.cshtml.tag.inside['attr-value']);
+
+	Prism.languages.insertBefore('cshtml', 'prolog', {
+		'razor-comment': {
+			pattern: /@\*[\s\S]*?\*@/,
+			greedy: true,
+			alias: 'comment'
+		},
+
+		'block': {
+			pattern: RegExp(
+				/(^|[^@])@/.source +
+				'(?:' +
+				[
+					// @{ ... }
+					curly,
+					// @code{ ... }
+					/(?:code|functions)\s*/.source + curly,
+					// @for (...) { ... }
+					/(?:for|foreach|lock|switch|using|while)\s*/.source + round + /\s*/.source + curly,
+					// @do { ... } while (...);
+					/do\s*/.source + curly + /\s*while\s*/.source + round + /(?:\s*;)?/.source,
+					// @try { ... } catch (...) { ... } finally { ... }
+					/try\s*/.source + curly + /\s*catch\s*/.source + round + /\s*/.source + curly + /\s*finally\s*/.source + curly,
+					// @if (...) {...} else if (...) {...} else {...}
+					/if\s*/.source + round + /\s*/.source + curly + '(?:' + /\s*else/.source + '(?:' + /\s+if\s*/.source + round + ')?' + /\s*/.source + curly + ')*',
+					// @helper Ident(params) { ... }
+					/helper\s+\w+\s*/.source + round + /\s*/.source + curly,
+				].join('|') +
+				')'
+			),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				'keyword': /^@\w*/,
+				'csharp': cs
+			}
+		},
+
+		'directive': {
+			pattern: /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				'keyword': /^@\w+/,
+				'csharp': cs
+			}
+		},
+
+		'value': inlineValue,
+
+		'delegate-operator': {
+			pattern: /(^|[^@])@(?=<)/,
+			lookbehind: true,
+			alias: 'operator'
+		}
+	});
+
+	Prism.languages.razor = Prism.languages.cshtml;
+
+}(Prism));

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

@@ -4,22 +4,73 @@
  * Reference: https://scotthelme.co.uk/csp-cheat-sheet/
  *
  * Supports the following:
- *  - CSP Level 1
- *  - CSP Level 2
- *  - CSP Level 3
+ *  - https://www.w3.org/TR/CSP1/
+ *  - https://www.w3.org/TR/CSP2/
+ *  - https://www.w3.org/TR/CSP3/
  */
 
-Prism.languages.csp = {
-	'directive':  {
-		pattern: /\b(?:(?:base-uri|form-action|frame-ancestors|plugin-types|referrer|reflected-xss|report-to|report-uri|require-sri-for|sandbox) |(?:block-all-mixed-content|disown-opener|upgrade-insecure-requests)(?: |;)|(?:child|connect|default|font|frame|img|manifest|media|object|script|style|worker)-src )/i,
-		alias: 'keyword'
-	},
-	'safe': {
-		pattern: /'(?:self|none|strict-dynamic|(?:nonce-|sha(?:256|384|512)-)[a-zA-Z\d+=/]+)'/,
-		alias: 'selector'
-	},
-	'unsafe': {
-		pattern: /(?:'unsafe-inline'|'unsafe-eval'|'unsafe-hashed-attributes'|\*)/,
-		alias: 'function'
+(function (Prism) {
+
+	/**
+	 * @param {string} source
+	 * @returns {RegExp}
+	 */
+	function value(source) {
+		return RegExp(/([ \t])/.source + '(?:' + source + ')' + /(?=[\s;]|$)/.source, 'i');
 	}
-};
+
+	Prism.languages.csp = {
+		'directive': {
+			pattern: /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
+			lookbehind: true,
+			alias: 'property'
+		},
+		'scheme': {
+			pattern: value(/[a-z][a-z0-9.+-]*:/.source),
+			lookbehind: true
+		},
+		'none': {
+			pattern: value(/'none'/.source),
+			lookbehind: true,
+			alias: 'keyword'
+		},
+		'nonce': {
+			pattern: value(/'nonce-[-+/\w=]+'/.source),
+			lookbehind: true,
+			alias: 'number'
+		},
+		'hash': {
+			pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
+			lookbehind: true,
+			alias: 'number'
+		},
+		'host': {
+			pattern: value(
+				/[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source +
+				'|' +
+				/\*[^\s;,']*/.source +
+				'|' +
+				/[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source
+			),
+			lookbehind: true,
+			alias: 'url',
+			inside: {
+				'important': /\*/
+			}
+		},
+		'keyword': [
+			{
+				pattern: value(/'unsafe-[a-z-]+'/.source),
+				lookbehind: true,
+				alias: 'unsafe'
+			},
+			{
+				pattern: value(/'[a-z-]+'/.source),
+				lookbehind: true,
+				alias: 'safe'
+			},
+		],
+		'punctuation': /;/
+	};
+
+}(Prism));

data/vendor/assets/javascripts/languages/prism-css-extras.js

@@ -4,12 +4,13 @@
 	var selectorInside;
 
 	Prism.languages.css.selector = {
-		pattern: Prism.languages.css.selector,
+		pattern: Prism.languages.css.selector.pattern,
+		lookbehind: true,
 		inside: selectorInside = {
 			'pseudo-element': /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
 			'pseudo-class': /:[-\w]+/,
-			'class': /\.[-:.\w]+/,
-			'id': /#[-:.\w]+/,
+			'class': /\.[-\w]+/,
+			'id': /#[-\w]+/,
 			'attribute': {
 				pattern: RegExp('\\[(?:[^[\\]"\']|' + string.source + ')*\\]'),
 				greedy: true,
@@ -21,20 +22,20 @@
 						alias: 'keyword'
 					},
 					'namespace': {
-						pattern: /^(\s*)[-*\w\xA0-\uFFFF]*\|(?!=)/,
+						pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
 						lookbehind: true,
 						inside: {
 							'punctuation': /\|$/
 						}
 					},
-					'attribute': {
-						pattern: /^(\s*)[-\w\xA0-\uFFFF]+/,
+					'attr-name': {
+						pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
 						lookbehind: true
 					},
-					'value': [
+					'attr-value': [
 						string,
 						{
-							pattern: /(=\s*)[-\w\xA0-\uFFFF]+(?=\s*$)/,
+							pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
 							lookbehind: true
 						}
 					],
@@ -55,7 +56,13 @@
 					lookbehind: true
 				}
 			],
-			'punctuation': /[()]/
+			'combinator': />|\+|~|\|\|/,
+
+			// the `tag` token has been existed and removed.
+			// because we can't find a perfect tokenize to match it.
+			// if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
+
+			'punctuation': /[(),]/,
 		}
 	};
 
@@ -63,18 +70,18 @@
 
 	Prism.languages.insertBefore('css', 'property', {
 		'variable': {
-			pattern: /(^|[^-\w\xA0-\uFFFF])--[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*/i,
+			pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
 			lookbehind: true
 		}
 	});
 
 	var unit = {
-		pattern: /(\d)(?:%|[a-z]+)/,
+		pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
 		lookbehind: true
 	};
 	// 123 -123 .123 -.123 12.3 -12.3
 	var number = {
-		pattern: /(^|[^\w.-])-?\d*\.?\d+/,
+		pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
 		lookbehind: true
 	};
 
@@ -86,13 +93,16 @@
 		// CAREFUL!
 		// Previewers and Inline color use hexcode and color.
 		'hexcode': {
-			pattern: /\B#(?:[\da-f]{1,2}){3,4}\b/i,
+			pattern: /\B#[\da-f]{3,8}\b/i,
 			alias: 'color'
 		},
 		'color': [
-			/\b(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)\b/i,
 			{
-				pattern: /\b(?:rgb|hsl)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:rgb|hsl)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
+				pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|RebeccaPurple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
+				lookbehind: true
+			},
+			{
+				pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
 				inside: {
 					'unit': unit,
 					'number': number,
@@ -101,9 +111,10 @@
 				}
 			}
 		],
+		// it's important that there is no boundary assertion after the hex digits
 		'entity': /\\[\da-f]{1,8}/i,
 		'unit': unit,
 		'number': number
 	});
 
-})(Prism);
+}(Prism));

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

@@ -1,36 +1,55 @@
 (function (Prism) {
 
-	var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+	var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
 
 	Prism.languages.css = {
 		'comment': /\/\*[\s\S]*?\*\//,
 		'atrule': {
-			pattern: /@[\w-]+[\s\S]*?(?:;|(?=\s*\{))/,
+			pattern: RegExp('@[\\w-](?:' + /[^;{\s"']|\s+(?!\s)/.source + '|' + string.source + ')*?' + /(?:;|(?=\s*\{))/.source),
 			inside: {
 				'rule': /^@[\w-]+/,
 				'selector-function-argument': {
-					pattern: /(\bselector\s*\((?!\s*\))\s*)(?:[^()]|\((?:[^()]|\([^()]*\))*\))+?(?=\s*\))/,
+					pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
 					lookbehind: true,
 					alias: 'selector'
+				},
+				'keyword': {
+					pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+					lookbehind: true
 				}
 				// See rest below
 			}
 		},
 		'url': {
-			pattern: RegExp('url\\((?:' + string.source + '|[^\n\r()]*)\\)', 'i'),
+			// https://drafts.csswg.org/css-values-3/#urls
+			pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'),
+			greedy: true,
 			inside: {
 				'function': /^url/i,
-				'punctuation': /^\(|\)$/
+				'punctuation': /^\(|\)$/,
+				'string': {
+					pattern: RegExp('^' + string.source + '$'),
+					alias: 'url'
+				}
 			}
 		},
-		'selector': RegExp('[^{}\\s](?:[^{};"\']|' + string.source + ')*?(?=\\s*\\{)'),
+		'selector': {
+			pattern: RegExp('(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'),
+			lookbehind: true
+		},
 		'string': {
 			pattern: string,
 			greedy: true
 		},
-		'property': /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,
+		'property': {
+			pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+			lookbehind: true
+		},
 		'important': /!important\b/i,
-		'function': /[-a-z0-9]+(?=\()/i,
+		'function': {
+			pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+			lookbehind: true
+		},
 		'punctuation': /[(){};:,]/
 	};
 
@@ -39,24 +58,7 @@
 	var markup = Prism.languages.markup;
 	if (markup) {
 		markup.tag.addInlined('style', 'css');
-
-		Prism.languages.insertBefore('inside', 'attr-value', {
-			'style-attr': {
-				pattern: /\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
-				inside: {
-					'attr-name': {
-						pattern: /^\s*style/i,
-						inside: markup.tag.inside
-					},
-					'punctuation': /^\s*=\s*['"]|['"]\s*$/,
-					'attr-value': {
-						pattern: /.+/i,
-						inside: Prism.languages.css
-					}
-				},
-				alias: 'language-css'
-			}
-		}, markup.tag);
+		markup.tag.addAttribute('style', 'css');
 	}
 
 }(Prism));

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

@@ -0,0 +1,6 @@
+// https://tools.ietf.org/html/rfc4180
+
+Prism.languages.csv = {
+	'value': /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
+	'punctuation': /,/
+};

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

@@ -0,0 +1,84 @@
+(function (Prism) {
+
+	// https://cuelang.org/docs/references/spec/
+
+	// eslint-disable-next-line regexp/strict
+	var stringEscape = /\\(?:(?!\2)|\2(?:[^()\r\n]|\([^()]*\)))/.source;
+	// eslint-disable-next-line regexp/strict
+	var stringTypes = /"""(?:[^\\"]|"(?!""\2)|<esc>)*"""/.source +
+		// eslint-disable-next-line regexp/strict
+		'|' + /'''(?:[^\\']|'(?!''\2)|<esc>)*'''/.source +
+		// eslint-disable-next-line regexp/strict
+		'|' + /"(?:[^\\\r\n"]|"(?!\2)|<esc>)*"/.source +
+		// eslint-disable-next-line regexp/strict
+		'|' + /'(?:[^\\\r\n']|'(?!\2)|<esc>)*'/.source;
+	var stringLiteral = '(?:' + stringTypes.replace(/<esc>/g, stringEscape) + ')';
+
+	Prism.languages.cue = {
+		'comment': {
+			pattern: /\/\/.*/,
+			greedy: true
+		},
+		'string-literal': {
+			// eslint-disable-next-line regexp/strict
+			pattern: RegExp(/(^|[^#"'\\])(#*)/.source + stringLiteral + /(?!["'])\2/.source),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				// I'm using dirty hack here. We have to know the number hashes at the start of the string somehow,
+				// but we can't look back. So instead, we will use a lookahead, go to the end of the string, and
+				// capture the hashes at the end of the string.
+				'escape': {
+					pattern: /(?=[\s\S]*["'](#*)$)\\\1(?:U[a-fA-F0-9]{1,8}|u[a-fA-F0-9]{1,4}|x[a-fA-F0-9]{1,2}|\d{2,3}|[^(])/,
+					greedy: true,
+					alias: 'string'
+				},
+				'interpolation': {
+					pattern: /(?=[\s\S]*["'](#*)$)\\\1\([^()]*\)/,
+					greedy: true,
+					inside: {
+						'punctuation': /^\\#*\(|\)$/,
+						'expression': {
+							pattern: /[\s\S]+/,
+							inside: null
+						}
+					}
+				},
+				'string': /[\s\S]+/
+			}
+		},
+
+		'keyword': {
+			pattern: /(^|[^\w$])(?:for|if|import|in|let|null|package)(?![\w$])/,
+			lookbehind: true
+		},
+		'boolean': {
+			pattern: /(^|[^\w$])(?:false|true)(?![\w$])/,
+			lookbehind: true
+		},
+		'builtin': {
+			pattern: /(^|[^\w$])(?:bool|bytes|float|float(?:32|64)|u?int(?:8|16|32|64|128)?|number|rune|string)(?![\w$])/,
+			lookbehind: true
+		},
+
+		'attribute': {
+			pattern: /@[\w$]+(?=\s*\()/,
+			alias: 'function'
+		},
+		'function': {
+			pattern: /(^|[^\w$])[a-z_$][\w$]*(?=\s*\()/i,
+			lookbehind: true
+		},
+
+		'number': {
+			pattern: /(^|[^\w$.])(?:0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|0[xX][0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*|(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[eE][+-]?\d+(?:_\d+)*)?(?:[KMGTP]i?)?)(?![\w$])/,
+			lookbehind: true
+		},
+
+		'operator': /\.{3}|_\|_|&&?|\|\|?|[=!]~|[<>=!]=?|[+\-*/?]/,
+		'punctuation': /[()[\]{},.:]/
+	};
+
+	Prism.languages.cue['string-literal'].inside.interpolation.inside.expression.inside = Prism.languages.cue;
+
+}(Prism));

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

@@ -0,0 +1,36 @@
+Prism.languages.cypher = {
+	// https://neo4j.com/docs/cypher-manual/current/syntax/comments/
+	'comment': /\/\/.*/,
+	'string': {
+		pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
+		greedy: true
+	},
+	'class-name': {
+		pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
+		lookbehind: true,
+		greedy: true
+	},
+	'relationship': {
+		pattern: /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
+		lookbehind: true,
+		greedy: true,
+		alias: 'property'
+	},
+	'identifier': {
+		pattern: /`(?:[^`\\\r\n])*`/,
+		greedy: true
+	},
+
+	'variable': /\$\w+/,
+
+	// https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
+	'keyword': /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
+
+	'function': /\b\w+\b(?=\s*\()/,
+
+	'boolean': /\b(?:false|null|true)\b/i,
+	'number': /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+	// https://neo4j.com/docs/cypher-manual/current/syntax/operators/
+	'operator': /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
+	'punctuation': /[()[\]{},;.]/
+};