prism-rails 1.6.0.3 → 1.19.0

data/vendor/assets/javascripts/{prism → languages}/prism-sass.js

@@ -20,7 +20,7 @@
 	delete Prism.languages.sass.atrule;
 
 
-	var variable = /((\$[-_\w]+)|(#\{\$[-_\w]+\}))/i;
+	var variable = /\$[-\w]+|#\{\$[-\w]+\}/;
 	var operator = [
 		/[+*\/%]|[=!]=|<=?|>=?|\b(?:and|or|not)\b/,
 		{
@@ -62,7 +62,6 @@
 
 	// Now that whole lines for other patterns are consumed,
 	// what's left should be selectors
-	delete Prism.languages.sass.selector;
 	Prism.languages.insertBefore('sass', 'punctuation', {
 		'selector': {
 			pattern: /([ \t]*)\S(?:,?[^,\r\n]+)*(?:,(?:\r?\n|\r)\1[ \t]+\S(?:,?[^,\r\n]+)*)*/,

data/vendor/assets/javascripts/{prism → languages}/prism-scala.js

@@ -1,17 +1,16 @@
 Prism.languages.scala = Prism.languages.extend('java', {
 	'keyword': /<-|=>|\b(?:abstract|case|catch|class|def|do|else|extends|final|finally|for|forSome|if|implicit|import|lazy|match|new|null|object|override|package|private|protected|return|sealed|self|super|this|throw|trait|try|type|val|var|while|with|yield)\b/,
-	'string': [
-		{
-			pattern: /"""[\W\w]*?"""/,
-			greedy: true
-		},
-		{
-			pattern: /("|')(?:\\\\|\\?[^\\\r\n])*?\1/,
-			greedy: true
-		},
-	],
+	'triple-quoted-string': {
+		pattern: /"""[\s\S]*?"""/,
+		greedy: true,
+		alias: 'string'
+	},
+	'string': {
+		pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+		greedy: true
+	},
 	'builtin': /\b(?:String|Int|Long|Short|Byte|Boolean|Double|Float|Char|Any|AnyRef|AnyVal|Unit|Nothing)\b/,
-	'number': /\b(?:0x[\da-f]*\.?[\da-f]+|\d*\.?\d+e?\d*[dfl]?)\b/i,
+	'number': /\b0x[\da-f]*\.?[\da-f]+|(?:\b\d+\.?\d*|\B\.\d+)(?:e\d+)?[dfl]?/i,
 	'symbol': /'[^\d\s\\]\w*/
 });
 delete Prism.languages.scala['class-name'];

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

@@ -0,0 +1,33 @@
+Prism.languages.scheme = {
+	'comment': /;.*/,
+	'string': {
+		pattern: /"(?:[^"\\]|\\.)*"|'[^()#'\s]+/,
+		greedy: true
+	},
+	'character': {
+		pattern: /#\\(?:[ux][a-fA-F\d]+|[a-zA-Z]+|\S)/,
+		alias: 'string'
+	},
+	'keyword': {
+		pattern: /(\()(?:define(?:-syntax|-library|-values)?|(?:case-)?lambda|let(?:\*|rec)?(?:-values)?|else|if|cond|begin|delay(?:-force)?|parameterize|guard|set!|(?:quasi-)?quote|syntax-rules)(?=[()\s])/,
+		lookbehind: true
+	},
+	'builtin': {
+		pattern: /(\()(?:(?:cons|car|cdr|list|call-with-current-continuation|call\/cc|append|abs|apply|eval)\b|null\?|pair\?|boolean\?|eof-object\?|char\?|procedure\?|number\?|port\?|string\?|vector\?|symbol\?|bytevector\?)(?=[()\s])/,
+		lookbehind: true
+	},
+	'number': {
+		pattern: /([\s()])[-+]?(?:\d+\/\d+|\d*\.?\d+(?:\s*[-+]\s*\d*\.?\d+i)?)\b/,
+		lookbehind: true
+	},
+	'boolean': /#[tf]/,
+	'operator': {
+		pattern: /(\()(?:[-+*%\/]|[<>]=?|=>?)(?=\s|$)/,
+		lookbehind: true
+	},
+	'function': {
+		pattern: /(\()[^()'\s]+(?=[()\s)]|$)/,
+		lookbehind: true
+	},
+	'punctuation': /[()']/
+};

data/vendor/assets/javascripts/{prism → languages}/prism-scss.js

@@ -1,6 +1,6 @@
 Prism.languages.scss = Prism.languages.extend('css', {
 	'comment': {
-		pattern: /(^|[^\\])(?:\/\*[\w\W]*?\*\/|\/\/.*)/,
+		pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
 		lookbehind: true
 	},
 	'atrule': {
@@ -11,7 +11,7 @@ Prism.languages.scss = Prism.languages.extend('css', {
 		}
 	},
 	// url, compassified
-	'url': /(?:[-a-z]+-)*url(?=\()/i,
+	'url': /(?:[-a-z]+-)?url(?=\()/i,
 	// CSS selector regex is not appropriate for Sass
 	// since there can be lot more things (var, @ directive, nesting..)
 	// a selector must start at the end of a property or after a brace (end of other rules or nesting)
@@ -21,14 +21,20 @@ Prism.languages.scss = Prism.languages.extend('css', {
 	// this one was hard to do, so please be careful if you edit this one :)
 	'selector': {
 		// Initial look-ahead is used to prevent matching of blank selectors
-		pattern: /(?=\S)[^@;\{\}\(\)]?([^@;\{\}\(\)]|&|#\{\$[-_\w]+\})+(?=\s*\{(\}|\s|[^\}]+(:|\{)[^\}]+))/m,
+		pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()]|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}]+[:{][^}]+))/m,
 		inside: {
 			'parent': {
 				pattern: /&/,
 				alias: 'important'
 			},
-			'placeholder': /%[-_\w]+/,
-			'variable': /\$[-_\w]+|#\{\$[-_\w]+\}/
+			'placeholder': /%[-\w]+/,
+			'variable': /\$[-\w]+|#\{\$[-\w]+\}/
+		}
+	},
+	'property': {
+		pattern: /(?:[\w-]|\$[-\w]+|#\{\$[-\w]+\})+(?=\s*:)/,
+		inside: {
+			'variable': /\$[-\w]+|#\{\$[-\w]+\}/
 		}
 	}
 });
@@ -43,21 +49,14 @@ Prism.languages.insertBefore('scss', 'atrule', {
 	]
 });
 
-Prism.languages.scss.property = {
-	pattern: /(?:[\w-]|\$[-_\w]+|#\{\$[-_\w]+\})+(?=\s*:)/i,
-	inside: {
-		'variable': /\$[-_\w]+|#\{\$[-_\w]+\}/
-	}
-};
-
 Prism.languages.insertBefore('scss', 'important', {
 	// var and interpolated vars
-	'variable': /\$[-_\w]+|#\{\$[-_\w]+\}/
+	'variable': /\$[-\w]+|#\{\$[-\w]+\}/
 });
 
 Prism.languages.insertBefore('scss', 'function', {
 	'placeholder': {
-		pattern: /%[-_\w]+/,
+		pattern: /%[-\w]+/,
 		alias: 'selector'
 	},
 	'statement': {
@@ -65,11 +64,14 @@ Prism.languages.insertBefore('scss', 'function', {
 		alias: 'keyword'
 	},
 	'boolean': /\b(?:true|false)\b/,
-	'null': /\bnull\b/,
+	'null': {
+		pattern: /\bnull\b/,
+		alias: 'keyword'
+	},
 	'operator': {
 		pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|or|not)(?=\s)/,
 		lookbehind: true
 	}
 });
 
-Prism.languages.scss['atrule'].inside.rest = Prism.util.clone(Prism.languages.scss);
+Prism.languages.scss['atrule'].inside.rest = Prism.languages.scss;

data/vendor/assets/javascripts/languages/prism-shell-session.js

@@ -0,0 +1,54 @@
+(function (Prism) {
+
+	// CAREFUL!
+	// The following patterns are concatenated, so the group referenced by a back reference is non-obvious!
+
+	var strings = [
+		// normal string
+		// 1 capturing group
+		/(["'])(?:\\[\s\S]|\$\([^)]+\)|`[^`]+`|(?!\1)[^\\])*\1/.source,
+
+		// here doc
+		// 1 capturing group
+		/<<-?\s*(\w+?)\s*(?:\r?\n|\r)[\s\S]*?(?:\r?\n|\r)\2/.source,
+
+		// here doc quoted
+		// 2 capturing group
+		/<<-?\s*(["'])(\w+)\3\s*(?:\r?\n|\r)[\s\S]*?(?:\r?\n|\r)\4/.source
+	].join('|');
+
+	Prism.languages['shell-session'] = {
+		'info': {
+			// foo@bar:~/files$ exit
+			// foo@bar$ exit
+			pattern: /^(?:[^\r\n$#*!]+)(?=[$#])/m,
+			alias: 'punctuation',
+			inside: {
+				'path': {
+					pattern: /(:)[\s\S]+/,
+					lookbehind: true
+				},
+				'user': /^[^\s@:$#*!/\\]+@[^\s@:$#*!/\\]+(?=:|$)/,
+				'punctuation': /:/
+			}
+		},
+		'command': {
+			pattern: RegExp(/[$#](?:[^\r\n'"<]|<<str>>)+/.source.replace(/<<str>>/g, strings)),
+			greedy: true,
+			inside: {
+				'bash': {
+					pattern: /(^[$#]\s*)[\s\S]+/,
+					lookbehind: true,
+					alias: 'language-bash',
+					inside: Prism.languages.bash
+				},
+				'shell-symbol': {
+					pattern: /^[$#]/,
+					alias: 'important'
+				}
+			}
+		},
+		'output': /.(?:.*(?:\r\n?|\n|.$))*/
+	};
+
+}(Prism));

data/vendor/assets/javascripts/{prism → languages}/prism-smalltalk.js

@@ -1,9 +1,13 @@
 Prism.languages.smalltalk = {
-	'comment': /"(?:""|[^"])+"/,
-	'string': /'(?:''|[^'])+'/,
+	'comment': /"(?:""|[^"])*"/,
+	'character': {
+		pattern: /\$./,
+		alias: 'string'
+	},
+	'string': /'(?:''|[^'])*'/,
 	'symbol': /#[\da-z]+|#(?:-|([+\/\\*~<>=@%|&?!])\1?)|#(?=\()/i,
 	'block-arguments': {
-		pattern: /(\[\s*):[^\[|]*?\|/,
+		pattern: /(\[\s*):[^\[|]*\|/,
 		lookbehind: true,
 		inside: {
 			'variable': /:[\da-z]+/i,
@@ -18,14 +22,10 @@ Prism.languages.smalltalk = {
 		}
 	},
 	'keyword': /\b(?:nil|true|false|self|super|new)\b/,
-	'character': {
-		pattern: /\$./,
-		alias: 'string'
-	},
 	'number': [
 		/\d+r-?[\dA-Z]+(?:\.[\dA-Z]+)?(?:e-?\d+)?/,
-		/(?:\B-|\b)\d+(?:\.\d+)?(?:e-?\d+)?/
+		/\b\d+(?:\.\d+)?(?:e-?\d+)?/
 	],
 	'operator': /[<=]=?|:=|~[~=]|\/\/?|\\\\|>[>=]?|[!^+\-*&|,@]/,
 	'punctuation': /[.;:?\[\](){}]/
-};
+};

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

@@ -0,0 +1,87 @@
+/* TODO
+	Add support for variables inside double quoted strings
+	Add support for {php}
+*/
+
+(function(Prism) {
+
+	Prism.languages.smarty = {
+		'comment': /\{\*[\s\S]*?\*\}/,
+		'delimiter': {
+			pattern: /^\{|\}$/i,
+			alias: 'punctuation'
+		},
+		'string': /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+		'number': /\b0x[\dA-Fa-f]+|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+		'variable': [
+			/\$(?!\d)\w+/,
+			/#(?!\d)\w+#/,
+			{
+				pattern: /(\.|->)(?!\d)\w+/,
+				lookbehind: true
+			},
+			{
+				pattern: /(\[)(?!\d)\w+(?=\])/,
+				lookbehind: true
+			}
+		],
+		'function': [
+			{
+				pattern: /(\|\s*)@?(?!\d)\w+/,
+				lookbehind: true
+			},
+			/^\/?(?!\d)\w+/,
+			/(?!\d)\w+(?=\()/
+		],
+		'attr-name': {
+			// Value is made optional because it may have already been tokenized
+			pattern: /\w+\s*=\s*(?:(?!\d)\w+)?/,
+			inside: {
+				"variable": {
+					pattern: /(=\s*)(?!\d)\w+/,
+					lookbehind: true
+				},
+				"operator": /=/
+			}
+		},
+		'punctuation': [
+			/[\[\]().,:`]|->/
+		],
+		'operator': [
+			/[+\-*\/%]|==?=?|[!<>]=?|&&|\|\|?/,
+			/\bis\s+(?:not\s+)?(?:div|even|odd)(?:\s+by)?\b/,
+			/\b(?:eq|neq?|gt|lt|gt?e|lt?e|not|mod|or|and)\b/
+		],
+		'keyword': /\b(?:false|off|on|no|true|yes)\b/
+	};
+
+	// Tokenize all inline Smarty expressions
+	Prism.hooks.add('before-tokenize', function(env) {
+		var smartyPattern = /\{\*[\s\S]*?\*\}|\{[\s\S]+?\}/g;
+		var smartyLitteralStart = '{literal}';
+		var smartyLitteralEnd = '{/literal}';
+		var smartyLitteralMode = false;
+
+		Prism.languages['markup-templating'].buildPlaceholders(env, 'smarty', smartyPattern, function (match) {
+			// Smarty tags inside {literal} block are ignored
+			if(match === smartyLitteralEnd) {
+				smartyLitteralMode = false;
+			}
+
+			if(!smartyLitteralMode) {
+				if(match === smartyLitteralStart) {
+					smartyLitteralMode = true;
+				}
+
+				return true;
+			}
+			return false;
+		});
+	});
+
+	// Re-insert the tokens after tokenizing
+	Prism.hooks.add('after-tokenize', function(env) {
+		Prism.languages['markup-templating'].tokenizePlaceholders(env, 'smarty');
+	});
+
+}(Prism));

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

@@ -0,0 +1,20 @@
+Prism.languages.solidity = Prism.languages.extend('clike', {
+	'class-name': {
+		pattern: /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
+		lookbehind: true
+	},
+	'keyword': /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
+	'operator': /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
+});
+
+Prism.languages.insertBefore('solidity', 'keyword', {
+	'builtin': /\b(?:address|bool|string|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|byte|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/
+});
+
+Prism.languages.insertBefore('solidity', 'number', {
+	'version': {
+		pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
+		lookbehind: true,
+		alias: 'number',
+	}
+});

data/vendor/assets/javascripts/languages/prism-solution-file.js

@@ -0,0 +1,51 @@
+(function (Prism){
+
+	var guid = {
+		// https://en.wikipedia.org/wiki/Universally_unique_identifier#Format
+		pattern: /\{[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\}/i,
+		alias: 'constant',
+		inside: {
+			'punctuation': /[{}]/
+		}
+	};
+
+	Prism.languages['solution-file'] = {
+		'comment': {
+			pattern: /#.*/,
+			greedy: true
+		},
+		'string': {
+			pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+			greedy: true,
+			inside: {
+				'guid': guid
+			}
+		},
+		'object': {
+			// Foo
+			//   Bar("abs") = 9
+			//   EndBar
+			//   Prop = TRUE
+			// EndFoo
+			pattern: /^([ \t]*)(?:([A-Z]\w*)\b(?=.*(?:\r\n?|\n)(?:\1[ \t].*(?:\r\n?|\n))*\1End\2(?=[ \t]*$))|End[A-Z]\w*(?=[ \t]*$))/m,
+			lookbehind: true,
+			greedy: true,
+			alias: 'keyword'
+		},
+		'property': {
+			pattern: /^([ \t]*)[^\r\n"#=()]*[^\s"#=()](?=\s*=)/m,
+			lookbehind: true,
+			inside: {
+				'guid': guid
+			}
+		},
+		'guid': guid,
+		'number': /\b\d+(?:\.\d+)*\b/,
+		'boolean': /\b(?:FALSE|TRUE)\b/,
+		'operator': /=/,
+		'punctuation': /[(),]/
+	};
+
+	Prism.languages['sln'] = Prism.languages['solution-file'];
+
+}(Prism));

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

@@ -0,0 +1,96 @@
+(function (Prism) {
+	var stringPattern = /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+	var numberPattern = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-F]+\b/;
+
+	Prism.languages.soy = {
+		'comment': [
+			/\/\*[\s\S]*?\*\//,
+			{
+				pattern: /(\s)\/\/.*/,
+				lookbehind: true,
+				greedy: true
+			}
+		],
+		'command-arg': {
+			pattern: /({+\/?\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\s+)\.?[\w.]+/,
+			lookbehind: true,
+			alias: 'string',
+			inside: {
+				'punctuation': /\./
+			}
+		},
+		'parameter': {
+			pattern: /({+\/?\s*@?param\??\s+)\.?[\w.]+/,
+			lookbehind: true,
+			alias: 'variable'
+		},
+		'keyword': [
+			{
+				pattern: /({+\/?[^\S\r\n]*)(?:\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\??|rb|sp|switch|template|xid)/,
+				lookbehind: true
+			},
+			/\b(?:any|as|attributes|bool|css|float|in|int|js|html|list|map|null|number|string|uri)\b/
+		],
+		'delimiter': {
+			pattern: /^{+\/?|\/?}+$/,
+			alias: 'punctuation'
+		},
+		'property': /\w+(?==)/,
+		'variable': {
+			pattern: /\$[^\W\d]\w*(?:\??(?:\.\w+|\[[^\]]+]))*/,
+			inside: {
+				'string': {
+					pattern: stringPattern,
+					greedy: true
+				},
+				'number': numberPattern,
+				'punctuation': /[\[\].?]/
+			}
+		},
+		'string': {
+			pattern: stringPattern,
+			greedy: true
+		},
+		'function': [
+			/\w+(?=\()/,
+			{
+				pattern: /(\|[^\S\r\n]*)\w+/,
+				lookbehind: true
+			}
+		],
+		'boolean': /\b(?:true|false)\b/,
+		'number': numberPattern,
+		'operator': /\?:?|<=?|>=?|==?|!=|[+*/%-]|\b(?:and|not|or)\b/,
+		'punctuation': /[{}()\[\]|.,:]/
+	};
+
+	// Tokenize all inline Soy expressions
+	Prism.hooks.add('before-tokenize', function (env) {
+		var soyPattern = /{{.+?}}|{.+?}|\s\/\/.*|\/\*[\s\S]*?\*\//g;
+		var soyLitteralStart = '{literal}';
+		var soyLitteralEnd = '{/literal}';
+		var soyLitteralMode = false;
+
+		Prism.languages['markup-templating'].buildPlaceholders(env, 'soy', soyPattern, function (match) {
+			// Soy tags inside {literal} block are ignored
+			if (match === soyLitteralEnd) {
+				soyLitteralMode = false;
+			}
+
+			if (!soyLitteralMode) {
+				if (match === soyLitteralStart) {
+					soyLitteralMode = true;
+				}
+
+				return true;
+			}
+			return false;
+		});
+	});
+
+	// Re-insert the tokens after tokenizing
+	Prism.hooks.add('after-tokenize', function (env) {
+		Prism.languages['markup-templating'].tokenizePlaceholders(env, 'soy');
+	});
+
+}(Prism));