prism-rails 1.6.0.3 → 1.29.0

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

@@ -0,0 +1,114 @@
+(function (Prism) {
+	Prism.languages.xeora = Prism.languages.extend('markup', {
+		'constant': {
+			pattern: /\$(?:DomainContents|PageRenderDuration)\$/,
+			inside: {
+				'punctuation': {
+					pattern: /\$/
+				}
+			}
+		},
+		'variable': {
+			pattern: /\$@?(?:#+|[-+*~=^])?[\w.]+\$/,
+			inside: {
+				'punctuation': {
+					pattern: /[$.]/
+				},
+				'operator': {
+					pattern: /#+|[-+*~=^@]/
+				}
+			}
+		},
+		'function-inline': {
+			pattern: /\$F:[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\$/,
+			inside: {
+				'variable': {
+					pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\w.]+/,
+					inside: {
+						'punctuation': {
+							pattern: /[,.|]/
+						},
+						'operator': {
+							pattern: /#+|[-+*~=^@]/
+						}
+					}
+				},
+				'punctuation': {
+					pattern: /\$\w:|[$:?.,|]/
+				}
+			},
+			alias: 'function'
+		},
+		'function-block': {
+			pattern: /\$XF:\{[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\}:XF\$/,
+			inside: {
+				'punctuation': {
+					pattern: /[$:{}?.,|]/
+				}
+			},
+			alias: 'function'
+		},
+		'directive-inline': {
+			pattern: /\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\/\w.]+\$/,
+			inside: {
+				'punctuation': {
+					pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
+					inside: {
+						'tag': {
+							pattern: /#\d/
+						}
+					}
+				}
+			},
+			alias: 'function'
+		},
+		'directive-block-open': {
+			pattern: /\$\w+:\{|\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\w.]+:\{(?:![A-Z]+)?/,
+			inside: {
+				'punctuation': {
+					pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
+					inside: {
+						'tag': {
+							pattern: /#\d/
+						}
+					}
+				},
+				'attribute': {
+					pattern: /![A-Z]+$/,
+					inside: {
+						'punctuation': {
+							pattern: /!/
+						}
+					},
+					alias: 'keyword'
+				}
+			},
+			alias: 'function'
+		},
+		'directive-block-separator': {
+			pattern: /\}:[-\w.]+:\{/,
+			inside: {
+				'punctuation': {
+					pattern: /[:{}]/
+				}
+			},
+			alias: 'function'
+		},
+		'directive-block-close': {
+			pattern: /\}:[-\w.]+\$/,
+			inside: {
+				'punctuation': {
+					pattern: /[:{}$]/
+				}
+			},
+			alias: 'function'
+		}
+	});
+
+	Prism.languages.insertBefore('inside', 'punctuation', {
+		'variable': Prism.languages.xeora['function-inline'].inside['variable']
+	}, Prism.languages.xeora['function-block']);
+
+	Prism.languages.xeoracube = Prism.languages.xeora;
+
+}(Prism));

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

@@ -0,0 +1,21 @@
+Prism.languages.xojo = {
+	'comment': {
+		pattern: /(?:'|\/\/|Rem\b).+/i,
+		greedy: true
+	},
+	'string': {
+		pattern: /"(?:""|[^"])*"/,
+		greedy: true
+	},
+	'number': [
+		/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+		/&[bchou][a-z\d]+/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

@@ -0,0 +1,162 @@
+(function (Prism) {
+
+	Prism.languages.xquery = Prism.languages.extend('markup', {
+		'xquery-comment': {
+			pattern: /\(:[\s\S]*?:\)/,
+			greedy: true,
+			alias: 'comment'
+		},
+		'string': {
+			pattern: /(["'])(?:\1\1|(?!\1)[\s\S])*\1/,
+			greedy: true
+		},
+		'extension': {
+			pattern: /\(#.+?#\)/,
+			alias: 'symbol'
+		},
+		'variable': /\$[-\w:]+/,
+		'axis': {
+			pattern: /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,
+			lookbehind: true,
+			alias: 'operator'
+		},
+		'keyword-operator': {
+			pattern: /(^|[^:-])\b(?:and|castable as|div|eq|except|ge|gt|idiv|instance of|intersect|is|le|lt|mod|ne|or|union)\b(?=$|[^:-])/,
+			lookbehind: true,
+			alias: 'operator'
+		},
+		'keyword': {
+			pattern: /(^|[^:-])\b(?:as|ascending|at|base-uri|boundary-space|case|cast as|collation|construction|copy-namespaces|declare|default|descending|else|empty (?:greatest|least)|encoding|every|external|for|function|if|import|in|inherit|lax|let|map|module|namespace|no-inherit|no-preserve|option|order(?: by|ed|ing)?|preserve|return|satisfies|schema|some|stable|strict|strip|then|to|treat as|typeswitch|unordered|validate|variable|version|where|xquery)\b(?=$|[^:-])/,
+			lookbehind: true
+		},
+		'function': /[\w-]+(?::[\w-]+)*(?=\s*\()/,
+		'xquery-element': {
+			pattern: /(element\s+)[\w-]+(?::[\w-]+)*/,
+			lookbehind: true,
+			alias: 'tag'
+		},
+		'xquery-attribute': {
+			pattern: /(attribute\s+)[\w-]+(?::[\w-]+)*/,
+			lookbehind: true,
+			alias: 'attr-name'
+		},
+		'builtin': {
+			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+)?/,
+		'operator': [
+			/[+*=?|@]|\.\.?|:=|!=|<[=<]?|>[=>]?/,
+			{
+				pattern: /(\s)-(?=\s)/,
+				lookbehind: true
+			}
+		],
+		'punctuation': /[[\](){},;:/]/
+	});
+
+	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: /\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}/,
+		inside: Prism.languages.xquery,
+		alias: 'language-xquery'
+	};
+
+	// The following will handle plain text inside tags
+	var stringifyToken = function (token) {
+		if (typeof token === 'string') {
+			return token;
+		}
+		if (typeof token.content === 'string') {
+			return token.content;
+		}
+		return token.content.map(stringifyToken).join('');
+	};
+
+	var walkTokens = function (tokens) {
+		var openedTags = [];
+		for (var i = 0; i < tokens.length; i++) {
+			var token = tokens[i];
+			var notTagNorBrace = false;
+
+			if (typeof token !== 'string') {
+				if (token.type === 'tag' && token.content[0] && token.content[0].type === 'tag') {
+					// We found a tag, now find its kind
+
+					if (token.content[0].content[0].content === '</') {
+						// Closing tag
+						if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
+							// Pop matching opening tag
+							openedTags.pop();
+						}
+					} else {
+						if (token.content[token.content.length - 1].content === '/>') {
+							// Autoclosed tag, ignore
+						} else {
+							// Opening tag
+							openedTags.push({
+								tagName: stringifyToken(token.content[0].content[1]),
+								openedBraces: 0
+							});
+						}
+					}
+				} else if (
+					openedTags.length > 0 && token.type === 'punctuation' && token.content === '{' &&
+					// Ignore `{{`
+					(!tokens[i + 1] || tokens[i + 1].type !== 'punctuation' || tokens[i + 1].content !== '{') &&
+					(!tokens[i - 1] || tokens[i - 1].type !== 'plain-text' || tokens[i - 1].content !== '{')
+				) {
+					// Here we might have entered an XQuery expression inside a tag
+					openedTags[openedTags.length - 1].openedBraces++;
+
+				} else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === 'punctuation' && token.content === '}') {
+
+					// Here we might have left an XQuery expression inside a tag
+					openedTags[openedTags.length - 1].openedBraces--;
+
+				} else if (token.type !== 'comment') {
+					notTagNorBrace = true;
+				}
+			}
+			if (notTagNorBrace || typeof token === 'string') {
+				if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+					// Here we are inside a tag, and not inside an XQuery expression.
+					// That's plain text: drop any tokens matched.
+					var plainText = stringifyToken(token);
+
+					// And merge text with adjacent text
+					if (i < tokens.length - 1 && (typeof tokens[i + 1] === 'string' || tokens[i + 1].type === 'plain-text')) {
+						plainText += stringifyToken(tokens[i + 1]);
+						tokens.splice(i + 1, 1);
+					}
+					if (i > 0 && (typeof tokens[i - 1] === 'string' || tokens[i - 1].type === 'plain-text')) {
+						plainText = stringifyToken(tokens[i - 1]) + plainText;
+						tokens.splice(i - 1, 1);
+						i--;
+					}
+
+					if (/^\s+$/.test(plainText)) {
+						tokens[i] = plainText;
+					} else {
+						tokens[i] = new Prism.Token('plain-text', plainText, null, plainText);
+					}
+				}
+			}
+
+			if (token.content && typeof token.content !== 'string') {
+				walkTokens(token.content);
+			}
+		}
+	};
+
+	Prism.hooks.add('after-tokenize', function (env) {
+		if (env.language !== 'xquery') {
+			return;
+		}
+		walkTokens(env.tokens);
+	});
+
+}(Prism));

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

@@ -0,0 +1,83 @@
+(function (Prism) {
+
+	// https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property
+	// https://yaml.org/spec/1.2/spec.html#c-ns-alias-node
+	var anchorOrAlias = /[*&][^\s[\]{},]+/;
+	// https://yaml.org/spec/1.2/spec.html#c-ns-tag-property
+	var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
+	// 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;
+
+	/**
+	 *
+	 * @param {string} value
+	 * @param {string} [flags]
+	 * @returns {RegExp}
+	 */
+	function createValuePattern(value, flags) {
+		flags = (flags || '').replace(/m/g, '') + 'm'; // add m flag
+		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]+)\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]+)?)<<key>>(?=\s*:\s)/.source
+				.replace(/<<prop>>/g, function () { return properties; })
+				.replace(/<<key>>/g, function () { return '(?:' + plainKey + '|' + string + ')'; })),
+			lookbehind: true,
+			greedy: true,
+			alias: 'atrule'
+		},
+		'directive': {
+			pattern: /(^[ \t]*)%.+/m,
+			lookbehind: true,
+			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),
+			lookbehind: true,
+			alias: 'number'
+		},
+		'boolean': {
+			pattern: createValuePattern(/false|true/.source, 'i'),
+			lookbehind: true,
+			alias: 'important'
+		},
+		'null': {
+			pattern: createValuePattern(/null|~/.source, 'i'),
+			lookbehind: true,
+			alias: 'important'
+		},
+		'string': {
+			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'),
+			lookbehind: true
+		},
+		'tag': tag,
+		'important': anchorOrAlias,
+		'punctuation': /---|[:[\]{}\-,|>?]|\.\.\./
+	};
+
+	Prism.languages.yml = Prism.languages.yaml;
+
+}(Prism));

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

@@ -0,0 +1,101 @@
+(function (Prism) {
+
+	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, 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 + ')+';
+
+	/*
+	 * A simplified grammar for Zig compile time type literals:
+	 *
+	 * TypeExpr = ( "!"? PREFIX_TYPE_OP* SUFFIX_EXPR )+
+	 *
+	 * SUFFIX_EXPR = ( \b "promise" \b | ( \b "error" "." )? IDENTIFIER ( "." IDENTIFIER )* (?! \s+ IDENTIFIER ) )
+	 *
+	 * PREFIX_TYPE_OP = "?"
+	 *                | \b "promise" "->"
+	 *                | ( "[" [^\[\]]* "]" | "*" | "**" ) ( ALIGN | "const" \b | "volatile" \b | "allowzero" \b )*
+	 *
+	 * ALIGN = "align" "(" ( [^()] | "(" [^()]* ")" )* ")"
+	 *
+	 * IDENTIFIER = \b (?! KEYWORD ) [a-zA-Z_] \w* \b
+	 *
+	*/
+
+	Prism.languages.zig = {
+		'comment': [
+			{
+				pattern: /\/\/[/!].*/,
+				alias: 'doc-comment'
+			},
+			/\/{2}.*/
+		],
+		'string': [
+			{
+				// "string" and c"string"
+				pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/,
+				lookbehind: true,
+				greedy: true
+			},
+			{
+				// multiline strings and c-strings
+				pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/,
+				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))/,
+			lookbehind: true
+		},
+		'class-name': [
+			// const Foo = struct {};
+			/\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/,
+			{
+				// 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, 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, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))),
+				lookbehind: true,
+				inside: null // see below
+			}
+		],
+		'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/,
+		'boolean': /\b(?:false|true)\b/,
+		'operator': /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,
+		'punctuation': /[.:,;(){}[\]]/
+	};
+
+	Prism.languages.zig['class-name'].forEach(function (obj) {
+		if (obj.inside === null) {
+			obj.inside = Prism.languages.zig;
+		}
+	});
+
+}(Prism));

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

@@ -1,76 +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\-+%~/.:#=?&!$'()*,;@]*)?/;
+	var email = /\b\S+@[\w.]+[a-z]{2}/;
+	var linkMd = /\[([^\]]+)\]\(([^)]+)\)/;
 
-var url = /\b([a-z]{3,7}:\/\/|tel:)[\w\-+%~/.:#=?&]+/,
-    email = /\b\S+@[\w.]+[a-z]{2}/,
-    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 && Prism.util.type(def) !== 'Array') {
-				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;
+		}
+	};
+
+	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';
+
+			var href = env.content;
 
-				def.inside['email-link'] = email;
+			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];
 			}
-		});
-		grammar['url-link'] = url;
-		grammar['email-link'] = email;
-	}
-};
 
-Prism.hooks.add('before-highlight', function(env) {
-	Prism.plugins.autolinker.processGrammar(env.grammar);
-});
+			env.attributes.href = href;
 
-Prism.hooks.add('wrap', function(env) {
-	if (/-link$/.test(env.type)) {
-		env.tag = 'a';
-		
-		var href = env.content;
-		
-		if (env.type == 'email-link' && href.indexOf('mailto:') != 0) {
-			href = 'mailto:' + href;
+			// Silently catch any error thrown by decodeURIComponent (#1186)
+			try {
+				env.content = decodeURIComponent(env.content);
+			} catch (e) { /* noop */ }
 		}
-		else if (env.type == 'md-link') {
-			// Markdown
-			var match = env.content.match(linkMd);
-			
-			href = match[2];
-			env.content = match[1];
-		}
-		
-		env.attributes.href = href;
-	}
-});
+	});
 
-})();
+}());