prism-rails 1.6.0.3 → 1.19.0

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

@@ -1,18 +1,17 @@
 Prism.languages.jolie = Prism.languages.extend('clike', {
-	'keyword': /\b(?:include|define|is_defined|undef|main|init|outputPort|inputPort|Location|Protocol|Interfaces|RequestResponse|OneWay|type|interface|extender|throws|cset|csets|forward|Aggregates|Redirects|embedded|courier|extender|execution|sequential|concurrent|single|scope|install|throw|comp|cH|default|global|linkIn|linkOut|synchronized|this|new|for|if|else|while|in|Jolie|Java|Javascript|nullProcess|spawn|constants|with|provide|until|exit|foreach|instanceof|over|service)\b/g,
+	'keyword': /\b(?:include|define|is_defined|undef|main|init|outputPort|inputPort|Location|Protocol|Interfaces|RequestResponse|OneWay|type|interface|extender|throws|cset|csets|forward|Aggregates|Redirects|embedded|courier|execution|sequential|concurrent|single|scope|install|throw|comp|cH|default|global|linkIn|linkOut|synchronized|this|new|for|if|else|while|in|Jolie|Java|Javascript|nullProcess|spawn|constants|with|provide|until|exit|foreach|instanceof|over|service)\b/,
 	'builtin': /\b(?:undefined|string|int|void|long|Byte|bool|double|float|char|any)\b/,
-	'number': /\b\d*\.?\d+(?:e[+-]?\d+)?l?\b/i,
-	'operator': /->|<<|[!+-<>=*]?=|[:<>!?*\/%^]|&&|\|\||--?|\+\+?/g,
+	'number': /(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?l?/i,
+	'operator': /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[:?\/%^]/,
 	'symbol': /[|;@]/,
 	'punctuation': /[,.]/,
 	'string': {
-		pattern: /(["'])(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+		pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
 		greedy: true
-	},
+	}
 });
 
 delete Prism.languages.jolie['class-name'];
-delete Prism.languages.jolie['function'];
 
 Prism.languages.insertBefore( 'jolie', 'keyword', {
 	'function':
@@ -24,7 +23,7 @@ Prism.languages.insertBefore( 'jolie', 'keyword', {
 		pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/,
 		lookbehind: true,
 		inside: {
-			'withExtension': {
+			'with-extension': {
 				pattern: /\bwith\s+\w+/,
 				inside: {
 					'keyword' : /\bwith\b/
@@ -46,11 +45,11 @@ Prism.languages.insertBefore( 'jolie', 'keyword', {
 				pattern: /,/
 			},
 			'function': {
-				pattern: /\w+/g
+				pattern: /\w+/
 			},
 			'symbol': {
-				pattern: /=>/g
+				pattern: /=>/
 			}
 		}
 	}
-});
+});

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

@@ -0,0 +1,67 @@
+(function (Prism) {
+
+	var interpolation = /\\\((?:[^()]|\([^()]*\))*\)/.source;
+	var string = RegExp(/"(?:[^"\r\n\\]|\\[^\r\n(]|__)*"/.source.replace(/__/g, interpolation));
+	var stringInterpolation = {
+		'interpolation': {
+			pattern: RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + interpolation),
+			lookbehind: true,
+			inside: {
+				'content': {
+					pattern: /^(\\\()[\s\S]+(?=\)$)/,
+					lookbehind: true,
+					inside: null // see below
+				},
+				'punctuation': /^\\\(|\)$/
+			}
+		}
+	};
+
+	var jq = Prism.languages.jq = {
+		'comment': /#.*/,
+		'property': {
+			pattern: RegExp(string.source + /(?=\s*:(?!:))/.source),
+			greedy: true,
+			inside: stringInterpolation
+		},
+		'string': {
+			pattern: string,
+			greedy: true,
+			inside: stringInterpolation
+		},
+
+		'function': {
+			pattern: /(\bdef\s+)[a-z_]\w+/i,
+			lookbehind: true
+		},
+
+		'variable': /\B\$\w+/,
+		'property-literal': {
+			pattern: /[a-z_]\w*(?=\s*:(?!:))/i,
+			alias: 'property'
+		},
+		'keyword': /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/,
+		'boolean': /\b(?:true|false)\b/,
+		'number': /(?:\b\d+\.|\B\.)?\d+(?:[eE][+-]?\d+)?\b/,
+
+		'operator': [
+			{
+				pattern: /\|=?/,
+				alias: 'pipe'
+			},
+			/\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|or|not)\b/
+		],
+		'c-style-function': {
+			pattern: /\b[a-z_]\w*(?=\s*\()/i,
+			alias: 'function'
+		},
+		'punctuation': /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/,
+		'dot': {
+			pattern: /\./,
+			alias: 'important'
+		}
+	}
+
+	stringInterpolation.interpolation.inside.content.inside = jq;
+
+}(Prism));

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

@@ -0,0 +1,104 @@
+(function (Prism) {
+
+	Prism.languages.insertBefore('javascript', 'function-variable', {
+		'method-variable': {
+			pattern: RegExp('(\\.\\s*)' + Prism.languages.javascript['function-variable'].pattern.source),
+			lookbehind: true,
+			alias: ['function-variable', 'method', 'function', 'property-access']
+		}
+	});
+
+	Prism.languages.insertBefore('javascript', 'function', {
+		'method': {
+			pattern: RegExp('(\\.\\s*)' + Prism.languages.javascript['function'].source),
+			lookbehind: true,
+			alias: ['function', 'property-access']
+		}
+	});
+
+	Prism.languages.insertBefore('javascript', 'constant', {
+		'known-class-name': [
+			{
+				// standard built-ins
+				// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+				pattern: /\b(?:(?:(?:Uint|Int)(?:8|16|32)|Uint8Clamped|Float(?:32|64))?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|(?:Weak)?(?:Set|Map)|WebAssembly)\b/,
+				alias: 'class-name'
+			},
+			{
+				// errors
+				pattern: /\b(?:[A-Z]\w*)Error\b/,
+				alias: 'class-name'
+			}
+		]
+	});
+
+	Prism.languages.javascript['keyword'].unshift(
+		{
+			pattern: /\b(?:as|default|export|from|import)\b/,
+			alias: 'module'
+		},
+		{
+			pattern: /\bnull\b/,
+			alias: ['null', 'nil']
+		},
+		{
+			pattern: /\bundefined\b/,
+			alias: 'nil'
+		}
+	);
+
+	Prism.languages.insertBefore('javascript', 'operator', {
+		'spread': {
+			pattern: /\.{3}/,
+			alias: 'operator'
+		},
+		'arrow': {
+			pattern: /=>/,
+			alias: 'operator'
+		}
+	});
+
+	Prism.languages.insertBefore('javascript', 'punctuation', {
+		'property-access': {
+			pattern: /(\.\s*)#?[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*/,
+			lookbehind: true
+		},
+		'maybe-class-name': {
+			pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
+			lookbehind: true
+		},
+		'dom': {
+			// this contains only a few commonly used DOM variables
+			pattern: /\b(?:document|location|navigator|performance|(?:local|session)Storage|window)\b/,
+			alias: 'variable'
+		},
+		'console': {
+			pattern: /\bconsole(?=\s*\.)/,
+			alias: 'class-name'
+		}
+	});
+
+
+	// add 'maybe-class-name' to tokens which might be a class name
+	var maybeClassNameTokens = ['function', 'function-variable', 'method', 'method-variable', 'property-access'];
+
+	for (var i = 0; i < maybeClassNameTokens.length; i++) {
+		var token = maybeClassNameTokens[i];
+		var value = Prism.languages.javascript[token];
+
+		// convert regex to object
+		if (Prism.util.type(value) === 'RegExp') {
+			value = Prism.languages.javascript[token] = {
+				pattern: value
+			};
+		}
+
+		// keep in mind that we don't support arrays
+
+		var inside = value.inside || {};
+		value.inside = inside;
+
+		inside['maybe-class-name'] = /^[A-Z][\s\S]*/;
+	}
+
+}(Prism));

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

@@ -0,0 +1,346 @@
+(function (Prism) {
+
+	var templateString = Prism.languages.javascript['template-string'];
+
+	// see the pattern in prism-javascript.js
+	var templateLiteralPattern = templateString.pattern.source;
+	var interpolationObject = templateString.inside['interpolation'];
+	var interpolationPunctuationObject = interpolationObject.inside['interpolation-punctuation'];
+	var interpolationPattern = interpolationObject.pattern.source;
+
+
+	/**
+	 * Creates a new pattern to match a template string with a special tag.
+	 *
+	 * This will return `undefined` if there is no grammar with the given language id.
+	 *
+	 * @param {string} language The language id of the embedded language. E.g. `markdown`.
+	 * @param {string} tag The regex pattern to match the tag.
+	 * @returns {object | undefined}
+	 * @example
+	 * createTemplate('css', /\bcss/.source);
+	 */
+	function createTemplate(language, tag) {
+		if (!Prism.languages[language]) {
+			return undefined;
+		}
+
+		return {
+			pattern: RegExp('((?:' + tag + ')\\s*)' + templateLiteralPattern),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				'template-punctuation': {
+					pattern: /^`|`$/,
+					alias: 'string'
+				},
+				'embedded-code': {
+					pattern: /[\s\S]+/,
+					alias: language
+				}
+			}
+		};
+	}
+
+
+	Prism.languages.javascript['template-string'] = [
+		// styled-jsx:
+		//   css`a { color: #25F; }`
+		// styled-components:
+		//   styled.h1`color: red;`
+		createTemplate('css', /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source),
+
+		// html`<p></p>`
+		// div.innerHTML = `<p></p>`
+		createTemplate('html', /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source),
+
+		// svg`<path fill="#fff" d="M55.37 ..."/>`
+		createTemplate('svg', /\bsvg/.source),
+
+		// md`# h1`, markdown`## h2`
+		createTemplate('markdown', /\b(?:md|markdown)/.source),
+
+		// gql`...`, graphql`...`, graphql.experimental`...`
+		createTemplate('graphql', /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source),
+
+		// vanilla template string
+		templateString
+	].filter(Boolean);
+
+
+	/**
+	 * Returns a specific placeholder literal for the given language.
+	 *
+	 * @param {number} counter
+	 * @param {string} language
+	 * @returns {string}
+	 */
+	function getPlaceholder(counter, language) {
+		return '___' + language.toUpperCase() + '_' + counter + '___';
+	}
+
+	/**
+	 * Returns the tokens of `Prism.tokenize` but also runs the `before-tokenize` and `after-tokenize` hooks.
+	 *
+	 * @param {string} code
+	 * @param {any} grammar
+	 * @param {string} language
+	 * @returns {(string|Token)[]}
+	 */
+	function tokenizeWithHooks(code, grammar, language) {
+		var env = {
+			code: code,
+			grammar: grammar,
+			language: language
+		};
+		Prism.hooks.run('before-tokenize', env);
+		env.tokens = Prism.tokenize(env.code, env.grammar);
+		Prism.hooks.run('after-tokenize', env);
+		return env.tokens;
+	}
+
+	/**
+	 * Returns the token of the given JavaScript interpolation expression.
+	 *
+	 * @param {string} expression The code of the expression. E.g. `"${42}"`
+	 * @returns {Token}
+	 */
+	function tokenizeInterpolationExpression(expression) {
+		var tempGrammar = {};
+		tempGrammar['interpolation-punctuation'] = interpolationPunctuationObject;
+
+		/** @type {Array} */
+		var tokens = Prism.tokenize(expression, tempGrammar);
+		if (tokens.length === 3) {
+			/**
+			 * The token array will look like this
+			 * [
+			 *     ["interpolation-punctuation", "${"]
+			 *     "..." // JavaScript expression of the interpolation
+			 *     ["interpolation-punctuation", "}"]
+			 * ]
+			 */
+
+			var args = [1, 1];
+			args.push.apply(args, tokenizeWithHooks(tokens[1], Prism.languages.javascript, 'javascript'));
+
+			tokens.splice.apply(tokens, args);
+		}
+
+		return new Prism.Token('interpolation', tokens, interpolationObject.alias, expression);
+	}
+
+	/**
+	 * Tokenizes the given code with support for JavaScript interpolation expressions mixed in.
+	 *
+	 * This function has 3 phases:
+	 *
+	 * 1. Replace all JavaScript interpolation expression with a placeholder.
+	 *    The placeholder will have the syntax of a identify of the target language.
+	 * 2. Tokenize the code with placeholders.
+	 * 3. Tokenize the interpolation expressions and re-insert them into the tokenize code.
+	 *    The insertion only works if a placeholder hasn't been "ripped apart" meaning that the placeholder has been
+	 *    tokenized as two tokens by the grammar of the embedded language.
+	 *
+	 * @param {string} code
+	 * @param {object} grammar
+	 * @param {string} language
+	 * @returns {Token}
+	 */
+	function tokenizeEmbedded(code, grammar, language) {
+		// 1. First filter out all interpolations
+
+		// because they might be escaped, we need a lookbehind, so we use Prism
+		/** @type {(Token|string)[]} */
+		var _tokens = Prism.tokenize(code, {
+			'interpolation': {
+				pattern: RegExp(interpolationPattern),
+				lookbehind: true
+			}
+		});
+
+		// replace all interpolations with a placeholder which is not in the code already
+		var placeholderCounter = 0;
+		/** @type {Object<string, string>} */
+		var placeholderMap = {};
+		var embeddedCode = _tokens.map(function (token) {
+			if (typeof token === 'string') {
+				return token;
+			} else {
+				var interpolationExpression = token.content;
+
+				var placeholder;
+				while (code.indexOf(placeholder = getPlaceholder(placeholderCounter++, language)) !== -1) { }
+				placeholderMap[placeholder] = interpolationExpression;
+				return placeholder;
+			}
+		}).join('');
+
+
+		// 2. Tokenize the embedded code
+
+		var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language);
+
+
+		// 3. Re-insert the interpolation
+
+		var placeholders = Object.keys(placeholderMap);
+		placeholderCounter = 0;
+
+		/**
+		 *
+		 * @param {(Token|string)[]} tokens
+		 * @returns {void}
+		 */
+		function walkTokens(tokens) {
+			for (var i = 0; i < tokens.length; i++) {
+				if (placeholderCounter >= placeholders.length) {
+					return;
+				}
+
+				var token = tokens[i];
+
+				if (typeof token === 'string' || typeof token.content === 'string') {
+					var placeholder = placeholders[placeholderCounter];
+					var s = typeof token === 'string' ? token : /** @type {string} */ (token.content);
+
+					var index = s.indexOf(placeholder);
+					if (index !== -1) {
+						++placeholderCounter;
+
+						var before = s.substring(0, index);
+						var middle = tokenizeInterpolationExpression(placeholderMap[placeholder]);
+						var after = s.substring(index + placeholder.length);
+
+						var replacement = [];
+						if (before) {
+							replacement.push(before);
+						}
+						replacement.push(middle);
+						if (after) {
+							var afterTokens = [after];
+							walkTokens(afterTokens);
+							replacement.push.apply(replacement, afterTokens);
+						}
+
+						if (typeof token === 'string') {
+							tokens.splice.apply(tokens, [i, 1].concat(replacement));
+							i += replacement.length - 1;
+						} else {
+							token.content = replacement;
+						}
+					}
+				} else {
+					var content = token.content;
+					if (Array.isArray(content)) {
+						walkTokens(content);
+					} else {
+						walkTokens([content]);
+					}
+				}
+			}
+		}
+		walkTokens(embeddedTokens);
+
+		return new Prism.Token(language, embeddedTokens, 'language-' + language, code);
+	}
+
+	/**
+	 * The languages for which JS templating will handle tagged template literals.
+	 *
+	 * JS templating isn't active for only JavaScript but also related languages like TypeScript, JSX, and TSX.
+	 */
+	var supportedLanguages = {
+		'javascript': true,
+		'js': true,
+		'typescript': true,
+		'ts': true,
+		'jsx': true,
+		'tsx': true,
+	};
+	Prism.hooks.add('after-tokenize', function (env) {
+		if (!(env.language in supportedLanguages)) {
+			return;
+		}
+
+		/**
+		 * Finds and tokenizes all template strings with an embedded languages.
+		 *
+		 * @param {(Token | string)[]} tokens
+		 * @returns {void}
+		 */
+		function findTemplateStrings(tokens) {
+			for (var i = 0, l = tokens.length; i < l; i++) {
+				var token = tokens[i];
+
+				if (typeof token === 'string') {
+					continue;
+				}
+
+				var content = token.content;
+				if (!Array.isArray(content)) {
+					if (typeof content !== 'string') {
+						findTemplateStrings([content]);
+					}
+					continue;
+				}
+
+				if (token.type === 'template-string') {
+					/**
+					 * A JavaScript template-string token will look like this:
+					 *
+					 * ["template-string", [
+					 *     ["template-punctuation", "`"],
+					 *     (
+					 *         An array of "string" and "interpolation" tokens. This is the simple string case.
+					 *         or
+					 *         ["embedded-code", "..."] This is the token containing the embedded code.
+					 *                                  It also has an alias which is the language of the embedded code.
+					 *     ),
+					 *     ["template-punctuation", "`"]
+					 * ]]
+					 */
+
+					var embedded = content[1];
+					if (content.length === 3 && typeof embedded !== 'string' && embedded.type === 'embedded-code') {
+						// get string content
+						var code = stringContent(embedded);
+
+						var alias = embedded.alias;
+						var language = Array.isArray(alias) ? alias[0] : alias;
+
+						var grammar = Prism.languages[language];
+						if (!grammar) {
+							// the embedded language isn't registered.
+							continue;
+						}
+
+						content[1] = tokenizeEmbedded(code, grammar, language);
+					}
+				} else {
+					findTemplateStrings(content);
+				}
+			}
+		}
+
+		findTemplateStrings(env.tokens);
+	});
+
+
+	/**
+	 * Returns the string content of a token or token stream.
+	 *
+	 * @param {string | Token | (string | Token)[]} value
+	 * @returns {string}
+	 */
+	function stringContent(value) {
+		if (typeof value === 'string') {
+			return value;
+		} else if (Array.isArray(value)) {
+			return value.map(stringContent).join('');
+		} else {
+			return stringContent(value.content);
+		}
+	}
+
+}(Prism));