prism-rails 1.6.0.3 → 1.29.0

data/vendor/assets/javascripts/prism/prism-python.js

@@ -1,27 +0,0 @@
-Prism.languages.python= {
-	'triple-quoted-string': {
-		pattern: /"""[\s\S]+?"""|'''[\s\S]+?'''/,
-		alias: 'string'
-	},
-	'comment': {
-		pattern: /(^|[^\\])#.*/,
-		lookbehind: true
-	},
-	'string': {
-		pattern: /("|')(?:\\\\|\\?[^\\\r\n])*?\1/,
-		greedy: true
-	},
-	'function' : {
-		pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_][a-zA-Z0-9_]*(?=\()/g,
-		lookbehind: true
-	},
-	'class-name': {
-		pattern: /(\bclass\s+)[a-z0-9_]+/i,
-		lookbehind: true
-	},
-	'keyword' : /\b(?:as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|pass|print|raise|return|try|while|with|yield)\b/,
-	'boolean' : /\b(?:True|False)\b/,
-	'number' : /\b-?(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
-	'operator' : /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b/,
-	'punctuation' : /[{}[\];(),.:]/
-};

data/vendor/assets/javascripts/prism/prism-r.js

@@ -1,19 +0,0 @@
-Prism.languages.r = {
-	'comment': /#.*/,
-	'string': /(['"])(?:\\?.)*?\1/,
-	'percent-operator': {
-		// Includes user-defined operators
-		// and %%, %*%, %/%, %in%, %o%, %x%
-		pattern: /%[^%\s]*%/,
-		alias: 'operator'
-	},
-	'boolean': /\b(?:TRUE|FALSE)\b/,
-	'ellipsis': /\.\.(?:\.|\d+)/,
-	'number': [
-		/\b(?:NaN|Inf)\b/,
-		/\b(?:0x[\dA-Fa-f]+(?:\.\d*)?|\d*\.?\d+)(?:[EePp][+-]?\d+)?[iL]?\b/
-	],
-	'keyword': /\b(?:if|else|repeat|while|function|for|in|next|break|NULL|NA|NA_integer_|NA_real_|NA_complex_|NA_character_)\b/,
-	'operator': /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
-	'punctuation': /[(){}\[\],;]/
-};

data/vendor/assets/javascripts/prism/prism-rip.js

@@ -1,28 +0,0 @@
-Prism.languages.rip = {
-	'comment': /#.*/,
-
-	'keyword': /(?:=>|->)|\b(?:class|if|else|switch|case|return|exit|try|catch|finally|raise)\b/,
-
-	'builtin': /@|\bSystem\b/,
-
-	'boolean': /\b(?:true|false)\b/,
-
-	'date': /\b\d{4}-\d{2}-\d{2}\b/,
-	'time': /\b\d{2}:\d{2}:\d{2}\b/,
-	'datetime': /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\b/,
-
-	'character': /\B`[^\s`'",.:;#\/\\()<>\[\]{}]\b/,
-
-	'regex': {
-		pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\\\r\n])+\/(?=\s*($|[\r\n,.;})]))/,
-		lookbehind: true
-	},
-
-	'symbol': /:[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/,
-	'string': /("|')(\\?.)*?\1/,
-	'number': /[+-]?(?:(?:\d+\.\d+)|(?:\d+))/,
-
-	'punctuation': /(?:\.{2,3})|[`,.:;=\/\\()<>\[\]{}]/,
-
-	'reference': /[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/
-};

data/vendor/assets/javascripts/prism/prism-ruby.js

@@ -1,116 +0,0 @@
-/**
- * Original by Samuel Flores
- *
- * Adds the following new token classes:
- * 		constant, builtin, variable, symbol, regex
- */
-(function(Prism) {
-	Prism.languages.ruby = Prism.languages.extend('clike', {
-		'comment': /#(?!\{[^\r\n]*?\}).*/,
-		'keyword': /\b(alias|and|BEGIN|begin|break|case|class|def|define_method|defined|do|each|else|elsif|END|end|ensure|false|for|if|in|module|new|next|nil|not|or|raise|redo|require|rescue|retry|return|self|super|then|throw|true|undef|unless|until|when|while|yield)\b/
-	});
-
-	var interpolation = {
-		pattern: /#\{[^}]+\}/,
-		inside: {
-			'delimiter': {
-				pattern: /^#\{|\}$/,
-				alias: 'tag'
-			},
-			rest: Prism.util.clone(Prism.languages.ruby)
-		}
-	};
-
-	Prism.languages.insertBefore('ruby', 'keyword', {
-		'regex': [
-			{
-				pattern: /%r([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1[gim]{0,3}/,
-				inside: {
-					'interpolation': interpolation
-				}
-			},
-			{
-				pattern: /%r\((?:[^()\\]|\\[\s\S])*\)[gim]{0,3}/,
-				inside: {
-					'interpolation': interpolation
-				}
-			},
-			{
-				// Here we need to specifically allow interpolation
-				pattern: /%r\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}[gim]{0,3}/,
-				inside: {
-					'interpolation': interpolation
-				}
-			},
-			{
-				pattern: /%r\[(?:[^\[\]\\]|\\[\s\S])*\][gim]{0,3}/,
-				inside: {
-					'interpolation': interpolation
-				}
-			},
-			{
-				pattern: /%r<(?:[^<>\\]|\\[\s\S])*>[gim]{0,3}/,
-				inside: {
-					'interpolation': interpolation
-				}
-			},
-			{
-				pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/,
-				lookbehind: true
-			}
-		],
-		'variable': /[@$]+[a-zA-Z_][a-zA-Z_0-9]*(?:[?!]|\b)/,
-		'symbol': /:[a-zA-Z_][a-zA-Z_0-9]*(?:[?!]|\b)/
-	});
-
-	Prism.languages.insertBefore('ruby', 'number', {
-		'builtin': /\b(Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|File|Fixnum|Float|Hash|Integer|IO|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|String|Struct|TMS|Symbol|ThreadGroup|Thread|Time|TrueClass)\b/,
-		'constant': /\b[A-Z][a-zA-Z_0-9]*(?:[?!]|\b)/
-	});
-
-	Prism.languages.ruby.string = [
-		{
-			pattern: /%[qQiIwWxs]?([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1/,
-			greedy: true,
-			inside: {
-				'interpolation': interpolation
-			}
-		},
-		{
-			pattern: /%[qQiIwWxs]?\((?:[^()\\]|\\[\s\S])*\)/,
-			greedy: true,
-			inside: {
-				'interpolation': interpolation
-			}
-		},
-		{
-			// Here we need to specifically allow interpolation
-			pattern: /%[qQiIwWxs]?\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}/,
-			greedy: true,
-			inside: {
-				'interpolation': interpolation
-			}
-		},
-		{
-			pattern: /%[qQiIwWxs]?\[(?:[^\[\]\\]|\\[\s\S])*\]/,
-			greedy: true,
-			inside: {
-				'interpolation': interpolation
-			}
-		},
-		{
-			pattern: /%[qQiIwWxs]?<(?:[^<>\\]|\\[\s\S])*>/,
-			greedy: true,
-			inside: {
-				'interpolation': interpolation
-			}
-		},
-		{
-			pattern: /("|')(#\{[^}]+\}|\\(?:\r?\n|\r)|\\?.)*?\1/,
-			greedy: true,
-			inside: {
-				'interpolation': interpolation
-			}
-		}
-	];
-}(Prism));

data/vendor/assets/javascripts/prism/prism-rust.js

@@ -1,53 +0,0 @@
-/* TODO
-	Add support for Markdown notation inside doc comments
-	Add support for nested block comments...
-	Match closure params even when not followed by dash or brace
-	Add better support for macro definition
-*/
-
-Prism.languages.rust = {
-	'comment': [
-		{
-			pattern: /(^|[^\\])\/\*[\w\W]*?\*\//,
-			lookbehind: true
-		},
-		{
-			pattern: /(^|[^\\:])\/\/.*/,
-			lookbehind: true
-		}
-	],
-	'string': [
-		/b?r(#*)"(?:\\?.)*?"\1/,
-		/b?("|')(?:\\?.)*?\1/
-	],
-	'keyword': /\b(?:abstract|alignof|as|be|box|break|const|continue|crate|do|else|enum|extern|false|final|fn|for|if|impl|in|let|loop|match|mod|move|mut|offsetof|once|override|priv|pub|pure|ref|return|sizeof|static|self|struct|super|true|trait|type|typeof|unsafe|unsized|use|virtual|where|while|yield)\b/,
-
-	'attribute': {
-		pattern: /#!?\[.+?\]/,
-		alias: 'attr-name'
-	},
-
-	'function': [
-		/[a-z0-9_]+(?=\s*\()/i,
-		// Macros can use parens or brackets
-		/[a-z0-9_]+!(?=\s*\(|\[)/i
-	],
-	'macro-rules': {
-		pattern: /[a-z0-9_]+!/i,
-		alias: 'function'
-	},
-
-	// Hex, oct, bin, dec numbers with visual separators and type suffix
-	'number': /\b-?(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(\d(_?\d)*)?\.?\d(_?\d)*([Ee][+-]?\d+)?)(?:_?(?:[iu](?:8|16|32|64)?|f32|f64))?\b/,
-
-	// Closure params should not be confused with bitwise OR |
-	'closure-params': {
-		pattern: /\|[^|]*\|(?=\s*[{-])/,
-		inside: {
-			'punctuation': /[\|:,]/,
-			'operator': /[&*]/
-		}
-	},
-	'punctuation': /[{}[\];(),:]|\.+|->/,
-	'operator': /[-+*\/%!^=]=?|@|&[&=]?|\|[|=]?|<<?=?|>>?=?/
-};

data/vendor/assets/javascripts/prism/prism-sas.js

@@ -1,31 +0,0 @@
-Prism.languages.sas = {
-	'datalines': {
-		pattern: /^\s*(?:(?:data)?lines|cards);[\s\S]+?(?:\r?\n|\r);/im,
-		alias: 'string',
-		inside: {
-			'keyword': {
-				pattern: /^(\s*)(?:(?:data)?lines|cards)/i,
-				lookbehind: true
-			},
-			'punctuation': /;/
-		}
-	},
-	'comment': [
-		{
-			pattern: /(^\s*|;\s*)\*.*;/m,
-			lookbehind: true
-		},
-		/\/\*[\s\S]+?\*\//
-	],
-	'datetime': {
-		// '1jan2013'd, '9:25:19pm't, '18jan2003:9:27:05am'dt
-		pattern: /'[^']+'(?:dt?|t)\b/i,
-		alias: 'number'
-	},
-	'string': /(["'])(?:\1\1|(?!\1)[\s\S])*\1/,
-	'keyword': /\b(?:data|else|format|if|input|proc\s\w+|quit|run|then)\b/i,
-	// Decimal (1.2e23), hexadecimal (0c1x)
-	'number': /(?:\B-|\b)(?:[\da-f]+x|\d+(?:\.\d+)?(?:e[+-]?\d+)?)/i,
-	'operator': /\*\*?|\|\|?|!!?|¦¦?|<[>=]?|>[<=]?|[-+\/=&]|[~¬^]=?|\b(?:eq|ne|gt|lt|ge|le|in|not)\b/i,
-	'punctuation': /[$%@.(){}\[\];,\\]/
-};

data/vendor/assets/javascripts/prism/prism-scala.js

@@ -1,18 +0,0 @@
-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
-		},
-	],
-	'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,
-	'symbol': /'[^\d\s\\]\w*/
-});
-delete Prism.languages.scala['class-name'];
-delete Prism.languages.scala['function'];

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

@@ -1,26 +0,0 @@
-Prism.languages.scheme = {
-	'comment' : /;.*/,
-	'string' :  /"(?:[^"\\\r\n]|\\.)*?"|'[^('\s]*/,
-	'keyword' : {
-		pattern : /(\()(?:define(?:-syntax|-library|-values)?|(?:case-)?lambda|let(?:\*|rec)?(?:-values)?|else|if|cond|begin|delay(?:-force)?|parameterize|guard|set!|(?:quasi-)?quote|syntax-rules)/,
-		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\?)/,
-		lookbehind : true
-	},
-	'number' : {
-		pattern: /(\s|\))[-+]?[0-9]*\.?[0-9]+(?:\s*[-+]\s*[0-9]*\.?[0-9]+i)?\b/,
-		lookbehind: true
-	},
-	'boolean' : /#[tf]/,
-	'operator': {
-		pattern: /(\()(?:[-+*%\/]|[<>]=?|=>?)/,
-		lookbehind: true
-	},
-	'function' : {
-		pattern : /(\()[^\s()]*(?=\s)/,
-		lookbehind : true
-	},
-	'punctuation' : /[()]/
-};

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

@@ -1,127 +0,0 @@
-/* TODO
-	Add support for variables inside double quoted strings
-	Add support for {php}
-*/
-
-(function(Prism) {
-
-	var smarty_pattern = /\{\*[\w\W]+?\*\}|\{[\w\W]+?\}/g;
-	var smarty_litteral_start = '{literal}';
-	var smarty_litteral_end = '{/literal}';
-	var smarty_litteral_mode = false;
-	
-	Prism.languages.smarty = Prism.languages.extend('markup', {
-		'smarty': {
-			pattern: smarty_pattern,
-			inside: {
-				'delimiter': {
-					pattern: /^\{|\}$/i,
-					alias: 'punctuation'
-				},
-				'string': /(["'])(?:\\?.)*?\1/,
-				'number': /\b-?(?:0x[\dA-Fa-f]+|\d*\.?\d+(?:[Ee][-+]?\d+)?)\b/,
-				'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/
-			}
-		}
-	});
-
-	// Comments are inserted at top so that they can
-	// surround markup
-	Prism.languages.insertBefore('smarty', 'tag', {
-		'smarty-comment': {
-			pattern: /\{\*[\w\W]*?\*\}/,
-			alias: ['smarty','comment']
-		}
-	});
-
-	// Tokenize all inline Smarty expressions
-	Prism.hooks.add('before-highlight', function(env) {
-		if (env.language !== 'smarty') {
-			return;
-		}
-
-		env.tokenStack = [];
-
-		env.backupCode = env.code;
-		env.code = env.code.replace(smarty_pattern, function(match) {
-
-			// Smarty tags inside {literal} block are ignored
-			if(match === smarty_litteral_end) {
-				smarty_litteral_mode = false;
-			}
-
-			if(!smarty_litteral_mode) {
-				if(match === smarty_litteral_start) {
-					smarty_litteral_mode = true;
-				}
-				env.tokenStack.push(match);
-
-				return '___SMARTY' + env.tokenStack.length + '___';
-			}
-			return match;
-		});
-	});
-
-	// Restore env.code for other plugins (e.g. line-numbers)
-	Prism.hooks.add('before-insert', function(env) {
-		if (env.language === 'smarty') {
-			env.code = env.backupCode;
-			delete env.backupCode;
-		}
-	});
-
-	// Re-insert the tokens after highlighting
-	// and highlight them with defined grammar
-	Prism.hooks.add('after-highlight', function(env) {
-		if (env.language !== 'smarty') {
-			return;
-		}
-
-		for (var i = 0, t; t = env.tokenStack[i]; i++) {
-			// The replace prevents $$, $&, $`, $', $n, $nn from being interpreted as special patterns
-			env.highlightedCode = env.highlightedCode.replace('___SMARTY' + (i + 1) + '___', Prism.highlight(t, env.grammar, 'smarty').replace(/\$/g, '$$$$'));
-		}
-
-		env.element.innerHTML = env.highlightedCode;
-	});
-
-}(Prism));

data/vendor/assets/javascripts/prism/prism-sql.js

@@ -1,17 +0,0 @@
-Prism.languages.sql= {
-	'comment': {
-		pattern: /(^|[^\\])(?:\/\*[\w\W]*?\*\/|(?:--|\/\/|#).*)/,
-		lookbehind: true
-	},
-	'string' : {
-		pattern: /(^|[^@\\])("|')(?:\\?[\s\S])*?\2/,
-		lookbehind: true
-	},
-	'variable': /@[\w.$]+|@("|'|`)(?:\\?[\s\S])+?\1/,
-	'function': /\b(?:COUNT|SUM|AVG|MIN|MAX|FIRST|LAST|UCASE|LCASE|MID|LEN|ROUND|NOW|FORMAT)(?=\s*\()/i, // Should we highlight user defined functions too?
-	'keyword': /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR VARYING|CHARACTER (?:SET|VARYING)|CHARSET|CHECK|CHECKPOINT|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMN|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS|CONTAINSTABLE|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|DATA(?:BASES?)?|DATE(?:TIME)?|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITER(?:S)?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE(?: PRECISION)?|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE KEY|ELSE|ENABLE|ENCLOSED BY|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPE(?:D BY)?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|IDENTITY(?:_INSERT|COL)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTO|INVOKER|ISOLATION LEVEL|JOIN|KEYS?|KILL|LANGUAGE SQL|LAST|LEFT|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MODIFIES SQL DATA|MODIFY|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL(?: CHAR VARYING| CHARACTER(?: VARYING)?| VARCHAR)?|NATURAL|NCHAR(?: VARCHAR)?|NEXT|NO(?: SQL|CHECK|CYCLE)?|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READ(?:S SQL DATA|TEXT)?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEATABLE|REPLICATION|REQUIRE|RESTORE|RESTRICT|RETURNS?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE MODE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|START(?:ING BY)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED BY|TEXT(?:SIZE)?|THEN|TIMESTAMP|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNPIVOT|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?)\b/i,
-	'boolean': /\b(?:TRUE|FALSE|NULL)\b/i,
-	'number': /\b-?(?:0x)?\d*\.?[\da-f]+\b/,
-	'operator': /[-+*\/=%^~]|&&?|\|?\||!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|IN|LIKE|NOT|OR|IS|DIV|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
-	'punctuation': /[;[\]()`,.]/
-};

data/vendor/assets/javascripts/prism/prism-stylus.js

@@ -1,102 +0,0 @@
-(function (Prism) {
-	var inside = {
-		'url': /url\((["']?).*?\1\)/i,
-		'string': /("|')(?:[^\\\r\n]|\\(?:\r\n|[\s\S]))*?\1/,
-		'interpolation': null, // See below
-		'func': null, // See below
-		'important': /\B!(?:important|optional)\b/i,
-		'keyword': {
-			pattern: /(^|\s+)(?:(?:if|else|for|return|unless)(?=\s+|$)|@[\w-]+)/,
-			lookbehind: true
-		},
-		'hexcode': /#[\da-f]{3,6}/i,
-		'number': /\b\d+(?:\.\d+)?%?/,
-		'boolean': /\b(?:true|false)\b/,
-		'operator': [
-			// We want non-word chars around "-" because it is
-			// accepted in property names.
-			/~|[+!\/%<>?=]=?|[-:]=|\*[*=]?|\.+|&&|\|\||\B-\B|\b(?:and|in|is(?: a| defined| not|nt)?|not|or)\b/
-		],
-		'punctuation': /[{}()\[\];:,]/
-	};
-
-	inside['interpolation'] = {
-		pattern: /\{[^\r\n}:]+\}/,
-		alias: 'variable',
-		inside: Prism.util.clone(inside)
-	};
-	inside['func'] = {
-		pattern: /[\w-]+\([^)]*\).*/,
-		inside: {
-			'function': /^[^(]+/,
-			rest: Prism.util.clone(inside)
-		}
-	};
-
-	Prism.languages.stylus = {
-		'comment': {
-			pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|\/\/.*)/,
-			lookbehind: true
-		},
-		'atrule-declaration': {
-			pattern: /(^\s*)@.+/m,
-			lookbehind: true,
-			inside: {
-				'atrule': /^@[\w-]+/,
-				rest: inside
-			}
-		},
-		'variable-declaration': {
-			pattern: /(^[ \t]*)[\w$-]+\s*.?=[ \t]*(?:(?:\{[^}]*\}|.+)|$)/m,
-			lookbehind: true,
-			inside: {
-				'variable': /^\S+/,
-				rest: inside
-			}
-		},
-
-		'statement': {
-			pattern: /(^[ \t]*)(?:if|else|for|return|unless)[ \t]+.+/m,
-			lookbehind: true,
-			inside: {
-				keyword: /^\S+/,
-				rest: inside
-			}
-		},
-
-		// A property/value pair cannot end with a comma or a brace
-		// It cannot have indented content unless it ended with a semicolon
-		'property-declaration': {
-			pattern: /((?:^|\{)([ \t]*))(?:[\w-]|\{[^}\r\n]+\})+(?:\s*:\s*|[ \t]+)[^{\r\n]*(?:;|[^{\r\n,](?=$)(?!(\r?\n|\r)(?:\{|\2[ \t]+)))/m,
-			lookbehind: true,
-			inside: {
-				'property': {
-					pattern: /^[^\s:]+/,
-					inside: {
-						'interpolation': inside.interpolation
-					}
-				},
-				rest: inside
-			}
-		},
-
-
-
-		// A selector can contain parentheses only as part of a pseudo-element
-		// It can span multiple lines.
-		// It must end with a comma or an accolade or have indented content.
-		'selector': {
-			pattern: /(^[ \t]*)(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\))?|\{[^}\r\n]+\})+)(?:(?:\r?\n|\r)(?:\1(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\))?|\{[^}\r\n]+\})+)))*(?:,$|\{|(?=(?:\r?\n|\r)(?:\{|\1[ \t]+)))/m,
-			lookbehind: true,
-			inside: {
-				'interpolation': inside.interpolation,
-				'punctuation': /[{},]/
-			}
-		},
-
-		'func': inside.func,
-		'string': inside.string,
-		'interpolation': inside.interpolation,
-		'punctuation': /[{}()\[\];:.]/
-	};
-}(Prism));

data/vendor/assets/javascripts/prism/prism-swift.js

@@ -1,25 +0,0 @@
-// issues: nested multiline comments
-Prism.languages.swift = Prism.languages.extend('clike', {
-	'string': {
-		pattern: /("|')(\\(?:\((?:[^()]|\([^)]+\))+\)|\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-		greedy: true,
-		inside: {
-			'interpolation': {
-				pattern: /\\\((?:[^()]|\([^)]+\))+\)/,
-				inside: {
-					delimiter: {
-						pattern: /^\\\(|\)$/,
-						alias: 'variable'
-					}
-					// See rest below
-				}
-			}
-		}
-	},
-	'keyword': /\b(as|associativity|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic(?:Type)?|else|enum|extension|fallthrough|final|for|func|get|guard|if|import|in|infix|init|inout|internal|is|lazy|left|let|mutating|new|none|nonmutating|operator|optional|override|postfix|precedence|prefix|private|Protocol|public|repeat|required|rethrows|return|right|safe|self|Self|set|static|struct|subscript|super|switch|throws?|try|Type|typealias|unowned|unsafe|var|weak|where|while|willSet|__(?:COLUMN__|FILE__|FUNCTION__|LINE__))\b/,
-	'number': /\b([\d_]+(\.[\de_]+)?|0x[a-f0-9_]+(\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
-	'constant': /\b(nil|[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
-	'atrule': /@\b(IB(?:Outlet|Designable|Action|Inspectable)|class_protocol|exported|noreturn|NS(?:Copying|Managed)|objc|UIApplicationMain|auto_closure)\b/,
-	'builtin': /\b([A-Z]\S+|abs|advance|alignof(?:Value)?|assert|contains|count(?:Elements)?|debugPrint(?:ln)?|distance|drop(?:First|Last)|dump|enumerate|equal|filter|find|first|getVaList|indices|isEmpty|join|last|lexicographicalCompare|map|max(?:Element)?|min(?:Element)?|numericCast|overlaps|partition|print(?:ln)?|reduce|reflect|reverse|sizeof(?:Value)?|sort(?:ed)?|split|startsWith|stride(?:of(?:Value)?)?|suffix|swap|toDebugString|toString|transcode|underestimateCount|unsafeBitCast|with(?:ExtendedLifetime|Unsafe(?:MutablePointers?|Pointers?)|VaList))\b/
-});
-Prism.languages.swift['string'].inside['interpolation'].inside.rest = Prism.util.clone(Prism.languages.swift);

data/vendor/assets/javascripts/prism/prism-tcl.js

@@ -1,43 +0,0 @@
-Prism.languages.tcl = {
-	'comment': {
-		pattern: /(^|[^\\])#.*/,
-		lookbehind: true
-	},
-	'string': /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"/,
-	'variable': [
-		{
-			pattern: /(\$)(?:::)?(?:[a-zA-Z0-9]+::)*[a-zA-Z0-9_]+/,
-			lookbehind: true
-		},
-		{
-			pattern: /(\$){[^}]+}/,
-			lookbehind: true
-		},
-		{
-			pattern: /(^\s*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*[a-zA-Z0-9_]+/m,
-			lookbehind: true
-		}
-	],
-	'function': {
-		pattern: /(^\s*proc[ \t]+)[^\s]+/m,
-		lookbehind: true
-	},
-	'builtin': [
-		{
-			pattern: /(^\s*)(?:proc|return|class|error|eval|exit|for|foreach|if|switch|while|break|continue)\b/m,
-			lookbehind: true
-		},
-		/\b(elseif|else)\b/
-	],
-	'scope': {
-		pattern: /(^\s*)(global|upvar|variable)\b/m,
-		lookbehind: true,
-		alias: 'constant'
-	},
-	'keyword': {
-		pattern: /(^\s*|\[)(after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|Safe_Base|scan|seek|set|socket|source|split|string|subst|Tcl|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|wordBreak(?:After|Before)|test|vars)|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
-		lookbehind: true
-	},
-	'operator': /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|ne|in|ni)\b/,
-	'punctuation': /[{}()\[\]]/
-};