prism-rails 1.19.0 → 1.29.0

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

@@ -1,126 +1,145 @@
-(function(Prism) {
+(function (Prism) {
+
+	var javascript = Prism.util.clone(Prism.languages.javascript);
+
+	var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
+	var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
+	var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+
+	/**
+	 * @param {string} source
+	 * @param {string} [flags]
+	 */
+	function re(source, flags) {
+		source = source
+			.replace(/<S>/g, function () { return space; })
+			.replace(/<BRACES>/g, function () { return braces; })
+			.replace(/<SPREAD>/g, function () { return spread; });
+		return RegExp(source, flags);
+	}
+
+	spread = re(spread).source;
 
-var javascript = Prism.util.clone(Prism.languages.javascript);
 
-Prism.languages.jsx = Prism.languages.extend('markup', javascript);
-Prism.languages.jsx.tag.pattern= /<\/?(?:[\w.:-]+\s*(?:\s+(?:[\w.:$-]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s{'">=]+|\{(?:\{(?:\{[^}]*\}|[^{}])*\}|[^{}])+\}))?|\{\s*\.{3}\s*[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\s*\}))*\s*\/?)?>/i;
+	Prism.languages.jsx = Prism.languages.extend('markup', javascript);
+	Prism.languages.jsx.tag.pattern = re(
+		/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
+	);
 
-Prism.languages.jsx.tag.inside['tag'].pattern = /^<\/?[^\s>\/]*/i;
-Prism.languages.jsx.tag.inside['attr-value'].pattern = /=(?!\{)(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">]+)/i;
-Prism.languages.jsx.tag.inside['tag'].inside['class-name'] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
+	Prism.languages.jsx.tag.inside['tag'].pattern = /^<\/?[^\s>\/]*/;
+	Prism.languages.jsx.tag.inside['attr-value'].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
+	Prism.languages.jsx.tag.inside['tag'].inside['class-name'] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
+	Prism.languages.jsx.tag.inside['comment'] = javascript['comment'];
 
-Prism.languages.insertBefore('inside', 'attr-name', {
-	'spread': {
-		pattern: /\{\s*\.{3}\s*[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\s*\}/,
-		inside: {
-			'punctuation': /\.{3}|[{}.]/,
-			'attr-value': /\w+/
+	Prism.languages.insertBefore('inside', 'attr-name', {
+		'spread': {
+			pattern: re(/<SPREAD>/.source),
+			inside: Prism.languages.jsx
 		}
-	}
-}, Prism.languages.jsx.tag);
-
-Prism.languages.insertBefore('inside', 'attr-value',{
-	'script': {
-		// Allow for two levels of nesting
-		pattern: /=(?:\{(?:\{(?:\{[^}]*\}|[^}])*\}|[^}])+\})/i,
-		inside: {
-			'script-punctuation': {
-				pattern: /^=(?={)/,
-				alias: 'punctuation'
+	}, Prism.languages.jsx.tag);
+
+	Prism.languages.insertBefore('inside', 'special-attr', {
+		'script': {
+			// Allow for two levels of nesting
+			pattern: re(/=<BRACES>/.source),
+			alias: 'language-javascript',
+			inside: {
+				'script-punctuation': {
+					pattern: /^=(?=\{)/,
+					alias: 'punctuation'
+				},
+				rest: Prism.languages.jsx
 			},
-			rest: Prism.languages.jsx
-		},
-		'alias': 'language-javascript'
-	}
-}, Prism.languages.jsx.tag);
+		}
+	}, Prism.languages.jsx.tag);
 
-// The following will handle plain text inside tags
-var stringifyToken = function (token) {
-	if (!token) {
-		return '';
-	}
-	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
+	// The following will handle plain text inside tags
+	var stringifyToken = function (token) {
+		if (!token) {
+			return '';
+		}
+		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 {
-						// Opening tag
-						openedTags.push({
-							tagName: stringifyToken(token.content[0].content[1]),
-							openedBraces: 0
-						});
+						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 === '{') {
+				} else if (openedTags.length > 0 && token.type === 'punctuation' && token.content === '{') {
 
-				// Here we might have entered a JSX context inside a tag
-				openedTags[openedTags.length - 1].openedBraces++;
+					// Here we might have entered a JSX context inside a tag
+					openedTags[openedTags.length - 1].openedBraces++;
 
-			} else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === 'punctuation' && token.content === '}') {
+				} else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === 'punctuation' && token.content === '}') {
 
-				// Here we might have left a JSX context inside a tag
-				openedTags[openedTags.length - 1].openedBraces--;
+					// Here we might have left a JSX context inside a tag
+					openedTags[openedTags.length - 1].openedBraces--;
 
-			} else {
-				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 a JSX context.
-				// 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);
+				} else {
+					notTagNorBrace = true;
 				}
-				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 (notTagNorBrace || typeof token === 'string') {
+				if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+					// Here we are inside a tag, and not inside a JSX context.
+					// 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--;
+					}
+
+					tokens[i] = new Prism.Token('plain-text', plainText, null, plainText);
 				}
+			}
 
-				tokens[i] = new Prism.Token('plain-text', plainText, null, plainText);
+			if (token.content && typeof token.content !== 'string') {
+				walkTokens(token.content);
 			}
 		}
+	};
 
-		if (token.content && typeof token.content !== 'string') {
-			walkTokens(token.content);
+	Prism.hooks.add('after-tokenize', function (env) {
+		if (env.language !== 'jsx' && env.language !== 'tsx') {
+			return;
 		}
-	}
-};
-
-Prism.hooks.add('after-tokenize', function (env) {
-	if (env.language !== 'jsx' && env.language !== 'tsx') {
-		return;
-	}
-	walkTokens(env.tokens);
-});
+		walkTokens(env.tokens);
+	});
 
 }(Prism));

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

@@ -1,13 +1,35 @@
-Prism.languages.julia= {
+Prism.languages.julia = {
 	'comment': {
-		pattern: /(^|[^\\])#.*/,
+		// support one level of nested comments
+		// https://github.com/JuliaLang/julia/pull/6128
+		pattern: /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/,
 		lookbehind: true
 	},
-	'string': /("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2/,
-	'keyword' : /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/,
-	'boolean' : /\b(?:true|false)\b/,
-	'number' : /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+\.?\d*|\.\d+)(?:[efp][+-]?\d+)?j?/i,
-	'operator': /[-+*^%÷&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥]/,
-	'punctuation' : /[{}[\];(),.:]/,
-	'constant': /\b(?:(?:NaN|Inf)(?:16|32|64)?)\b/
+	'regex': {
+		// https://docs.julialang.org/en/v1/manual/strings/#Regular-Expressions-1
+		pattern: /r"(?:\\.|[^"\\\r\n])*"[imsx]{0,4}/,
+		greedy: true
+	},
+	'string': {
+		// https://docs.julialang.org/en/v1/manual/strings/#String-Basics-1
+		// https://docs.julialang.org/en/v1/manual/strings/#non-standard-string-literals-1
+		// https://docs.julialang.org/en/v1/manual/running-external-programs/#Running-External-Programs-1
+		pattern: /"""[\s\S]+?"""|(?:\b\w+)?"(?:\\.|[^"\\\r\n])*"|`(?:[^\\`\r\n]|\\.)*`/,
+		greedy: true
+	},
+	'char': {
+		// https://docs.julialang.org/en/v1/manual/strings/#man-characters-1
+		pattern: /(^|[^\w'])'(?:\\[^\r\n][^'\r\n]*|[^\\\r\n])'/,
+		lookbehind: true,
+		greedy: true
+	},
+	'keyword': /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/,
+	'boolean': /\b(?:false|true)\b/,
+	'number': /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+(?:_[\da-f]+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[efp][+-]?\d+(?:_\d+)*)?j?/i,
+	// https://docs.julialang.org/en/v1/manual/mathematical-operations/
+	// https://docs.julialang.org/en/v1/manual/mathematical-operations/#Operator-Precedence-and-Associativity-1
+	'operator': /&&|\|\||[-+*^%÷⊻&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥'√∛]/,
+	'punctuation': /::?|[{}[\]();,.?]/,
+	// https://docs.julialang.org/en/v1/base/numbers/#Base.im
+	'constant': /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[πℯ]/
 };

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

@@ -0,0 +1,51 @@
+Prism.languages.keepalived = {
+	'comment': {
+		pattern: /[#!].*/,
+		greedy: true
+	},
+	'string': {
+		pattern: /(^|[^\\])(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/,
+		lookbehind: true,
+		greedy: true
+	},
+
+	// support IPv4, IPv6, subnet mask
+	'ip': {
+		pattern: RegExp(
+			/\b(?:(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){5}:(?:[\da-f]{1,4}:)?[\da-f]{1,4}|(?:[\da-f]{1,4}:){4}:(?:[\da-f]{1,4}:){0,2}[\da-f]{1,4}|(?:[\da-f]{1,4}:){3}:(?:[\da-f]{1,4}:){0,3}[\da-f]{1,4}|(?:[\da-f]{1,4}:){2}:(?:[\da-f]{1,4}:){0,4}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}<ipv4>|(?:[\da-f]{1,4}:){0,5}:<ipv4>|::(?:[\da-f]{1,4}:){0,5}<ipv4>|[\da-f]{1,4}::(?:[\da-f]{1,4}:){0,5}[\da-f]{1,4}|::(?:[\da-f]{1,4}:){0,6}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:)(?:\/\d{1,3})?|<ipv4>(?:\/\d{1,2})?)\b/.source
+				.replace(/<ipv4>/g, function () { return /(?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d))/.source; }),
+			'i'
+		),
+		alias: 'number'
+	},
+
+	// support *nix / Windows, directory / file
+	'path': {
+		pattern: /(\s)\/(?:[^\/\s]+\/)*[^\/\s]*|\b[a-zA-Z]:\\(?:[^\\\s]+\\)*[^\\\s]*/,
+		lookbehind: true,
+		alias: 'string',
+	},
+	'variable': /\$\{?\w+\}?/,
+	'email': {
+		pattern: /[\w-]+@[\w-]+(?:\.[\w-]{2,3}){1,2}/,
+		alias: 'string',
+	},
+	'conditional-configuration': {
+		pattern: /@\^?[\w-]+/,
+		alias: 'variable'
+	},
+	'operator': /=/,
+
+	'property': /\b(?:BFD_CHECK|DNS_CHECK|FILE_CHECK|HTTP_GET|MISC_CHECK|NAME|PING_CHECK|SCRIPTS|SMTP_CHECK|SSL|SSL_GET|TCP_CHECK|UDP_CHECK|accept|advert_int|alpha|auth_pass|auth_type|authentication|bfd_cpu_affinity|bfd_instance|bfd_no_swap|bfd_priority|bfd_process_name|bfd_rlimit_rttime|bfd_rt_priority|bind_if|bind_port|bindto|ca|certificate|check_unicast_src|checker|checker_cpu_affinity|checker_log_all_failures|checker_no_swap|checker_priority|checker_rlimit_rttime|checker_rt_priority|child_wait_time|connect_ip|connect_port|connect_timeout|dbus_service_name|debug|default_interface|delay|delay_before_retry|delay_loop|digest|dont_track_primary|dynamic|dynamic_interfaces|enable_(?:dbus|script_security|sni|snmp_checker|snmp_rfc|snmp_rfcv2|snmp_rfcv3|snmp_vrrp|traps)|end|fall|fast_recovery|file|flag-[123]|fork_delay|full_command|fwmark|garp_group|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|global_defs|global_tracking|gna_interval|group|ha_suspend|hashed|helo_name|higher_prio_send_advert|hoplimit|http_protocol|hysteresis|idle_tx|include|inhibit_on_failure|init_fail|init_file|instance|interface|interfaces|interval|ip_family|ipvs_process_name|keepalived.conf|kernel_rx_buf_size|key|linkbeat_interfaces|linkbeat_use_polling|log_all_failures|log_unknown_vrids|lower_prio_no_advert|lthreshold|lvs_flush|lvs_flush_onstop|lvs_method|lvs_netlink_cmd_rcv_bufs|lvs_netlink_cmd_rcv_bufs_force|lvs_netlink_monitor_rcv_bufs|lvs_netlink_monitor_rcv_bufs_force|lvs_notify_fifo|lvs_notify_fifo_script|lvs_sched|lvs_sync_daemon|max_auto_priority|max_hops|mcast_src_ip|mh-fallback|mh-port|min_auto_priority_delay|min_rx|min_tx|misc_dynamic|misc_path|misc_timeout|multiplier|name|namespace_with_ipsets|native_ipv6|neighbor_ip|net_namespace|net_namespace_ipvs|nftables|nftables_counters|nftables_ifindex|nftables_priority|no_accept|no_checker_emails|no_email_faults|nopreempt|notification_email|notification_email_from|notify|notify_backup|notify_deleted|notify_down|notify_fault|notify_fifo|notify_fifo_script|notify_master|notify_master_rx_lower_pri|notify_priority_changes|notify_stop|notify_up|old_unicast_checksum|omega|ops|param_match|passive|password|path|persistence_engine|persistence_granularity|persistence_timeout|preempt|preempt_delay|priority|process|process_monitor_rcv_bufs|process_monitor_rcv_bufs_force|process_name|process_names|promote_secondaries|protocol|proxy_arp|proxy_arp_pvlan|quorum|quorum_down|quorum_max|quorum_up|random_seed|real_server|regex|regex_max_offset|regex_min_offset|regex_no_match|regex_options|regex_stack|reload_repeat|reload_time_file|require_reply|retry|rise|router_id|rs_init_notifies|script|script_user|sh-fallback|sh-port|shutdown_script|shutdown_script_timeout|skip_check_adv_addr|smtp_alert|smtp_alert_checker|smtp_alert_vrrp|smtp_connect_timeout|smtp_helo_name|smtp_server|snmp_socket|sorry_server|sorry_server_inhibit|sorry_server_lvs_method|source_ip|start|startup_script|startup_script_timeout|state|static_ipaddress|static_routes|static_rules|status_code|step|strict_mode|sync_group_tracking_weight|terminate_delay|timeout|track_bfd|track_file|track_group|track_interface|track_process|track_script|track_src_ip|ttl|type|umask|unicast_peer|unicast_src_ip|unicast_ttl|url|use_ipvlan|use_pid_dir|use_vmac|user|uthreshold|val[123]|version|virtual_ipaddress|virtual_ipaddress_excluded|virtual_router_id|virtual_routes|virtual_rules|virtual_server|virtual_server_group|virtualhost|vmac_xmit_base|vrrp|vrrp_(?:check_unicast_src|cpu_affinity|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|gna_interval|higher_prio_send_advert|instance|ipsets|iptables|lower_prio_no_advert|mcast_group4|mcast_group6|min_garp|netlink_cmd_rcv_bufs|netlink_cmd_rcv_bufs_force|netlink_monitor_rcv_bufs|netlink_monitor_rcv_bufs_force|no_swap|notify_fifo|notify_fifo_script|notify_priority_changes|priority|process_name|rlimit_rttime|rt_priority|rx_bufs_multiplier|rx_bufs_policy|script|skip_check_adv_addr|startup_delay|strict|sync_group|track_process|version)|warmup|weight)\b/,
+
+	'constant': /\b(?:A|AAAA|AH|BACKUP|CNAME|DR|MASTER|MX|NAT|NS|PASS|SCTP|SOA|TCP|TUN|TXT|UDP|dh|fo|lblc|lblcr|lc|mh|nq|ovf|rr|sed|sh|wlc|wrr)\b/,
+
+	'number': {
+		pattern: /(^|[^\w.-])-?\d+(?:\.\d+)?/,
+		lookbehind: true
+	},
+
+	'boolean': /\b(?:false|no|off|on|true|yes)\b/,
+
+	'punctuation': /[\{\}]/
+};

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

@@ -1,14 +1,44 @@
 Prism.languages.keyman = {
-	'comment': /\bc\s.*/i,
-	'function': /\[\s*(?:(?:CTRL|SHIFT|ALT|LCTRL|RCTRL|LALT|RALT|CAPS|NCAPS)\s+)*(?:[TKU]_[\w?]+|".+?"|'.+?')\s*\]/i,  // virtual key
-	'string': /("|').*?\1/,
-	'bold': [   // header statements, system stores and variable system stores
-		/&(?:baselayout|bitmap|capsononly|capsalwaysoff|shiftfreescaps|copyright|ethnologuecode|hotkey|includecodes|keyboardversion|kmw_embedcss|kmw_embedjs|kmw_helpfile|kmw_helptext|kmw_rtl|language|layer|layoutfile|message|mnemoniclayout|name|oldcharposmatching|platform|targets|version|visualkeyboard|windowslanguages)\b/i,
-		/\b(?:bitmap|bitmaps|caps on only|caps always off|shift frees caps|copyright|hotkey|language|layout|message|name|version)\b/i
-	],
-	'keyword': /\b(?:any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|return|reset|save|set|store|use)\b/i,  // rule keywords
-	'atrule': /\b(?:ansi|begin|unicode|group|using keys|match|nomatch)\b/i,   // structural keywords
-	'number': /\b(?:U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i, // U+####, x###, d### characters and numbers
-	'operator': /[+>\\,()]/,
-	'tag': /\$(?:keyman|kmfl|weaver|keymanweb|keymanonly):/i   // prefixes
-};
+	'comment': {
+		pattern: /\bc .*/i,
+		greedy: true
+	},
+	'string': {
+		pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+		greedy: true
+	},
+	'virtual-key': {
+		pattern: /\[\s*(?:(?:ALT|CAPS|CTRL|LALT|LCTRL|NCAPS|RALT|RCTRL|SHIFT)\s+)*(?:[TKU]_[\w?]+|[A-E]\d\d?|"[^"\r\n]*"|'[^'\r\n]*')\s*\]/i,
+		greedy: true,
+		alias: 'function' // alias for styles
+	},
+
+	// https://help.keyman.com/developer/language/guide/headers
+	'header-keyword': {
+		pattern: /&\w+/,
+		alias: 'bold' // alias for styles
+	},
+	'header-statement': {
+		pattern: /\b(?:bitmap|bitmaps|caps always off|caps on only|copyright|hotkey|language|layout|message|name|shift frees caps|version)\b/i,
+		alias: 'bold' // alias for styles
+	},
+
+	'rule-keyword': {
+		pattern: /\b(?:any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|reset|return|save|set|store|use)\b/i,
+		alias: 'keyword'
+	},
+	'structural-keyword': {
+		pattern: /\b(?:ansi|begin|group|match|newcontext|nomatch|postkeystroke|readonly|unicode|using keys)\b/i,
+		alias: 'keyword'
+	},
+
+	'compile-target': {
+		pattern: /\$(?:keyman|keymanonly|keymanweb|kmfl|weaver):/i,
+		alias: 'property'
+	},
+
+	// U+####, x###, d### characters and numbers
+	'number': /\b(?:U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i,
+	'operator': /[+>\\$]|\.\./,
+	'punctuation': /[()=,]/
+};

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

@@ -6,57 +6,83 @@
 			lookbehind: true
 		},
 		'function': [
-			/\w+(?=\s*\()/,
 			{
-				pattern: /(\.)\w+(?=\s*\{)/,
-				lookbehind: true
+				pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+				greedy: true
+			},
+			{
+				pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+				lookbehind: true,
+				greedy: true
 			}
 		],
 		'number': /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
 		'operator': /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
 	});
 
-	delete Prism.languages.kotlin["class-name"];
+	delete Prism.languages.kotlin['class-name'];
+
+	var interpolationInside = {
+		'interpolation-punctuation': {
+			pattern: /^\$\{?|\}$/,
+			alias: 'punctuation'
+		},
+		'expression': {
+			pattern: /[\s\S]+/,
+			inside: Prism.languages.kotlin
+		}
+	};
 
 	Prism.languages.insertBefore('kotlin', 'string', {
-		'raw-string': {
-			pattern: /("""|''')[\s\S]*?\1/,
-			alias: 'string'
-			// See interpolation below
+		// https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
+		'string-literal': [
+			{
+				pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+				alias: 'multiline',
+				inside: {
+					'interpolation': {
+						pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+						inside: interpolationInside
+					},
+					'string': /[\s\S]+/
+				}
+			},
+			{
+				pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+				alias: 'singleline',
+				inside: {
+					'interpolation': {
+						pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+						lookbehind: true,
+						inside: interpolationInside
+					},
+					'string': /[\s\S]+/
+				}
+			}
+		],
+		'char': {
+			// https://kotlinlang.org/spec/expressions.html#character-literals
+			pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+			greedy: true
 		}
 	});
+
+	delete Prism.languages.kotlin['string'];
+
 	Prism.languages.insertBefore('kotlin', 'keyword', {
 		'annotation': {
 			pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
 			alias: 'builtin'
 		}
 	});
+
 	Prism.languages.insertBefore('kotlin', 'function', {
 		'label': {
-			pattern: /\w+@|@\w+/,
+			pattern: /\b\w+@|@\w+\b/,
 			alias: 'symbol'
 		}
 	});
 
-	var interpolation = [
-		{
-			pattern: /\$\{[^}]+\}/,
-			inside: {
-				'delimiter': {
-					pattern: /^\$\{|\}$/,
-					alias: 'variable'
-				},
-				rest: Prism.languages.kotlin
-			}
-		},
-		{
-			pattern: /\$\w+/,
-			alias: 'variable'
-		}
-	];
-
-	Prism.languages.kotlin['string'].inside = Prism.languages.kotlin['raw-string'].inside = {
-		interpolation: interpolation
-	};
-
+	Prism.languages.kt = Prism.languages.kotlin;
+	Prism.languages.kts = Prism.languages.kotlin;
 }(Prism));

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

@@ -0,0 +1,106 @@
+/* eslint-disable regexp/no-dupe-characters-character-class */
+(function (Prism) {
+
+	/**
+	 * Regular expression for characters that are not allowed in identifiers.
+	 *
+	 * @type {string}
+	 */
+	var nonId = /\s\x00-\x1f\x22-\x2f\x3a-\x3f\x5b-\x5e\x60\x7b-\x7e/.source;
+
+	/**
+	 * Surround a regular expression for IDs with patterns for non-ID sequences.
+	 *
+	 * @param {string} pattern A regular expression for identifiers.
+	 * @param {string} [flags] The regular expression flags.
+	 * @returns {RegExp} A wrapped regular expression for identifiers.
+	 */
+	function wrapId(pattern, flags) {
+		return RegExp(pattern.replace(/<nonId>/g, nonId), flags);
+	}
+
+	Prism.languages.kumir = {
+		'comment': {
+			pattern: /\|.*/
+		},
+
+		'prolog': {
+			pattern: /#.*/,
+			greedy: true
+		},
+
+		'string': {
+			pattern: /"[^\n\r"]*"|'[^\n\r']*'/,
+			greedy: true
+		},
+
+		'boolean': {
+			pattern: wrapId(/(^|[<nonId>])(?:да|нет)(?=[<nonId>]|$)/.source),
+			lookbehind: true
+		},
+
+		'operator-word': {
+			pattern: wrapId(/(^|[<nonId>])(?:и|или|не)(?=[<nonId>]|$)/.source),
+			lookbehind: true,
+			alias: 'keyword'
+		},
+
+		'system-variable': {
+			pattern: wrapId(/(^|[<nonId>])знач(?=[<nonId>]|$)/.source),
+			lookbehind: true,
+			alias: 'keyword'
+		},
+
+		'type': [
+			{
+				pattern: wrapId(/(^|[<nonId>])(?:вещ|лит|лог|сим|цел)(?:\x20*таб)?(?=[<nonId>]|$)/.source),
+				lookbehind: true,
+				alias: 'builtin'
+			},
+			{
+				pattern: wrapId(/(^|[<nonId>])(?:компл|сканкод|файл|цвет)(?=[<nonId>]|$)/.source),
+				lookbehind: true,
+				alias: 'important'
+			}
+		],
+
+		/**
+		 * Should be performed after searching for type names because of "таб".
+		 * "таб" is a reserved word, but never used without a preceding type name.
+		 * "НАЗНАЧИТЬ", "Фввод", and "Фвывод" are not reserved words.
+		 */
+		'keyword': {
+			pattern: wrapId(/(^|[<nonId>])(?:алг|арг(?:\x20*рез)?|ввод|ВКЛЮЧИТЬ|вс[её]|выбор|вывод|выход|дано|для|до|дс|если|иначе|исп|использовать|кон(?:(?:\x20+|_)исп)?|кц(?:(?:\x20+|_)при)?|надо|нач|нс|нц|от|пауза|пока|при|раза?|рез|стоп|таб|то|утв|шаг)(?=[<nonId>]|$)/.source),
+			lookbehind: true
+		},
+
+		/** Should be performed after searching for reserved words. */
+		'name': {
+			// eslint-disable-next-line regexp/no-super-linear-backtracking
+			pattern: wrapId(/(^|[<nonId>])[^\d<nonId>][^<nonId>]*(?:\x20+[^<nonId>]+)*(?=[<nonId>]|$)/.source),
+			lookbehind: true
+		},
+
+		/** Should be performed after searching for names. */
+		'number': {
+			pattern: wrapId(/(^|[<nonId>])(?:\B\$[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?=[<nonId>]|$)/.source, 'i'),
+			lookbehind: true
+		},
+
+		/** Should be performed after searching for words. */
+		'punctuation': /:=|[(),:;\[\]]/,
+
+		/**
+		 * Should be performed after searching for
+		 * - numeric constants (because of "+" and "-");
+		 * - punctuation marks (because of ":=" and "=").
+		 */
+		'operator-char': {
+			pattern: /\*\*?|<[=>]?|>=?|[-+/=]/,
+			alias: 'operator'
+		}
+	};
+
+	Prism.languages.kum = Prism.languages.kumir;
+
+}(Prism));