prism-rails 1.19.0 → 1.29.0

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

@@ -1,45 +1,78 @@
 Prism.languages.haxe = Prism.languages.extend('clike', {
-	// Strings can be multi-line
 	'string': {
-		pattern: /(["'])(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+		// Strings can be multi-line
+		pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+		greedy: true
+	},
+	'class-name': [
+		{
+			pattern: /(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
+			lookbehind: true,
+		},
+		// based on naming convention
+		/\b[A-Z]\w*/
+	],
+	// The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
+	'keyword': /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
+	'function': {
+		pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
+		greedy: true
+	},
+	'operator': /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
+});
+
+Prism.languages.insertBefore('haxe', 'string', {
+	'string-interpolation': {
+		pattern: /'(?:[^'\\]|\\[\s\S])*'/,
 		greedy: true,
 		inside: {
 			'interpolation': {
-				pattern: /(^|[^\\])\$(?:\w+|\{[^}]+\})/,
+				pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
 				lookbehind: true,
 				inside: {
-					'interpolation': {
-						pattern: /^\$\w*/,
-						alias: 'variable'
-					}
-					// See rest below
+					'interpolation-punctuation': {
+						pattern: /^\$\{?|\}$/,
+						alias: 'punctuation'
+					},
+					'expression': {
+						pattern: /[\s\S]+/,
+						inside: Prism.languages.haxe
+					},
 				}
-			}
+			},
+			'string': /[\s\S]+/
 		}
-	},
-	// The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
-	'keyword': /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|from|for|function|if|implements|import|in|inline|interface|macro|new|null|override|public|private|return|static|super|switch|throw|to|try|typedef|using|var|while)(?!\.)\b/,
-	'operator': /\.{3}|\+\+?|-[->]?|[=!]=?|&&?|\|\|?|<[<=]?|>[>=]?|[*\/%~^]/
+	}
 });
+
 Prism.languages.insertBefore('haxe', 'class-name', {
 	'regex': {
-		pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[igmsu]*/,
-		greedy: true
+		pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
+		greedy: true,
+		inside: {
+			'regex-flags': /\b[a-z]+$/,
+			'regex-source': {
+				pattern: /^(~\/)[\s\S]+(?=\/$)/,
+				lookbehind: true,
+				alias: 'language-regex',
+				inside: Prism.languages.regex
+			},
+			'regex-delimiter': /^~\/|\/$/,
+		}
 	}
 });
+
 Prism.languages.insertBefore('haxe', 'keyword', {
 	'preprocessor': {
-		pattern: /#\w+/,
-		alias: 'builtin'
+		pattern: /#(?:else|elseif|end|if)\b.*/,
+		alias: 'property'
 	},
 	'metadata': {
-		pattern: /@:?\w+/,
+		pattern: /@:?[\w.]+/,
 		alias: 'symbol'
 	},
 	'reification': {
 		pattern: /\$(?:\w+|(?=\{))/,
-		alias: 'variable'
+		alias: 'important'
 	}
 });
-Prism.languages.haxe['string'].inside['interpolation'].inside.rest = Prism.languages.haxe;
-delete Prism.languages.haxe['class-name'];

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

@@ -1,13 +1,13 @@
 Prism.languages.hcl = {
 	'comment': /(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,
 	'heredoc': {
-		pattern: /<<-?(\w+)[\s\S]*?^\s*\1/m,
+		pattern: /<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,
 		greedy: true,
 		alias: 'string'
 	},
 	'keyword': [
 		{
-			pattern: /(?:resource|data)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+{)/i,
+			pattern: /(?:data|resource)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+\{)/i,
 			inside: {
 				'type': {
 					pattern: /(resource|data|\s+)(?:"(?:\\[\s\S]|[^\\"])*")/i,
@@ -17,25 +17,23 @@ Prism.languages.hcl = {
 			}
 		},
 		{
-			pattern: /(?:provider|provisioner|variable|output|module|backend)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?={)/i,
+			pattern: /(?:backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?=\{)/i,
 			inside: {
 				'type': {
-					pattern: /(provider|provisioner|variable|output|module|backend)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,
+					pattern: /(backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,
 					lookbehind: true,
 					alias: 'variable'
 				}
 			}
 		},
-		{
-			pattern: /[\w-]+(?=\s+{)/
-		}
+		/[\w-]+(?=\s+\{)/
 	],
 	'property': [
-		/[\w-\.]+(?=\s*=(?!=))/,
+		/[-\w\.]+(?=\s*=(?!=))/,
 		/"(?:\\[\s\S]|[^\\"])+"(?=\s*[:=])/,
 	],
 	'string': {
-		pattern: /"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,
+		pattern: /"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+(?!\$)|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,
 		greedy: true,
 		inside: {
 			'interpolation': {
@@ -43,23 +41,23 @@ Prism.languages.hcl = {
 				lookbehind: true,
 				inside: {
 					'type': {
-						pattern: /(\b(?:terraform|var|self|count|module|path|data|local)\b\.)[\w\*]+/i,
+						pattern: /(\b(?:count|data|local|module|path|self|terraform|var)\b\.)[\w\*]+/i,
 						lookbehind: true,
 						alias: 'variable'
 					},
-					'keyword': /\b(?:terraform|var|self|count|module|path|data|local)\b/i,
+					'keyword': /\b(?:count|data|local|module|path|self|terraform|var)\b/i,
 					'function': /\w+(?=\()/,
 					'string': {
 						pattern: /"(?:\\[\s\S]|[^\\"])*"/,
 						greedy: true,
 					},
-					'number': /\b0x[\da-f]+|\d+\.?\d*(?:e[+-]?\d+)?/i,
+					'number': /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
 					'punctuation': /[!\$#%&'()*+,.\/;<=>@\[\\\]^`{|}~?:]/,
 				}
 			},
 		}
 	},
-	'number': /\b0x[\da-f]+|\d+\.?\d*(?:e[+-]?\d+)?/i,
-	'boolean': /\b(?:true|false)\b/i,
+	'number': /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+	'boolean': /\b(?:false|true)\b/i,
 	'punctuation': /[=\[\]{}]/,
 };

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

@@ -0,0 +1,20 @@
+Prism.languages.hlsl = Prism.languages.extend('c', {
+
+	// Regarding keywords and class names:
+	// The list of all keywords was split into 'keyword' and 'class-name' tokens based on whether they are capitalized.
+	// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords
+	// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-reserved-words
+	'class-name': [
+		Prism.languages.c['class-name'],
+		/\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/
+	],
+	'keyword': [
+		// HLSL keyword
+		/\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\b/,
+		// scalar, vector, and matrix types
+		/\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\b/
+	],
+	// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-grammar#floating-point-numbers
+	'number': /(?:(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?|\b0x[\da-fA-F]+)[fFhHlLuU]?\b/,
+	'boolean': /\b(?:false|true)\b/
+});

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

@@ -0,0 +1,14 @@
+Prism.languages.hoon = {
+	'comment': {
+		pattern: /::.*/,
+		greedy: true
+	},
+	'string': {
+		pattern: /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/,
+		greedy: true
+	},
+	'constant': /%(?:\.[ny]|[\w-]+)/,
+	'class-name': /@(?:[a-z0-9-]*[a-z0-9])?|\*/i,
+	'function': /(?:\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,
+	'keyword': /\.[\^\+\*=\?]|![><:\.=\?!]|=[>|:,\.\-\^<+;/~\*\?]|\?[>|:\.\-\^<\+&~=@!]|\|[\$_%:\.\-\^~\*=@\?]|\+[|\$\+\*]|:[_\-\^\+~\*]|%[_:\.\-\^\+~\*=]|\^[|:\.\-\+&~\*=\?]|\$[|_%:<>\-\^&~@=\?]|;[:<\+;\/~\*=]|~[>|\$_%<\+\/&=\?!]|--|==/
+};

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

@@ -6,15 +6,9 @@
 
 Prism.languages.hpkp = {
 	'directive': {
-		pattern: /\b(?:(?:includeSubDomains|preload|strict)(?: |;)|pin-sha256="[a-zA-Z\d+=/]+"|(?:max-age|report-uri)=|report-to )/,
-		alias: 'keyword'
+		pattern: /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i,
+		alias: 'property'
 	},
-	'safe': {
-		pattern: /\d{7,}/,
-		alias: 'selector'
-	},
-	'unsafe': {
-		pattern: /\d{1,6}/,
-		alias: 'function'
-	}
+	'operator': /=/,
+	'punctuation': /;/
 };

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

@@ -6,15 +6,9 @@
 
 Prism.languages.hsts = {
 	'directive': {
-		pattern: /\b(?:max-age=|includeSubDomains|preload)/,
-		alias: 'keyword'
+		pattern: /\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i,
+		alias: 'property'
 	},
-	'safe': {
-		pattern: /\d{8,}/,
-		alias: 'selector'
-	},
-	'unsafe': {
-		pattern: /\d{1,7}/,
-		alias: 'function'
-	}
+	'operator': /=/,
+	'punctuation': /;/
 };

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

@@ -1,28 +1,92 @@
 (function (Prism) {
+
+	/**
+	 * @param {string} name
+	 * @returns {RegExp}
+	 */
+	function headerValueOf(name) {
+		return RegExp('(^(?:' + name + '):[ \t]*(?![ \t]))[^]+', 'i');
+	}
+
 	Prism.languages.http = {
 		'request-line': {
-			pattern: /^(?:POST|GET|PUT|DELETE|OPTIONS|PATCH|TRACE|CONNECT)\s(?:https?:\/\/|\/)\S+\sHTTP\/[0-9.]+/m,
+			pattern: /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\s(?:https?:\/\/|\/)\S*\sHTTP\/[\d.]+/m,
 			inside: {
-				// HTTP Verb
-				'property': /^(?:POST|GET|PUT|DELETE|OPTIONS|PATCH|TRACE|CONNECT)\b/,
-				// Path or query argument
-				'attr-name': /:\w+/
+				// HTTP Method
+				'method': {
+					pattern: /^[A-Z]+\b/,
+					alias: 'property'
+				},
+				// Request Target e.g. http://example.com, /path/to/file
+				'request-target': {
+					pattern: /^(\s)(?:https?:\/\/|\/)\S*(?=\s)/,
+					lookbehind: true,
+					alias: 'url',
+					inside: Prism.languages.uri
+				},
+				// HTTP Version
+				'http-version': {
+					pattern: /^(\s)HTTP\/[\d.]+/,
+					lookbehind: true,
+					alias: 'property'
+				},
 			}
 		},
 		'response-status': {
-			pattern: /^HTTP\/1.[01] \d+.*/m,
+			pattern: /^HTTP\/[\d.]+ \d+ .+/m,
 			inside: {
-				// Status, e.g. 200 OK
-				'property': {
-					pattern: /(^HTTP\/1.[01] )\d+.*/i,
-					lookbehind: true
+				// HTTP Version
+				'http-version': {
+					pattern: /^HTTP\/[\d.]+/,
+					alias: 'property'
+				},
+				// Status Code
+				'status-code': {
+					pattern: /^(\s)\d+(?=\s)/,
+					lookbehind: true,
+					alias: 'number'
+				},
+				// Reason Phrase
+				'reason-phrase': {
+					pattern: /^(\s).+/,
+					lookbehind: true,
+					alias: 'string'
 				}
 			}
 		},
-		// HTTP header name
-		'header-name': {
-			pattern: /^[\w-]+:(?=.)/m,
-			alias: 'keyword'
+		'header': {
+			pattern: /^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m,
+			inside: {
+				'header-value': [
+					{
+						pattern: headerValueOf(/Content-Security-Policy/.source),
+						lookbehind: true,
+						alias: ['csp', 'languages-csp'],
+						inside: Prism.languages.csp
+					},
+					{
+						pattern: headerValueOf(/Public-Key-Pins(?:-Report-Only)?/.source),
+						lookbehind: true,
+						alias: ['hpkp', 'languages-hpkp'],
+						inside: Prism.languages.hpkp
+					},
+					{
+						pattern: headerValueOf(/Strict-Transport-Security/.source),
+						lookbehind: true,
+						alias: ['hsts', 'languages-hsts'],
+						inside: Prism.languages.hsts
+					},
+					{
+						pattern: headerValueOf(/[^:]+/.source),
+						lookbehind: true
+					}
+				],
+				'header-name': {
+					pattern: /^[^:]+/,
+					alias: 'keyword'
+				},
+				'punctuation': /^:/
+			}
 		}
 	};
 
@@ -34,7 +98,8 @@
 		'application/xml': langs.xml,
 		'text/xml': langs.xml,
 		'text/html': langs.html,
-		'text/css': langs.css
+		'text/css': langs.css,
+		'text/plain': langs.plain
 	};
 
 	// Declare which types can also be suffixes
@@ -64,14 +129,23 @@
 
 			var pattern = suffixTypes[contentType] ? getSuffixPattern(contentType) : contentType;
 			options[contentType.replace(/\//g, '-')] = {
-				pattern: RegExp('(content-type:\\s*' + pattern + '[\\s\\S]*?)(?:\\r?\\n|\\r){2}[\\s\\S]*', 'i'),
+				pattern: RegExp(
+					'(' + /content-type:\s*/.source + pattern + /(?:(?:\r\n?|\n)[\w-].*)*(?:\r(?:\n|(?!\n))|\n)/.source + ')' +
+					// This is a little interesting:
+					// The HTTP format spec required 1 empty line before the body to make everything unambiguous.
+					// However, when writing code by hand (e.g. to display on a website) people can forget about this,
+					// so we want to be liberal here. We will allow the empty line to be omitted if the first line of
+					// the body does not start with a [\w-] character (as headers do).
+					/[^ \t\w-][\s\S]*/.source,
+					'i'
+				),
 				lookbehind: true,
 				inside: httpLanguages[contentType]
 			};
 		}
 	}
 	if (options) {
-		Prism.languages.insertBefore('http', 'header-name', options);
+		Prism.languages.insertBefore('http', 'header', options);
 	}
 
 }(Prism));

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

@@ -3,13 +3,13 @@
 Prism.languages.ichigojam = {
 	'comment': /(?:\B'|REM)(?:[^\n\r]*)/i,
 	'string': {
-		pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^_ +\-.A-Z\d])*"/i,
+		pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
 		greedy: true
 	},
-	'number': /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+\.?\d*|\B\.\d+)(?:E[+-]?\d+)?/i,
-	'keyword': /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GSB|GOTO|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|RIGHT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,
+	'number': /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+	'keyword': /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,
 	'function': /\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i,
-	'label': /(?:\B@[^\s]+)/i,
+	'label': /(?:\B@\S+)/,
 	'operator': /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,
 	'punctuation': /[\[,;:()\]]/
-};
+};

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

@@ -14,7 +14,7 @@ Prism.languages.icon = {
 		alias: 'builtin'
 	},
 	'keyword': /\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\b/,
-	'function': /(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/,
+	'function': /\b(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/,
 	'operator': /[+-]:(?!=)|(?:[\/?@^%&]|\+\+?|--?|==?=?|~==?=?|\*\*?|\|\|\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\|~]/,
 	'punctuation': /[\[\](){},;]/
-};
+};

data/vendor/assets/javascripts/languages/prism-icu-message-format.js

@@ -0,0 +1,148 @@
+// https://unicode-org.github.io/icu/userguide/format_parse/messages/
+// https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/MessageFormat.html
+
+(function (Prism) {
+
+	/**
+	 * @param {string} source
+	 * @param {number} level
+	 * @returns {string}
+	 */
+	function nested(source, level) {
+		if (level <= 0) {
+			return /[]/.source;
+		} else {
+			return source.replace(/<SELF>/g, function () { return nested(source, level - 1); });
+		}
+	}
+
+	var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/;
+
+	var escape = {
+		pattern: /''/,
+		greedy: true,
+		alias: 'operator'
+	};
+	var string = {
+		pattern: stringPattern,
+		greedy: true,
+		inside: {
+			'escape': escape
+		}
+	};
+
+	var argumentSource = nested(
+		/\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source
+			.replace(/<STR>/g, function () { return stringPattern.source; }),
+		8
+	);
+
+	var nestedMessage = {
+		pattern: RegExp(argumentSource),
+		inside: {
+			'message': {
+				pattern: /^(\{)[\s\S]+(?=\}$)/,
+				lookbehind: true,
+				inside: null // see below
+			},
+			'message-delimiter': {
+				pattern: /./,
+				alias: 'punctuation'
+			}
+		}
+	};
+
+	Prism.languages['icu-message-format'] = {
+		'argument': {
+			pattern: RegExp(argumentSource),
+			greedy: true,
+			inside: {
+				'content': {
+					pattern: /^(\{)[\s\S]+(?=\}$)/,
+					lookbehind: true,
+					inside: {
+						'argument-name': {
+							pattern: /^(\s*)[^{}:=,\s]+/,
+							lookbehind: true
+						},
+						'choice-style': {
+							// https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details
+							pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,
+							lookbehind: true,
+							inside: {
+								'punctuation': /\|/,
+								'range': {
+									pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,
+									lookbehind: true,
+									inside: {
+										'operator': /[<#\u2264]/,
+										'number': /\S+/
+									}
+								},
+								rest: null // see below
+							}
+						},
+						'plural-style': {
+							// https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+							pattern: /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,
+							lookbehind: true,
+							inside: {
+								'offset': /^offset:\s*\d+/,
+								'nested-message': nestedMessage,
+								'selector': {
+									pattern: /=\d+|[^{}:=,\s]+/,
+									inside: {
+										'keyword': /^(?:few|many|one|other|two|zero)$/
+									}
+								}
+							}
+						},
+						'select-style': {
+							// https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+							pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,
+							lookbehind: true,
+							inside: {
+								'nested-message': nestedMessage,
+								'selector': {
+									pattern: /[^{}:=,\s]+/,
+									inside: {
+										'keyword': /^other$/
+									}
+								}
+							}
+						},
+						'keyword': /\b(?:choice|plural|select|selectordinal)\b/,
+						'arg-type': {
+							pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/,
+							alias: 'keyword'
+						},
+						'arg-skeleton': {
+							pattern: /(,\s*)::[^{}:=,\s]+/,
+							lookbehind: true
+						},
+						'arg-style': {
+							pattern: /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,
+							lookbehind: true
+						},
+						'arg-style-text': {
+							pattern: RegExp(/(^\s*,\s*(?=\S))/.source + nested(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source, 8) + '$'),
+							lookbehind: true,
+							alias: 'string'
+						},
+						'punctuation': /,/
+					}
+				},
+				'argument-delimiter': {
+					pattern: /./,
+					alias: 'operator'
+				}
+			}
+		},
+		'escape': escape,
+		'string': string
+	};
+
+	nestedMessage.inside.message.inside = Prism.languages['icu-message-format'];
+	Prism.languages['icu-message-format'].argument.inside.content.inside['choice-style'].inside.rest = Prism.languages['icu-message-format'];
+
+}(Prism));

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

@@ -0,0 +1,19 @@
+Prism.languages.idris = Prism.languages.extend('haskell', {
+	'comment': {
+		pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m,
+	},
+	'keyword': /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,
+	'builtin': undefined
+});
+
+Prism.languages.insertBefore('idris', 'keyword', {
+	'import-statement': {
+		pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,
+		lookbehind: true,
+		inside: {
+			'punctuation': /\./
+		}
+	}
+});
+
+Prism.languages.idr = Prism.languages.idris;

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

@@ -0,0 +1,32 @@
+Prism.languages.iecst = {
+	'comment': [
+		{
+			pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+			lookbehind: true,
+			greedy: true,
+		},
+		{
+			pattern: /(^|[^\\:])\/\/.*/,
+			lookbehind: true,
+			greedy: true,
+		},
+	],
+	'string': {
+		pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+		greedy: true,
+	},
+	'keyword': [
+		/\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i,
+		/\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/
+	],
+	'class-name': /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+	'address': {
+		pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+		alias: 'symbol'
+	},
+	'number': /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+	'boolean': /\b(?:FALSE|NULL|TRUE)\b/,
+	'operator': /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+	'function': /\b[a-z_]\w*(?=\s*\()/i,
+	'punctuation': /[()[\].,;]/,
+};

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

@@ -0,0 +1,23 @@
+(function (Prism) {
+	Prism.languages.ignore = {
+		// https://git-scm.com/docs/gitignore
+		'comment': /^#.*/m,
+		'entry': {
+			pattern: /\S(?:.*(?:(?:\\ )|\S))?/,
+			alias: 'string',
+			inside: {
+				'operator': /^!|\*\*?|\?/,
+				'regex': {
+					pattern: /(^|[^\\])\[[^\[\]]*\]/,
+					lookbehind: true
+				},
+				'punctuation': /\//
+			}
+		}
+	};
+
+	Prism.languages.gitignore = Prism.languages.ignore;
+	Prism.languages.hgignore = Prism.languages.ignore;
+	Prism.languages.npmignore = Prism.languages.ignore;
+
+}(Prism));