prism-rails 1.19.0 → 1.29.0

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

@@ -0,0 +1,100 @@
+// https://wren.io/
+
+Prism.languages.wren = {
+	// Multiline comments in Wren can have nested multiline comments
+	// Comments: // and /* */
+	'comment': [
+		{
+			// support 3 levels of nesting
+			// regex: \/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\/
+			pattern: /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*))*\*\/)*\*\/)*\*\//,
+			greedy: true
+		},
+		{
+			pattern: /(^|[^\\:])\/\/.*/,
+			lookbehind: true,
+			greedy: true
+		}
+	],
+
+	// Triple quoted strings are multiline but cannot have interpolation (raw strings)
+	// Based on prism-python.js
+	'triple-quoted-string': {
+		pattern: /"""[\s\S]*?"""/,
+		greedy: true,
+		alias: 'string'
+	},
+
+	// see below
+	'string-literal': null,
+
+	// #!/usr/bin/env wren on the first line
+	'hashbang': {
+		pattern: /^#!\/.+/,
+		greedy: true,
+		alias: 'comment'
+	},
+
+	// Attributes are special keywords to add meta data to classes
+	'attribute': {
+		// #! attributes are stored in class properties
+		// #!myvar = true
+		// #attributes are not stored and dismissed at compilation
+		pattern: /#!?[ \t\u3000]*\w+/,
+		alias: 'keyword'
+	},
+	'class-name': [
+		{
+			// class definition
+			// class Meta {}
+			pattern: /(\bclass\s+)\w+/,
+			lookbehind: true
+		},
+		// A class must always start with an uppercase.
+		// File.read
+		/\b[A-Z][a-z\d_]*\b/,
+	],
+
+	// A constant can be a variable, class, property or method. Just named in all uppercase letters
+	'constant': /\b[A-Z][A-Z\d_]*\b/,
+
+	'null': {
+		pattern: /\bnull\b/,
+		alias: 'keyword'
+	},
+	'keyword': /\b(?:as|break|class|construct|continue|else|for|foreign|if|import|in|is|return|static|super|this|var|while)\b/,
+	'boolean': /\b(?:false|true)\b/,
+	'number': /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+
+	// Functions can be Class.method()
+	'function': /\b[a-z_]\w*(?=\s*[({])/i,
+
+	'operator': /<<|>>|[=!<>]=?|&&|\|\||[-+*/%~^&|?:]|\.{2,3}/,
+	'punctuation': /[\[\](){}.,;]/,
+};
+
+Prism.languages.wren['string-literal'] = {
+	// A single quote string is multiline and can have interpolation (similar to JS backticks ``)
+	pattern: /(^|[^\\"])"(?:[^\\"%]|\\[\s\S]|%(?!\()|%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\))*"/,
+	lookbehind: true,
+	greedy: true,
+	inside: {
+		'interpolation': {
+			// "%(interpolation)"
+			pattern: /((?:^|[^\\])(?:\\{2})*)%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\)/,
+			lookbehind: true,
+			inside: {
+				'expression': {
+					pattern: /^(%\()[\s\S]+(?=\)$)/,
+					lookbehind: true,
+					inside: Prism.languages.wren
+				},
+				'interpolation-punctuation': {
+					pattern: /^%\(|\)$/,
+					alias: 'punctuation'
+				},
+			}
+		},
+		'string': /[\s\S]+/
+	}
+};

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

@@ -1,4 +1,4 @@
-(function(Prism) {
+(function (Prism) {
 	Prism.languages.xeora = Prism.languages.extend('markup', {
 		'constant': {
 			pattern: /\$(?:DomainContents|PageRenderDuration)\$/,
@@ -20,7 +20,7 @@
 			}
 		},
 		'function-inline': {
-			pattern: /\$F:[-\w.]+\?[-\w.]+(?:,(?:\|?(?:[-#.^+*~]*(?:[\w+][^$]*)|=(?:[\S+][^$]*)|@[-#]*(?:\w+.)[\w+.]+)?)*)?\$/,
+			pattern: /\$F:[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\$/,
 			inside: {
 				'variable': {
 					pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\w.]+/,
@@ -40,7 +40,7 @@
 			alias: 'function'
 		},
 		'function-block': {
-			pattern: /\$XF:{[-\w.]+\?[-\w.]+(?:,(?:\|?(?:[-#.^+*~]*(?:[\w+][^$]*)|=(?:[\S+][^$]*)|@[-#]*(?:\w+.)[\w+.]+)?)*)?}:XF\$/,
+			pattern: /\$XF:\{[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\}:XF\$/,
 			inside: {
 				'punctuation': {
 					pattern: /[$:{}?.,|]/
@@ -49,7 +49,7 @@
 			alias: 'function'
 		},
 		'directive-inline': {
-			pattern: /\$\w(?:#\d+\+?)?(?:\[[-\w.]+])?:[-\/\w.]+\$/,
+			pattern: /\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\/\w.]+\$/,
 			inside: {
 				'punctuation': {
 					pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
@@ -63,7 +63,7 @@
 			alias: 'function'
 		},
 		'directive-block-open': {
-			pattern: /\$\w+:{|\$\w(?:#\d+\+?)?(?:\[[-\w.]+])?:[-\w.]+:{(?:![A-Z]+)?/,
+			pattern: /\$\w+:\{|\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\w.]+:\{(?:![A-Z]+)?/,
 			inside: {
 				'punctuation': {
 					pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
@@ -86,7 +86,7 @@
 			alias: 'function'
 		},
 		'directive-block-separator': {
-			pattern: /}:[-\w.]+:{/,
+			pattern: /\}:[-\w.]+:\{/,
 			inside: {
 				'punctuation': {
 					pattern: /[:{}]/
@@ -95,7 +95,7 @@
 			alias: 'function'
 		},
 		'directive-block-close': {
-			pattern: /}:[-\w.]+\$/,
+			pattern: /\}:[-\w.]+\$/,
 			inside: {
 				'punctuation': {
 					pattern: /[:{}$]/
@@ -107,7 +107,7 @@
 
 	Prism.languages.insertBefore('inside', 'punctuation', {
 		'variable': Prism.languages.xeora['function-inline'].inside['variable']
-	}, Prism.languages.xeora["function-block"]);
+	}, Prism.languages.xeora['function-block']);
 
 	Prism.languages.xeoracube = Prism.languages.xeora;
 

data/vendor/assets/javascripts/languages/prism-xml-doc.js

@@ -0,0 +1,40 @@
+(function (Prism) {
+
+	/**
+	 * If the given language is present, it will insert the given doc comment grammar token into it.
+	 *
+	 * @param {string} lang
+	 * @param {any} docComment
+	 */
+	function insertDocComment(lang, docComment) {
+		if (Prism.languages[lang]) {
+			Prism.languages.insertBefore(lang, 'comment', {
+				'doc-comment': docComment
+			});
+		}
+	}
+
+	var tag = Prism.languages.markup.tag;
+
+	var slashDocComment = {
+		pattern: /\/\/\/.*/,
+		greedy: true,
+		alias: 'comment',
+		inside: {
+			'tag': tag
+		}
+	};
+	var tickDocComment = {
+		pattern: /'''.*/,
+		greedy: true,
+		alias: 'comment',
+		inside: {
+			'tag': tag
+		}
+	};
+
+	insertDocComment('csharp', slashDocComment);
+	insertDocComment('fsharp', slashDocComment);
+	insertDocComment('vbnet', tickDocComment);
+
+}(Prism));

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

@@ -1,20 +1,21 @@
 Prism.languages.xojo = {
 	'comment': {
 		pattern: /(?:'|\/\/|Rem\b).+/i,
-		inside: {
-			'keyword': /^Rem/i
-		}
+		greedy: true
 	},
 	'string': {
 		pattern: /"(?:""|[^"])*"/,
 		greedy: true
 	},
 	'number': [
-		/(?:\b\d+\.?\d*|\B\.\d+)(?:E[+-]?\d+)?/i,
+		/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
 		/&[bchou][a-z\d]+/i
 	],
-	'symbol': /#(?:If|Else|ElseIf|Endif|Pragma)\b/i,
-	'keyword': /\b(?:AddHandler|App|Array|As(?:signs)?|By(?:Ref|Val)|Break|Call|Case|Catch|Const|Continue|CurrentMethodName|Declare|Dim|Do(?:wnTo)?|Each|Else(?:If)?|End|Exit|Extends|False|Finally|For|Global|If|In|Lib|Loop|Me|Next|Nil|Optional|ParamArray|Raise(?:Event)?|ReDim|Rem|RemoveHandler|Return|Select|Self|Soft|Static|Step|Super|Then|To|True|Try|Ubound|Until|Using|Wend|While)\b/i,
-	'operator': /<[=>]?|>=?|[+\-*\/\\^=]|\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|Xor|WeakAddressOf)\b/i,
+	'directive': {
+		pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\b/i,
+		alias: 'property'
+	},
+	'keyword': /\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\b/i,
+	'operator': /<[=>]?|>=?|[+\-*\/\\^=]|\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\b/i,
 	'punctuation': /[.,;:()]/
-};
+};

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

@@ -4,7 +4,7 @@
 		'xquery-comment': {
 			pattern: /\(:[\s\S]*?:\)/,
 			greedy: true,
-			alias: "comment"
+			alias: 'comment'
 		},
 		'string': {
 			pattern: /(["'])(?:\1\1|(?!\1)[\s\S])*\1/,
@@ -14,7 +14,7 @@
 			pattern: /\(#.+?#\)/,
 			alias: 'symbol'
 		},
-		'variable': /\$[\w-:]+/,
+		'variable': /\$[-\w:]+/,
 		'axis': {
 			pattern: /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,
 			lookbehind: true,
@@ -41,7 +41,7 @@
 			alias: 'attr-name'
 		},
 		'builtin': {
-			pattern: /(^|[^:-])\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|ENTITIES|ENTITY|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|ID|IDREFS?|int|integer|language|long|Name|NCName|negativeInteger|NMTOKENS?|nonNegativeInteger|nonPositiveInteger|normalizedString|NOTATION|positiveInteger|QName|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\b(?=$|[^:-])/,
+			pattern: /(^|[^:-])\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:ENTITIES|ENTITY|ID|IDREFS?|NCName|NMTOKENS?|NOTATION|Name|QName|anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|int|integer|language|long|negativeInteger|nonNegativeInteger|nonPositiveInteger|normalizedString|positiveInteger|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\b(?=$|[^:-])/,
 			lookbehind: true
 		},
 		'number': /\b\d+(?:\.\d+)?(?:E[+-]?\d+)?/,
@@ -55,12 +55,12 @@
 		'punctuation': /[[\](){},;:/]/
 	});
 
-	Prism.languages.xquery.tag.pattern = /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|{(?!{)(?:{(?:{[^}]*}|[^}])*}|[^}])+}|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i;
-	Prism.languages.xquery['tag'].inside['attr-value'].pattern = /=(?:("|')(?:\\[\s\S]|{(?!{)(?:{(?:{[^}]*}|[^}])*}|[^}])+}|(?!\1)[^\\])*\1|[^\s'">=]+)/i;
+	Prism.languages.xquery.tag.pattern = /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
+	Prism.languages.xquery['tag'].inside['attr-value'].pattern = /=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+)/;
 	Prism.languages.xquery['tag'].inside['attr-value'].inside['punctuation'] = /^="|"$/;
 	Prism.languages.xquery['tag'].inside['attr-value'].inside['expression'] = {
 		// Allow for two levels of nesting
-		pattern: /{(?!{)(?:{(?:{[^}]*}|[^}])*}|[^}])+}/,
+		pattern: /\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}/,
 		inside: Prism.languages.xquery,
 		alias: 'language-xquery'
 	};
@@ -118,7 +118,7 @@
 					openedTags[openedTags.length - 1].openedBraces--;
 
 				} else if (token.type !== 'comment') {
-					notTagNorBrace = true
+					notTagNorBrace = true;
 				}
 			}
 			if (notTagNorBrace || typeof token === 'string') {

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

@@ -8,6 +8,12 @@
 	// https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)
 	var properties = '(?:' + tag.source + '(?:[ \t]+' + anchorOrAlias.source + ')?|'
 		+ anchorOrAlias.source + '(?:[ \t]+' + tag.source + ')?)';
+	// https://yaml.org/spec/1.2/spec.html#ns-plain(n,c)
+	// This is a simplified version that doesn't support "#" and multiline keys
+	// All these long scarry character classes are simplified versions of YAML's characters
+	var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source
+		.replace(/<PLAIN>/g, function () { return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source; });
+	var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
 
 	/**
 	 *
@@ -17,23 +23,25 @@
 	 */
 	function createValuePattern(value, flags) {
 		flags = (flags || '').replace(/m/g, '') + 'm'; // add m flag
-		var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|]|}|\s*#))/.source
-			.replace(/<<prop>>/g, properties).replace(/<<value>>/g, value);
-		return RegExp(pattern, flags)
+		var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source
+			.replace(/<<prop>>/g, function () { return properties; }).replace(/<<value>>/g, function () { return value; });
+		return RegExp(pattern, flags);
 	}
 
 	Prism.languages.yaml = {
 		'scalar': {
-			pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)[^\r\n]+(?:\2[^\r\n]+)*)/.source
-				.replace(/<<prop>>/g, properties)),
+			pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source
+				.replace(/<<prop>>/g, function () { return properties; })),
 			lookbehind: true,
 			alias: 'string'
 		},
 		'comment': /#.*/,
 		'key': {
-			pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)[^\r\n{[\]},#\s]+?(?=\s*:\s)/.source
-				.replace(/<<prop>>/g, properties)),
+			pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source
+				.replace(/<<prop>>/g, function () { return properties; })
+				.replace(/<<key>>/g, function () { return '(?:' + plainKey + '|' + string + ')'; })),
 			lookbehind: true,
+			greedy: true,
 			alias: 'atrule'
 		},
 		'directive': {
@@ -42,12 +50,12 @@
 			alias: 'important'
 		},
 		'datetime': {
-			pattern: createValuePattern(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?)?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
+			pattern: createValuePattern(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
 			lookbehind: true,
 			alias: 'number'
 		},
 		'boolean': {
-			pattern: createValuePattern(/true|false/.source, 'i'),
+			pattern: createValuePattern(/false|true/.source, 'i'),
 			lookbehind: true,
 			alias: 'important'
 		},
@@ -57,13 +65,12 @@
 			alias: 'important'
 		},
 		'string': {
-			// \2 because of the lookbehind group
-			pattern: createValuePattern(/("|')(?:(?!\2)[^\\\r\n]|\\.)*\2/.source),
+			pattern: createValuePattern(string),
 			lookbehind: true,
 			greedy: true
 		},
 		'number': {
-			pattern: createValuePattern(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+\.?\d*|\.?\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, 'i'),
+			pattern: createValuePattern(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, 'i'),
 			lookbehind: true
 		},
 		'tag': tag,

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

@@ -0,0 +1,20 @@
+Prism.languages.yang = {
+	// https://tools.ietf.org/html/rfc6020#page-34
+	// http://www.yang-central.org/twiki/bin/view/Main/YangExamples
+	'comment': /\/\*[\s\S]*?\*\/|\/\/.*/,
+	'string': {
+		pattern: /"(?:[^\\"]|\\.)*"|'[^']*'/,
+		greedy: true
+	},
+	'keyword': {
+		pattern: /(^|[{};\r\n][ \t]*)[a-z_][\w.-]*/i,
+		lookbehind: true
+	},
+	'namespace': {
+		pattern: /(\s)[a-z_][\w.-]*(?=:)/i,
+		lookbehind: true
+	},
+	'boolean': /\b(?:false|true)\b/,
+	'operator': /\+/,
+	'punctuation': /[{};:]/
+};

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

@@ -1,11 +1,15 @@
 (function (Prism) {
 
-	var keyword = /\b(?:align|allowzero|and|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
+	function literal(str) {
+		return function () { return str; };
+	}
+
+	var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
 
 	var IDENTIFIER = '\\b(?!' + keyword.source + ')(?!\\d)\\w+\\b';
 	var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source;
-	var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(/<ALIGN>/g, ALIGN);
-	var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(/<ID>/g, IDENTIFIER);
+	var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(/<ALIGN>/g, literal(ALIGN));
+	var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(/<ID>/g, literal(IDENTIFIER));
 	var TYPE = '(?!\\s)(?:!?\\s*(?:' + PREFIX_TYPE_OP + '\\s*)*' + SUFFIX_EXPR + ')+';
 
 	/*
@@ -28,7 +32,7 @@
 	Prism.languages.zig = {
 		'comment': [
 			{
-				pattern: /\/{3}.*/,
+				pattern: /\/\/[/!].*/,
 				alias: 'doc-comment'
 			},
 			/\/{2}.*/
@@ -45,14 +49,14 @@
 				pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/,
 				lookbehind: true,
 				greedy: true
-			},
-			{
-				// characters 'a', '\n', '\xFF', '\u{10FFFF}'
-				pattern: /(^|[^\\])'(?:[^'\\\r\n]|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/,
-				lookbehind: true,
-				greedy: true
 			}
 		],
+		'char': {
+			// characters 'a', '\n', '\xFF', '\u{10FFFF}'
+			pattern: /(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/,
+			lookbehind: true,
+			greedy: true
+		},
 		'builtin': /\B@(?!\d)\w+(?=\s*\()/,
 		'label': {
 			pattern: /(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/,
@@ -65,24 +69,24 @@
 				// const x: i32 = 9;
 				// var x: Bar;
 				// fn foo(x: bool, y: f32) void {}
-				pattern: RegExp(/(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source.replace(/<TYPE>/g, TYPE).replace(/<ALIGN>/g, ALIGN)),
+				pattern: RegExp(/(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))),
 				lookbehind: true,
 				inside: null // see below
 			},
 			{
 				// extern fn foo(x: f64) f64; (optional alignment)
-				pattern: RegExp(/(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source.replace(/<TYPE>/g, TYPE).replace(/<ALIGN>/g, ALIGN)),
+				pattern: RegExp(/(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))),
 				lookbehind: true,
 				inside: null // see below
 			}
 		],
-		'builtin-types': {
-			pattern: /\b(?:anyerror|bool|c_u?(?:short|int|long|longlong)|c_longdouble|c_void|comptime_(?:float|int)|[iu](?:8|16|32|64|128|size)|f(?:16|32|64|128)|noreturn|type|void)\b/,
+		'builtin-type': {
+			pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,
 			alias: 'keyword'
 		},
 		'keyword': keyword,
 		'function': /\b(?!\d)\w+(?=\s*\()/,
-		'number': /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+\.?[a-fA-F\d]*(?:[pP][+-]?[a-fA-F\d]+)?|\d+\.?\d*(?:[eE][+-]?\d+)?)\b/,
+		'number': /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,
 		'boolean': /\b(?:false|true)\b/,
 		'operator': /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,
 		'punctuation': /[.:,;(){}[\]]/

data/vendor/assets/javascripts/prism-plugin/prism-autolinker.js

@@ -1,81 +1,76 @@
-(function(){
+(function () {
 
-if (
-	typeof self !== 'undefined' && !self.Prism ||
-	typeof global !== 'undefined' && !global.Prism
-) {
-	return;
-}
+	if (typeof Prism === 'undefined') {
+		return;
+	}
 
-var url = /\b([a-z]{3,7}:\/\/|tel:)[\w\-+%~/.:=&@]+(?:\?[\w\-+%~/.:=?&!$'()*,;@]*)?(?:#[\w\-+%~/.:#=?&!$'()*,;@]*)?/,
-    email = /\b\S+@[\w.]+[a-z]{2}/,
-    linkMd = /\[([^\]]+)]\(([^)]+)\)/,
+	var url = /\b([a-z]{3,7}:\/\/|tel:)[\w\-+%~/.:=&!$'()*,;@]+(?:\?[\w\-+%~/.:=?&!$'()*,;@]*)?(?:#[\w\-+%~/.:#=?&!$'()*,;@]*)?/;
+	var email = /\b\S+@[\w.]+[a-z]{2}/;
+	var linkMd = /\[([^\]]+)\]\(([^)]+)\)/;
 
 	// Tokens that may contain URLs and emails
-    candidates = ['comment', 'url', 'attr-value', 'string'];
+	var candidates = ['comment', 'url', 'attr-value', 'string'];
 
-Prism.plugins.autolinker = {
-	processGrammar: function (grammar) {
-		// Abort if grammar has already been processed
-		if (!grammar || grammar['url-link']) {
-			return;
-		}
-		Prism.languages.DFS(grammar, function (key, def, type) {
-			if (candidates.indexOf(type) > -1 && !Array.isArray(def)) {
-				if (!def.pattern) {
-					def = this[key] = {
-						pattern: def
-					};
-				}
+	Prism.plugins.autolinker = {
+		processGrammar: function (grammar) {
+			// Abort if grammar has already been processed
+			if (!grammar || grammar['url-link']) {
+				return;
+			}
+			Prism.languages.DFS(grammar, function (key, def, type) {
+				if (candidates.indexOf(type) > -1 && !Array.isArray(def)) {
+					if (!def.pattern) {
+						def = this[key] = {
+							pattern: def
+						};
+					}
 
-				def.inside = def.inside || {};
+					def.inside = def.inside || {};
 
-				if (type == 'comment') {
-					def.inside['md-link'] = linkMd;
-				}
-				if (type == 'attr-value') {
-					Prism.languages.insertBefore('inside', 'punctuation', { 'url-link': url }, def);
-				}
-				else {
-					def.inside['url-link'] = url;
-				}
+					if (type == 'comment') {
+						def.inside['md-link'] = linkMd;
+					}
+					if (type == 'attr-value') {
+						Prism.languages.insertBefore('inside', 'punctuation', { 'url-link': url }, def);
+					} else {
+						def.inside['url-link'] = url;
+					}
 
-				def.inside['email-link'] = email;
-			}
-		});
-		grammar['url-link'] = url;
-		grammar['email-link'] = email;
-	}
-};
+					def.inside['email-link'] = email;
+				}
+			});
+			grammar['url-link'] = url;
+			grammar['email-link'] = email;
+		}
+	};
 
-Prism.hooks.add('before-highlight', function(env) {
-	Prism.plugins.autolinker.processGrammar(env.grammar);
-});
+	Prism.hooks.add('before-highlight', function (env) {
+		Prism.plugins.autolinker.processGrammar(env.grammar);
+	});
 
-Prism.hooks.add('wrap', function(env) {
-	if (/-link$/.test(env.type)) {
-		env.tag = 'a';
+	Prism.hooks.add('wrap', function (env) {
+		if (/-link$/.test(env.type)) {
+			env.tag = 'a';
 
-		var href = env.content;
+			var href = env.content;
 
-		if (env.type == 'email-link' && href.indexOf('mailto:') != 0) {
-			href = 'mailto:' + href;
-		}
-		else if (env.type == 'md-link') {
-			// Markdown
-			var match = env.content.match(linkMd);
+			if (env.type == 'email-link' && href.indexOf('mailto:') != 0) {
+				href = 'mailto:' + href;
+			} else if (env.type == 'md-link') {
+				// Markdown
+				var match = env.content.match(linkMd);
 
-			href = match[2];
-			env.content = match[1];
-		}
+				href = match[2];
+				env.content = match[1];
+			}
 
-		env.attributes.href = href;
+			env.attributes.href = href;
 
-		// Silently catch any error thrown by decodeURIComponent (#1186)
-		try {
-			env.content = decodeURIComponent(env.content);
-		} catch(e) {}
-	}
-});
+			// Silently catch any error thrown by decodeURIComponent (#1186)
+			try {
+				env.content = decodeURIComponent(env.content);
+			} catch (e) { /* noop */ }
+		}
+	});
 
-})();
+}());