[devdocsgjs/main: 833/1867] octave: finish scraper and filters
- From: Andy Holmes <andyholmes src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [devdocsgjs/main: 833/1867] octave: finish scraper and filters
- Date: Fri, 19 Nov 2021 23:47:32 +0000 (UTC)
commit 4da5ae7e732b21c8c78aa94a8355cf89a1365117
Author: Jasper van Merle <jaspervmerle gmail com>
Date: Sat Aug 17 00:02:54 2019 +0200
octave: finish scraper and filters
.../javascripts/templates/pages/about_tmpl.coffee | 5 +
assets/javascripts/vendor/prism.js | 4787 +++++++++++---------
lib/docs/filters/octave/clean_html.rb | 7 +-
lib/docs/filters/octave/entries.rb | 8 +-
lib/docs/scrapers/octave.rb | 2 +-
5 files changed, 2592 insertions(+), 2217 deletions(-)
---
diff --git a/assets/javascripts/templates/pages/about_tmpl.coffee
b/assets/javascripts/templates/pages/about_tmpl.coffee
index 892c4284..5238d850 100644
--- a/assets/javascripts/templates/pages/about_tmpl.coffee
+++ b/assets/javascripts/templates/pages/about_tmpl.coffee
@@ -516,6 +516,11 @@ credits = [
'2008-2017 NumPy Developers',
'NumPy',
'https://raw.githubusercontent.com/numpy/numpy/master/LICENSE.txt'
+ ], [
+ 'Octave',
+ '1996-2018 John W. Eaton',
+ 'Custom',
+ 'https://octave.org/doc/interpreter/'
], [
'OpenJDK',
'1993-2017, Oracle and/or its affiliates. All rights reserved.<br>Licensed under the GNU General Public
License, version 2, with the Classpath Exception.<br>Various third party code in OpenJDK is licensed under
different licenses.<br>Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its
affiliates.',
diff --git a/assets/javascripts/vendor/prism.js b/assets/javascripts/vendor/prism.js
index 09d6df87..c2cbaadd 100644
--- a/assets/javascripts/vendor/prism.js
+++ b/assets/javascripts/vendor/prism.js
@@ -1,12 +1,12 @@
-/* PrismJS 1.15.0
-https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+c+bash+cpp+coffeescript+ruby+d+dart+django+elixir+markup-templating+erlang+go+java+json+kotlin+lua+crystal+nginx+nim+perl+php+sql+scss+python+jsx+typescript+rust+yaml
*/
+/* PrismJS 1.17.1
+https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+c+bash+cpp+coffeescript+ruby+d+dart+markup-templating+elixir+erlang+go+java+php+json+kotlin+crystal+lua+django+matlab+typescript+nginx+nim+perl+sql+scss+python+jsx+rust+yaml
*/
var _self = (typeof window !== 'undefined')
- ? window // if in browser
- : (
- (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
- ? self // if in worker
- : {} // if in node js
- );
+ ? window // if in browser
+ : (
+ (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
+ ? self // if in worker
+ : {} // if in node js
+ );
/**
* Prism: Lightweight, robust, elegant syntax highlighting
@@ -14,977 +14,1174 @@ var _self = (typeof window !== 'undefined')
* @author Lea Verou http://lea.verou.me
*/
-var Prism = (function(){
+var Prism = (function (_self){
// Private helper vars
-var lang = /\blang(?:uage)?-([\w-]+)\b/i;
-var uniqueId = 0;
-
-var _ = _self.Prism = {
- manual: _self.Prism && _self.Prism.manual,
- disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
- util: {
- encode: function (tokens) {
- if (tokens instanceof Token) {
- return new Token(tokens.type, _.util.encode(tokens.content), tokens.alias);
- } else if (_.util.type(tokens) === 'Array') {
- return tokens.map(_.util.encode);
- } else {
- return tokens.replace(/&/g, '&').replace(/</g, '<').replace(/\u00a0/g,
' ');
- }
- },
-
- type: function (o) {
- return Object.prototype.toString.call(o).match(/\[object (\w+)\]/)[1];
- },
-
- objId: function (obj) {
- if (!obj['__id']) {
- Object.defineProperty(obj, '__id', { value: ++uniqueId });
- }
- return obj['__id'];
- },
-
- // Deep clone a language definition (e.g. to extend it)
- clone: function (o, visited) {
- var type = _.util.type(o);
- visited = visited || {};
-
- switch (type) {
- case 'Object':
- if (visited[_.util.objId(o)]) {
- return visited[_.util.objId(o)];
- }
- var clone = {};
- visited[_.util.objId(o)] = clone;
-
- for (var key in o) {
- if (o.hasOwnProperty(key)) {
- clone[key] = _.util.clone(o[key], visited);
- }
- }
-
- return clone;
-
- case 'Array':
- if (visited[_.util.objId(o)]) {
- return visited[_.util.objId(o)];
- }
- var clone = [];
- visited[_.util.objId(o)] = clone;
-
- o.forEach(function (v, i) {
- clone[i] = _.util.clone(v, visited);
- });
-
- return clone;
- }
-
- return o;
- }
- },
-
- languages: {
- extend: function (id, redef) {
- var lang = _.util.clone(_.languages[id]);
-
- for (var key in redef) {
- lang[key] = redef[key];
- }
-
- return lang;
- },
-
- /**
- * Insert a token before another token in a language literal
- * As this needs to recreate the object (we cannot actually insert before keys in object
literals),
- * we cannot just provide an object, we need anobject and a key.
- * @param inside The key (or language id) of the parent
- * @param before The key to insert before. If not provided, the function appends instead.
- * @param insert Object with the key/value pairs to insert
- * @param root The object that contains `inside`. If equal to Prism.languages, it can be
omitted.
- */
- insertBefore: function (inside, before, insert, root) {
- root = root || _.languages;
- var grammar = root[inside];
-
- if (arguments.length == 2) {
- insert = arguments[1];
-
- for (var newToken in insert) {
- if (insert.hasOwnProperty(newToken)) {
- grammar[newToken] = insert[newToken];
- }
- }
-
- return grammar;
- }
-
- var ret = {};
-
- for (var token in grammar) {
-
- if (grammar.hasOwnProperty(token)) {
-
- if (token == before) {
-
- for (var newToken in insert) {
-
- if (insert.hasOwnProperty(newToken)) {
- ret[newToken] = insert[newToken];
- }
- }
- }
-
- ret[token] = grammar[token];
- }
- }
-
- // Update references in other language definitions
- _.languages.DFS(_.languages, function(key, value) {
- if (value === root[inside] && key != inside) {
- this[key] = ret;
- }
- });
-
- return root[inside] = ret;
- },
-
- // Traverse a language definition with Depth First Search
- DFS: function(o, callback, type, visited) {
- visited = visited || {};
- for (var i in o) {
- if (o.hasOwnProperty(i)) {
- callback.call(o, i, o[i], type || i);
-
- if (_.util.type(o[i]) === 'Object' && !visited[_.util.objId(o[i])]) {
- visited[_.util.objId(o[i])] = true;
- _.languages.DFS(o[i], callback, null, visited);
- }
- else if (_.util.type(o[i]) === 'Array' &&
!visited[_.util.objId(o[i])]) {
- visited[_.util.objId(o[i])] = true;
- _.languages.DFS(o[i], callback, i, visited);
- }
- }
- }
- }
- },
- plugins: {},
-
- highlightAll: function(async, callback) {
- _.highlightAllUnder(document, async, callback);
- },
-
- highlightAllUnder: function(container, async, callback) {
- var env = {
- callback: callback,
- selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"],
[class*="lang-"] code'
- };
-
- _.hooks.run("before-highlightall", env);
-
- var elements = env.elements || container.querySelectorAll(env.selector);
-
- for (var i=0, element; element = elements[i++];) {
- _.highlightElement(element, async === true, env.callback);
- }
- },
-
- highlightElement: function(element, async, callback) {
- // Find language
- var language, grammar, parent = element;
-
- while (parent && !lang.test(parent.className)) {
- parent = parent.parentNode;
- }
-
- if (parent) {
- language = (parent.className.match(lang) || [,''])[1].toLowerCase();
- grammar = _.languages[language];
- }
-
- // Set language on the element, if not present
- element.className = element.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' +
language;
-
- if (element.parentNode) {
- // Set language on the parent, for styling
- parent = element.parentNode;
-
- if (/pre/i.test(parent.nodeName)) {
- parent.className = parent.className.replace(lang, '').replace(/\s+/g, ' ') +
' language-' + language;
- }
- }
-
- var code = element.textContent;
-
- var env = {
- element: element,
- language: language,
- grammar: grammar,
- code: code
- };
-
- _.hooks.run('before-sanity-check', env);
-
- if (!env.code || !env.grammar) {
- if (env.code) {
- _.hooks.run('before-highlight', env);
- env.element.textContent = env.code;
- _.hooks.run('after-highlight', env);
- }
- _.hooks.run('complete', env);
- return;
- }
-
- _.hooks.run('before-highlight', env);
-
- // if (async && _self.Worker) {
- // var worker = new Worker(_.filename);
-
- // worker.onmessage = function(evt) {
- // env.highlightedCode = evt.data;
-
- // _.hooks.run('before-insert', env);
-
- // env.element.innerHTML = env.highlightedCode;
-
- // callback && callback.call(env.element);
- // _.hooks.run('after-highlight', env);
- // _.hooks.run('complete', env);
- // };
-
- // worker.postMessage(JSON.stringify({
- // language: env.language,
- // code: env.code,
- // immediateClose: true
- // }));
- // }
- // else {
- env.highlightedCode = _.highlight(env.code, env.grammar, env.language);
-
- _.hooks.run('before-insert', env);
-
- env.element.innerHTML = env.highlightedCode;
-
- callback && callback.call(element);
-
- _.hooks.run('after-highlight', env);
- _.hooks.run('complete', env);
- // }
- },
-
- highlight: function (text, grammar, language) {
- var env = {
- code: text,
- grammar: grammar,
- language: language
- };
- _.hooks.run('before-tokenize', env);
- env.tokens = _.tokenize(env.code, env.grammar);
- _.hooks.run('after-tokenize', env);
- return Token.stringify(_.util.encode(env.tokens), env.language);
- },
-
- matchGrammar: function (text, strarr, grammar, index, startPos, oneshot, target) {
- var Token = _.Token;
-
- for (var token in grammar) {
- if(!grammar.hasOwnProperty(token) || !grammar[token]) {
- continue;
- }
-
- if (token == target) {
- return;
- }
-
- var patterns = grammar[token];
- patterns = (_.util.type(patterns) === "Array") ? patterns : [patterns];
-
- for (var j = 0; j < patterns.length; ++j) {
- var pattern = patterns[j],
- inside = pattern.inside,
- lookbehind = !!pattern.lookbehind,
- greedy = !!pattern.greedy,
- lookbehindLength = 0,
- alias = pattern.alias;
-
- if (greedy && !pattern.pattern.global) {
- // Without the global flag, lastIndex won't work
- var flags = pattern.pattern.toString().match(/[imuy]*$/)[0];
- pattern.pattern = RegExp(pattern.pattern.source, flags + "g");
- }
-
- pattern = pattern.pattern || pattern;
-
- // Don’t cache length as it changes during the loop
- for (var i = index, pos = startPos; i < strarr.length; pos +=
strarr[i].length, ++i) {
-
- var str = strarr[i];
-
- if (strarr.length > text.length) {
- // Something went terribly wrong, ABORT, ABORT!
- return;
- }
-
- if (str instanceof Token) {
- continue;
- }
-
- if (greedy && i != strarr.length - 1) {
- pattern.lastIndex = pos;
- var match = pattern.exec(text);
- if (!match) {
- break;
- }
-
- var from = match.index + (lookbehind ? match[1].length : 0),
- to = match.index + match[0].length,
- k = i,
- p = pos;
-
- for (var len = strarr.length; k < len && (p < to ||
(!strarr[k].type && !strarr[k - 1].greedy)); ++k) {
- p += strarr[k].length;
- // Move the index i to the element in strarr that is
closest to from
- if (from >= p) {
- ++i;
- pos = p;
- }
- }
-
- // If strarr[i] is a Token, then the match starts inside
another Token, which is invalid
- if (strarr[i] instanceof Token) {
- continue;
- }
-
- // Number of tokens to delete and replace with the new match
- delNum = k - i;
- str = text.slice(pos, p);
- match.index -= pos;
- } else {
- pattern.lastIndex = 0;
-
- var match = pattern.exec(str),
- delNum = 1;
- }
-
- if (!match) {
- if (oneshot) {
- break;
- }
-
- continue;
- }
-
- if(lookbehind) {
- lookbehindLength = match[1] ? match[1].length : 0;
- }
-
- var from = match.index + lookbehindLength,
- match = match[0].slice(lookbehindLength),
- to = from + match.length,
- before = str.slice(0, from),
- after = str.slice(to);
+ var lang = /\blang(?:uage)?-([\w-]+)\b/i;
+ var uniqueId = 0;
+
+ var _ = {
+ manual: _self.Prism && _self.Prism.manual,
+ disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
+ util: {
+ encode: function (tokens) {
+ if (tokens instanceof Token) {
+ return new Token(tokens.type, _.util.encode(tokens.content), tokens.alias);
+ } else if (Array.isArray(tokens)) {
+ return tokens.map(_.util.encode);
+ } else {
+ return tokens.replace(/&/g, '&').replace(/</g, '<').replace(/\u00a0/g, ' ');
+ }
+ },
+
+ type: function (o) {
+ return Object.prototype.toString.call(o).slice(8, -1);
+ },
+
+ objId: function (obj) {
+ if (!obj['__id']) {
+ Object.defineProperty(obj, '__id', { value: ++uniqueId });
+ }
+ return obj['__id'];
+ },
+
+ // Deep clone a language definition (e.g. to extend it)
+ clone: function deepClone(o, visited) {
+ var clone, id, type = _.util.type(o);
+ visited = visited || {};
+
+ switch (type) {
+ case 'Object':
+ id = _.util.objId(o);
+ if (visited[id]) {
+ return visited[id];
+ }
+ clone = {};
+ visited[id] = clone;
+
+ for (var key in o) {
+ if (o.hasOwnProperty(key)) {
+ clone[key] = deepClone(o[key], visited);
+ }
+ }
+
+ return clone;
+
+ case 'Array':
+ id = _.util.objId(o);
+ if (visited[id]) {
+ return visited[id];
+ }
+ clone = [];
+ visited[id] = clone;
+
+ o.forEach(function (v, i) {
+ clone[i] = deepClone(v, visited);
+ });
+
+ return clone;
+
+ default:
+ return o;
+ }
+ }
+ },
+
+ languages: {
+ extend: function (id, redef) {
+ var lang = _.util.clone(_.languages[id]);
+
+ for (var key in redef) {
+ lang[key] = redef[key];
+ }
+
+ return lang;
+ },
+
+ /**
+ * Insert a token before another token in a language literal
+ * As this needs to recreate the object (we cannot actually insert before keys in object literals),
+ * we cannot just provide an object, we need an object and a key.
+ * @param inside The key (or language id) of the parent
+ * @param before The key to insert before.
+ * @param insert Object with the key/value pairs to insert
+ * @param root The object that contains `inside`. If equal to Prism.languages, it can be omitted.
+ */
+ insertBefore: function (inside, before, insert, root) {
+ root = root || _.languages;
+ var grammar = root[inside];
+ var ret = {};
+
+ for (var token in grammar) {
+ if (grammar.hasOwnProperty(token)) {
+
+ if (token == before) {
+ for (var newToken in insert) {
+ if (insert.hasOwnProperty(newToken)) {
+ ret[newToken] = insert[newToken];
+ }
+ }
+ }
+
+ // Do not insert token which also occur in insert. See #1525
+ if (!insert.hasOwnProperty(token)) {
+ ret[token] = grammar[token];
+ }
+ }
+ }
+
+ var old = root[inside];
+ root[inside] = ret;
+
+ // Update references in other language definitions
+ _.languages.DFS(_.languages, function(key, value) {
+ if (value === old && key != inside) {
+ this[key] = ret;
+ }
+ });
+
+ return ret;
+ },
+
+ // Traverse a language definition with Depth First Search
+ DFS: function DFS(o, callback, type, visited) {
+ visited = visited || {};
+
+ var objId = _.util.objId;
+
+ for (var i in o) {
+ if (o.hasOwnProperty(i)) {
+ callback.call(o, i, o[i], type || i);
+
+ var property = o[i],
+ propertyType = _.util.type(property);
+
+ if (propertyType === 'Object' && !visited[objId(property)]) {
+ visited[objId(property)] = true;
+ DFS(property, callback, null, visited);
+ }
+ else if (propertyType === 'Array' && !visited[objId(property)]) {
+ visited[objId(property)] = true;
+ DFS(property, callback, i, visited);
+ }
+ }
+ }
+ }
+ },
+ plugins: {},
+
+ highlightAll: function(async, callback) {
+ _.highlightAllUnder(document, async, callback);
+ },
+
+ highlightAllUnder: function(container, async, callback) {
+ var env = {
+ callback: callback,
+ selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"],
[class*="lang-"] code'
+ };
+
+ _.hooks.run('before-highlightall', env);
+
+ var elements = container.querySelectorAll(env.selector);
+
+ for (var i=0, element; element = elements[i++];) {
+ _.highlightElement(element, async === true, env.callback);
+ }
+ },
+
+ highlightElement: function(element, async, callback) {
+ // Find language
+ var language = 'none', grammar, parent = element;
+
+ while (parent && !lang.test(parent.className)) {
+ parent = parent.parentNode;
+ }
+
+ if (parent) {
+ language = (parent.className.match(lang) || [,'none'])[1].toLowerCase();
+ grammar = _.languages[language];
+ }
+
+ // Set language on the element, if not present
+ element.className = element.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
+
+ if (element.parentNode) {
+ // Set language on the parent, for styling
+ parent = element.parentNode;
+
+ if (/pre/i.test(parent.nodeName)) {
+ parent.className = parent.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' +
language;
+ }
+ }
+
+ var code = element.textContent;
+
+ var env = {
+ element: element,
+ language: language,
+ grammar: grammar,
+ code: code
+ };
+
+ var insertHighlightedCode = function (highlightedCode) {
+ env.highlightedCode = highlightedCode;
+
+ _.hooks.run('before-insert', env);
+
+ env.element.innerHTML = env.highlightedCode;
+
+ _.hooks.run('after-highlight', env);
+ _.hooks.run('complete', env);
+ callback && callback.call(env.element);
+ }
+
+ _.hooks.run('before-sanity-check', env);
+
+ if (!env.code) {
+ _.hooks.run('complete', env);
+ return;
+ }
+
+ _.hooks.run('before-highlight', env);
+
+ if (!env.grammar) {
+ insertHighlightedCode(_.util.encode(env.code));
+ return;
+ }
+
+ if (async && _self.Worker) {
+ var worker = new Worker(_.filename);
+
+ worker.onmessage = function(evt) {
+ insertHighlightedCode(evt.data);
+ };
+
+ worker.postMessage(JSON.stringify({
+ language: env.language,
+ code: env.code,
+ immediateClose: true
+ }));
+ }
+ else {
+ insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
+ }
+ },
+
+ highlight: function (text, grammar, language) {
+ var env = {
+ code: text,
+ grammar: grammar,
+ language: language
+ };
+ _.hooks.run('before-tokenize', env);
+ env.tokens = _.tokenize(env.code, env.grammar);
+ _.hooks.run('after-tokenize', env);
+ return Token.stringify(_.util.encode(env.tokens), env.language);
+ },
+
+ matchGrammar: function (text, strarr, grammar, index, startPos, oneshot, target) {
+ for (var token in grammar) {
+ if(!grammar.hasOwnProperty(token) || !grammar[token]) {
+ continue;
+ }
+
+ if (token == target) {
+ return;
+ }
+
+ var patterns = grammar[token];
+ patterns = (_.util.type(patterns) === "Array") ? patterns : [patterns];
+
+ for (var j = 0; j < patterns.length; ++j) {
+ var pattern = patterns[j],
+ inside = pattern.inside,
+ lookbehind = !!pattern.lookbehind,
+ greedy = !!pattern.greedy,
+ lookbehindLength = 0,
+ alias = pattern.alias;
+
+ if (greedy && !pattern.pattern.global) {
+ // Without the global flag, lastIndex won't work
+ var flags = pattern.pattern.toString().match(/[imuy]*$/)[0];
+ pattern.pattern = RegExp(pattern.pattern.source, flags + "g");
+ }
+
+ pattern = pattern.pattern || pattern;
+
+ // Don’t cache length as it changes during the loop
+ for (var i = index, pos = startPos; i < strarr.length; pos += strarr[i].length, ++i) {
+
+ var str = strarr[i];
+
+ if (strarr.length > text.length) {
+ // Something went terribly wrong, ABORT, ABORT!
+ return;
+ }
+
+ if (str instanceof Token) {
+ continue;
+ }
+
+ if (greedy && i != strarr.length - 1) {
+ pattern.lastIndex = pos;
+ var match = pattern.exec(text);
+ if (!match) {
+ break;
+ }
+
+ var from = match.index + (lookbehind ? match[1].length : 0),
+ to = match.index + match[0].length,
+ k = i,
+ p = pos;
+
+ for (var len = strarr.length; k < len && (p < to || (!strarr[k].type && !strarr[k -
1].greedy)); ++k) {
+ p += strarr[k].length;
+ // Move the index i to the element in strarr that is closest to from
+ if (from >= p) {
+ ++i;
+ pos = p;
+ }
+ }
+
+ // If strarr[i] is a Token, then the match starts inside another Token, which is invalid
+ if (strarr[i] instanceof Token) {
+ continue;
+ }
+
+ // Number of tokens to delete and replace with the new match
+ delNum = k - i;
+ str = text.slice(pos, p);
+ match.index -= pos;
+ } else {
+ pattern.lastIndex = 0;
+
+ var match = pattern.exec(str),
+ delNum = 1;
+ }
+
+ if (!match) {
+ if (oneshot) {
+ break;
+ }
+
+ continue;
+ }
+
+ if(lookbehind) {
+ lookbehindLength = match[1] ? match[1].length : 0;
+ }
+
+ var from = match.index + lookbehindLength,
+ match = match[0].slice(lookbehindLength),
+ to = from + match.length,
+ before = str.slice(0, from),
+ after = str.slice(to);
+
+ var args = [i, delNum];
+
+ if (before) {
+ ++i;
+ pos += before.length;
+ args.push(before);
+ }
+
+ var wrapped = new Token(token, inside? _.tokenize(match, inside) : match, alias, match, greedy);
+
+ args.push(wrapped);
+
+ if (after) {
+ args.push(after);
+ }
+
+ Array.prototype.splice.apply(strarr, args);
+
+ if (delNum != 1)
+ _.matchGrammar(text, strarr, grammar, i, pos, true, token);
+
+ if (oneshot)
+ break;
+ }
+ }
+ }
+ },
+
+ tokenize: function(text, grammar) {
+ var strarr = [text];
+
+ var rest = grammar.rest;
+
+ if (rest) {
+ for (var token in rest) {
+ grammar[token] = rest[token];
+ }
+
+ delete grammar.rest;
+ }
+
+ _.matchGrammar(text, strarr, grammar, 0, 0, false);
+
+ return strarr;
+ },
+
+ hooks: {
+ all: {},
+
+ add: function (name, callback) {
+ var hooks = _.hooks.all;
+
+ hooks[name] = hooks[name] || [];
+
+ hooks[name].push(callback);
+ },
+
+ run: function (name, env) {
+ var callbacks = _.hooks.all[name];
+
+ if (!callbacks || !callbacks.length) {
+ return;
+ }
- var args = [i, delNum];
-
- if (before) {
- ++i;
- pos += before.length;
- args.push(before);
- }
+ for (var i=0, callback; callback = callbacks[i++];) {
+ callback(env);
+ }
+ }
+ },
- var wrapped = new Token(token, inside? _.tokenize(match, inside) :
match, alias, match, greedy);
-
- args.push(wrapped);
+ Token: Token
+ };
- if (after) {
- args.push(after);
- }
-
- Array.prototype.splice.apply(strarr, args);
-
- if (delNum != 1)
- _.matchGrammar(text, strarr, grammar, i, pos, true, token);
+ _self.Prism = _;
- if (oneshot)
- break;
- }
- }
- }
- },
+ function Token(type, content, alias, matchedStr, greedy) {
+ this.type = type;
+ this.content = content;
+ this.alias = alias;
+ // Copy of the full string this token was created from
+ this.length = (matchedStr || "").length|0;
+ this.greedy = !!greedy;
+ }
- tokenize: function(text, grammar, language) {
- var strarr = [text];
+ Token.stringify = function(o, language) {
+ if (typeof o == 'string') {
+ return o;
+ }
- var rest = grammar.rest;
+ if (Array.isArray(o)) {
+ return o.map(function(element) {
+ return Token.stringify(element, language);
+ }).join('');
+ }
- if (rest) {
- for (var token in rest) {
- grammar[token] = rest[token];
- }
-
- delete grammar.rest;
- }
-
- _.matchGrammar(text, strarr, grammar, 0, 0, false);
-
- return strarr;
- },
-
- hooks: {
- all: {},
-
- add: function (name, callback) {
- var hooks = _.hooks.all;
-
- hooks[name] = hooks[name] || [];
-
- hooks[name].push(callback);
- },
-
- run: function (name, env) {
- var callbacks = _.hooks.all[name];
-
- if (!callbacks || !callbacks.length) {
- return;
- }
-
- for (var i=0, callback; callback = callbacks[i++];) {
- callback(env);
- }
- }
- }
-};
-
-var Token = _.Token = function(type, content, alias, matchedStr, greedy) {
- this.type = type;
- this.content = content;
- this.alias = alias;
- // Copy of the full string this token was created from
- this.length = (matchedStr || "").length|0;
- this.greedy = !!greedy;
-};
-
-Token.stringify = function(o, language, parent) {
- if (typeof o == 'string') {
- return o;
- }
-
- if (_.util.type(o) === 'Array') {
- return o.map(function(element) {
- return Token.stringify(element, language, o);
- }).join('');
- }
-
- var env = {
- type: o.type,
- content: Token.stringify(o.content, language, parent),
- tag: 'span',
- classes: ['token', o.type],
- attributes: {},
- language: language,
- parent: parent
- };
-
- if (o.alias) {
- var aliases = _.util.type(o.alias) === 'Array' ? o.alias : [o.alias];
- Array.prototype.push.apply(env.classes, aliases);
- }
-
- _.hooks.run('wrap', env);
-
- var attributes = Object.keys(env.attributes).map(function(name) {
- return name + '="' + (env.attributes[name] || '').replace(/"/g, '"') + '"';
- }).join(' ');
-
- return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + (attributes ? ' ' + attributes :
'') + '>' + env.content + '</' + env.tag + '>';
-
-};
+ var env = {
+ type: o.type,
+ content: Token.stringify(o.content, language),
+ tag: 'span',
+ classes: ['token', o.type],
+ attributes: {},
+ language: language
+ };
-// if (!_self.document) {
-// if (!_self.addEventListener) {
-// // in Node.js
-// return _self.Prism;
-// }
-
-// if (!_.disableWorkerMessageHandler) {
-// // In worker
-// _self.addEventListener('message', function (evt) {
-// var message = JSON.parse(evt.data),
-// lang = message.language,
-// code = message.code,
-// immediateClose = message.immediateClose;
-
-// _self.postMessage(_.highlight(code, _.languages[lang], lang));
-// if (immediateClose) {
-// _self.close();
-// }
-// }, false);
-// }
-
-// return _self.Prism;
-// }
-
-// //Get current script and highlight
-// var script = document.currentScript || [].slice.call(document.getElementsByTagName("script")).pop();
-
-// if (script) {
-// _.filename = script.src;
-
-// if (!_.manual && !script.hasAttribute('data-manual')) {
-// if(document.readyState !== "loading") {
-// if (window.requestAnimationFrame) {
-// window.requestAnimationFrame(_.highlightAll);
-// } else {
-// window.setTimeout(_.highlightAll, 16);
-// }
-// }
-// else {
-// document.addEventListener('DOMContentLoaded', _.highlightAll);
-// }
-// }
-// }
-
-return _self.Prism;
-
-})();
+ if (o.alias) {
+ var aliases = Array.isArray(o.alias) ? o.alias : [o.alias];
+ Array.prototype.push.apply(env.classes, aliases);
+ }
+
+ _.hooks.run('wrap', env);
+
+ var attributes = Object.keys(env.attributes).map(function(name) {
+ return name + '="' + (env.attributes[name] || '').replace(/"/g, '"') + '"';
+ }).join(' ');
+
+ return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + (attributes ? ' ' + attributes : '') +
'>' + env.content + '</' + env.tag + '>';
+ };
+
+ if (!_self.document) {
+ if (!_self.addEventListener) {
+ // in Node.js
+ return _;
+ }
+
+ if (!_.disableWorkerMessageHandler) {
+ // In worker
+ _self.addEventListener('message', function (evt) {
+ var message = JSON.parse(evt.data),
+ lang = message.language,
+ code = message.code,
+ immediateClose = message.immediateClose;
+
+ _self.postMessage(_.highlight(code, _.languages[lang], lang));
+ if (immediateClose) {
+ _self.close();
+ }
+ }, false);
+ }
+
+ return _;
+ }
+
+//Get current script and highlight
+ var script = document.currentScript || [].slice.call(document.getElementsByTagName("script")).pop();
+
+ if (script) {
+ _.filename = script.src;
+
+ if (!_.manual && !script.hasAttribute('data-manual')) {
+ if(document.readyState !== "loading") {
+ if (window.requestAnimationFrame) {
+ window.requestAnimationFrame(_.highlightAll);
+ } else {
+ window.setTimeout(_.highlightAll, 16);
+ }
+ }
+ else {
+ document.addEventListener('DOMContentLoaded', _.highlightAll);
+ }
+ }
+ }
+
+ return _;
+
+})(_self);
if (typeof module !== 'undefined' && module.exports) {
- module.exports = Prism;
+ module.exports = Prism;
}
// hack for components to work correctly in node.js
if (typeof global !== 'undefined') {
- global.Prism = Prism;
+ global.Prism = Prism;
}
;
Prism.languages.markup = {
- 'comment': /<!--[\s\S]*?-->/,
- 'prolog': /<\?[\s\S]+?\?>/,
- 'doctype': /<!DOCTYPE[\s\S]+?>/i,
- 'cdata': /<!\[CDATA\[[\s\S]*?]]>/i,
- 'tag': {
- pattern:
/<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i,
- greedy: true,
- inside: {
- 'tag': {
- pattern: /^<\/?[^\s>\/]+/i,
- inside: {
- 'punctuation': /^<\/?/,
- 'namespace': /^[^\s>\/:]+:/
- }
- },
- 'attr-value': {
- pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/i,
- inside: {
- 'punctuation': [
- /^=/,
- {
- pattern: /(^|[^\\])["']/,
- lookbehind: true
- }
- ]
- }
- },
- 'punctuation': /\/?>/,
- 'attr-name': {
- pattern: /[^\s>\/]+/,
- inside: {
- 'namespace': /^[^\s>\/:]+:/
- }
- }
-
- }
- },
- 'entity': /&#?[\da-z]{1,8};/i
+ 'comment': /<!--[\s\S]*?-->/,
+ 'prolog': /<\?[\s\S]+?\?>/,
+ 'doctype': /<!DOCTYPE[\s\S]+?>/i,
+ 'cdata': /<!\[CDATA\[[\s\S]*?]]>/i,
+ 'tag': {
+ pattern:
/<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/i,
+ greedy: true,
+ inside: {
+ 'tag': {
+ pattern: /^<\/?[^\s>\/]+/i,
+ inside: {
+ 'punctuation': /^<\/?/,
+ 'namespace': /^[^\s>\/:]+:/
+ }
+ },
+ 'attr-value': {
+ pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/i,
+ inside: {
+ 'punctuation': [
+ /^=/,
+ {
+ pattern: /^(\s*)["']|["']$/,
+ lookbehind: true
+ }
+ ]
+ }
+ },
+ 'punctuation': /\/?>/,
+ 'attr-name': {
+ pattern: /[^\s>\/]+/,
+ inside: {
+ 'namespace': /^[^\s>\/:]+:/
+ }
+ }
+
+ }
+ },
+ 'entity': /&#?[\da-z]{1,8};/i
};
Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] =
- Prism.languages.markup['entity'];
+ Prism.languages.markup['entity'];
// Plugin to make entity title show the real entity, idea by Roman Komarov
Prism.hooks.add('wrap', function(env) {
- if (env.type === 'entity') {
- env.attributes['title'] = env.content.replace(/&/, '&');
- }
+ if (env.type === 'entity') {
+ env.attributes['title'] = env.content.replace(/&/, '&');
+ }
+});
+
+Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {
+ /**
+ * Adds an inlined language to markup.
+ *
+ * An example of an inlined language is CSS with `<style>` tags.
+ *
+ * @param {string} tagName The name of the tag that contains the inlined language. This name will be
treated as
+ * case insensitive.
+ * @param {string} lang The language key.
+ * @example
+ * addInlined('style', 'css');
+ */
+ value: function addInlined(tagName, lang) {
+ var includedCdataInside = {};
+ includedCdataInside['language-' + lang] = {
+ pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+ lookbehind: true,
+ inside: Prism.languages[lang]
+ };
+ includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
+
+ var inside = {
+ 'included-cdata': {
+ pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+ inside: includedCdataInside
+ }
+ };
+ inside['language-' + lang] = {
+ pattern: /[\s\S]+/,
+ inside: Prism.languages[lang]
+ };
+
+ var def = {};
+ def[tagName] = {
+ pattern:
RegExp(/(<__[\s\S]*?>)(?:<!\[CDATA\[[\s\S]*?\]\]>\s*|[\s\S])*?(?=<\/__>)/.source.replace(/__/g, tagName),
'i'),
+ lookbehind: true,
+ greedy: true,
+ inside: inside
+ };
+
+ Prism.languages.insertBefore('markup', 'cdata', def);
+ }
});
-Prism.languages.xml = Prism.languages.markup;
+Prism.languages.xml = Prism.languages.extend('markup', {});
Prism.languages.html = Prism.languages.markup;
Prism.languages.mathml = Prism.languages.markup;
Prism.languages.svg = Prism.languages.markup;
-Prism.languages.css = {
- 'comment': /\/\*[\s\S]*?\*\//,
- 'atrule': {
- pattern: /@[\w-]+?.*?(?:;|(?=\s*\{))/i,
- inside: {
- 'rule': /@[\w-]+/
- // See rest below
- }
- },
- 'url': /url\((?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|.*?)\)/i,
- 'selector': /[^{}\s][^{};]*?(?=\s*\{)/,
- 'string': {
- pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
- greedy: true
- },
- 'property': /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,
- 'important': /\B!important\b/i,
- 'function': /[-a-z0-9]+(?=\()/i,
- 'punctuation': /[(){};:]/
-};
+(function (Prism) {
-Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
+ var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+
+ Prism.languages.css = {
+ 'comment': /\/\*[\s\S]*?\*\//,
+ 'atrule': {
+ pattern: /@[\w-]+[\s\S]*?(?:;|(?=\s*\{))/,
+ inside: {
+ 'rule': /@[\w-]+/
+ // See rest below
+ }
+ },
+ 'url': {
+ pattern: RegExp('url\\((?:' + string.source + '|[^\n\r()]*)\\)', 'i'),
+ inside: {
+ 'function': /^url/i,
+ 'punctuation': /^\(|\)$/
+ }
+ },
+ 'selector': RegExp('[^{}\\s](?:[^{};"\']|' + string.source + ')*?(?=\\s*\\{)'),
+ 'string': {
+ pattern: string,
+ greedy: true
+ },
+ 'property': /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,
+ 'important': /!important\b/i,
+ 'function': /[-a-z0-9]+(?=\()/i,
+ 'punctuation': /[(){};:,]/
+ };
+
+ Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
+
+ var markup = Prism.languages.markup;
+ if (markup) {
+ markup.tag.addInlined('style', 'css');
+
+ Prism.languages.insertBefore('inside', 'attr-value', {
+ 'style-attr': {
+ pattern: /\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
+ inside: {
+ 'attr-name': {
+ pattern: /^\s*style/i,
+ inside: markup.tag.inside
+ },
+ 'punctuation': /^\s*=\s*['"]|['"]\s*$/,
+ 'attr-value': {
+ pattern: /.+/i,
+ inside: Prism.languages.css
+ }
+ },
+ alias: 'language-css'
+ }
+ }, markup.tag);
+ }
+
+}(Prism));
-if (Prism.languages.markup) {
- Prism.languages.insertBefore('markup', 'tag', {
- 'style': {
- pattern: /(<style[\s\S]*?>)[\s\S]*?(?=<\/style>)/i,
- lookbehind: true,
- inside: Prism.languages.css,
- alias: 'language-css',
- greedy: true
- }
- });
-
- Prism.languages.insertBefore('inside', 'attr-value', {
- 'style-attr': {
- pattern: /\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
- inside: {
- 'attr-name': {
- pattern: /^\s*style/i,
- inside: Prism.languages.markup.tag.inside
- },
- 'punctuation': /^\s*=\s*['"]|['"]\s*$/,
- 'attr-value': {
- pattern: /.+/i,
- inside: Prism.languages.css
- }
- },
- alias: 'language-css'
- }
- }, Prism.languages.markup.tag);
-};
Prism.languages.clike = {
- 'comment': [
- {
- pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
- lookbehind: true
- },
- {
- pattern: /(^|[^\\:])\/\/.*/,
- lookbehind: true,
- greedy: true
- }
- ],
- 'string': {
- pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
- greedy: true
- },
- 'class-name': {
- pattern:
/((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,
- lookbehind: true,
- inside: {
- punctuation: /[.\\]/
- }
- },
- 'keyword':
/\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
- 'boolean': /\b(?:true|false)\b/,
- 'function': /[a-z0-9_]+(?=\()/i,
- 'number': /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,
- 'operator': /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,
- 'punctuation': /[{}[\];(),.:]/
+ 'comment': [
+ {
+ pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+ lookbehind: true
+ },
+ {
+ pattern: /(^|[^\\:])\/\/.*/,
+ lookbehind: true,
+ greedy: true
+ }
+ ],
+ 'string': {
+ pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true
+ },
+ 'class-name': {
+ pattern:
/((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,
+ lookbehind: true,
+ inside: {
+ punctuation: /[.\\]/
+ }
+ },
+ 'keyword':
/\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
+ 'boolean': /\b(?:true|false)\b/,
+ 'function': /\w+(?=\()/,
+ 'number': /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,
+ 'operator': /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,
+ 'punctuation': /[{}[\];(),.:]/
};
Prism.languages.javascript = Prism.languages.extend('clike', {
- 'keyword':
/\b(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|var|void|while|with|yield)\b/,
- 'number':
/\b(?:0[xX][\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+|NaN|Infinity)\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee][+-]?\d+)?/,
- // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
- 'function': /[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*\()/i,
- 'operator':
/-[-=]?|\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/
+ 'class-name': [
+ Prism.languages.clike['class-name'],
+ {
+ pattern: /(^|[^$\w\xA0-\uFFFF])[_$A-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\.(?:prototype|constructor))/,
+ lookbehind: true
+ }
+ ],
+ 'keyword': [
+ {
+ pattern: /((?:^|})\s*)(?:catch|finally)\b/,
+ lookbehind: true
+ },
+ {
+ pattern:
/(^|[^.])\b(?:as|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+ lookbehind: true
+ },
+ ],
+ 'number':
/\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,
+ // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+ 'function': /#?[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+ 'operator':
/-[-=]?|\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/
});
+Prism.languages.javascript['class-name'][0].pattern =
/(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/;
+
Prism.languages.insertBefore('javascript', 'keyword', {
- 'regex': {
- pattern:
/((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(\[[^\]\r\n]+]|\\.|[^/\\\[\r\n])+\/[gimyu]{0,5}(?=\s*($|[\r\n,.;})\]]))/,
- lookbehind: true,
- greedy: true
- },
- // This must be declared before keyword because we use "function" inside the look-forward
- 'function-variable': {
- pattern:
/[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=\s*(?:function\b|(?:\([^()]*\)|[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/i,
- alias: 'function'
- },
- 'constant': /\b[A-Z][A-Z\d_]*\b/
+ 'regex': {
+ pattern:
/((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=\s*($|[\r\n,.;})\]]))/,
+ lookbehind: true,
+ greedy: true
+ },
+ // This must be declared before keyword because we use "function" inside the look-forward
+ 'function-variable': {
+ pattern:
/#?[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/,
+ alias: 'function'
+ },
+ 'parameter': [
+ {
+ pattern:
/(function(?:\s+[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)?\s*\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\))/,
+ lookbehind: true,
+ inside: Prism.languages.javascript
+ },
+ {
+ pattern: /[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=>)/i,
+ inside: Prism.languages.javascript
+ },
+ {
+ pattern: /(\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*=>)/,
+ lookbehind: true,
+ inside: Prism.languages.javascript
+ },
+ {
+ pattern:
/((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\s*)\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*\{)/,
+ lookbehind: true,
+ inside: Prism.languages.javascript
+ }
+ ],
+ 'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/
});
Prism.languages.insertBefore('javascript', 'string', {
- 'template-string': {
- pattern: /`(?:\\[\s\S]|\${[^}]+}|[^\\`])*`/,
- greedy: true,
- inside: {
- 'interpolation': {
- pattern: /\${[^}]+}/,
- inside: {
- 'interpolation-punctuation': {
- pattern: /^\${|}$/,
- alias: 'punctuation'
- },
- rest: null // See below
- }
- },
- 'string': /[\s\S]+/
- }
- }
+ 'template-string': {
+ pattern: /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\${)[^\\`])*`/,
+ greedy: true,
+ inside: {
+ 'template-punctuation': {
+ pattern: /^`|`$/,
+ alias: 'string'
+ },
+ 'interpolation': {
+ pattern: /((?:^|[^\\])(?:\\{2})*)\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,
+ lookbehind: true,
+ inside: {
+ 'interpolation-punctuation': {
+ pattern: /^\${|}$/,
+ alias: 'punctuation'
+ },
+ rest: Prism.languages.javascript
+ }
+ },
+ 'string': /[\s\S]+/
+ }
+ }
});
-Prism.languages.javascript['template-string'].inside['interpolation'].inside.rest =
Prism.languages.javascript;
if (Prism.languages.markup) {
- Prism.languages.insertBefore('markup', 'tag', {
- 'script': {
- pattern: /(<script[\s\S]*?>)[\s\S]*?(?=<\/script>)/i,
- lookbehind: true,
- inside: Prism.languages.javascript,
- alias: 'language-javascript',
- greedy: true
- }
- });
+ Prism.languages.markup.tag.addInlined('script', 'javascript');
}
Prism.languages.js = Prism.languages.javascript;
Prism.languages.c = Prism.languages.extend('clike', {
- 'keyword':
/\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\b/,
- 'operator': /-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/]/,
- 'number': /(?:\b0x[\da-f]+|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?)[ful]*/i
+ 'class-name': {
+ pattern: /(\b(?:enum|struct)\s+)\w+/,
+ lookbehind: true
+ },
+ 'keyword':
/\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\b/,
+ 'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/,
+ 'number':
/(?:\b0x(?:[\da-f]+\.?[\da-f]*|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?)[ful]*/i
});
Prism.languages.insertBefore('c', 'string', {
- 'macro': {
- // allow for multiline macro definitions
- // spaces after the # character compile fine with gcc
- pattern: /(^\s*)#\s*[a-z]+(?:[^\r\n\\]|\\(?:\r\n|[\s\S]))*/im,
- lookbehind: true,
- alias: 'property',
- inside: {
- // highlight the path of the include statement as a string
- 'string': {
- pattern: /(#\s*include\s*)(?:<.+?>|("|')(?:\\?.)+?\2)/,
- lookbehind: true
- },
- // highlight macro directives as keywords
- 'directive': {
- pattern:
/(#\s*)\b(?:define|defined|elif|else|endif|error|ifdef|ifndef|if|import|include|line|pragma|undef|using)\b/,
- lookbehind: true,
- alias: 'keyword'
- }
- }
- },
- // highlight predefined macros as constants
- 'constant':
/\b(?:__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|stdin|stdout|stderr)\b/
+ 'macro': {
+ // allow for multiline macro definitions
+ // spaces after the # character compile fine with gcc
+ pattern: /(^\s*)#\s*[a-z]+(?:[^\r\n\\]|\\(?:\r\n|[\s\S]))*/im,
+ lookbehind: true,
+ alias: 'property',
+ inside: {
+ // highlight the path of the include statement as a string
+ 'string': {
+ pattern: /(#\s*include\s*)(?:<.+?>|("|')(?:\\?.)+?\2)/,
+ lookbehind: true
+ },
+ // highlight macro directives as keywords
+ 'directive': {
+ pattern:
/(#\s*)\b(?:define|defined|elif|else|endif|error|ifdef|ifndef|if|import|include|line|pragma|undef|using)\b/,
+ lookbehind: true,
+ alias: 'keyword'
+ }
+ }
+ },
+ // highlight predefined macros as constants
+ 'constant':
/\b(?:__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|stdin|stdout|stderr)\b/
});
-delete Prism.languages.c['class-name'];
delete Prism.languages.c['boolean'];
(function(Prism) {
- var insideString = {
- variable: [
- // Arithmetic Environment
- {
- pattern: /\$?\(\([\s\S]+?\)\)/,
- inside: {
- // If there is a $ sign at the beginning highlight $(( and )) as
variable
- variable: [{
- pattern: /(^\$\(\([\s\S]+)\)\)/,
- lookbehind: true
- },
- /^\$\(\(/
- ],
- number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee]-?\d+)?/,
- // Operators according to
https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
- operator:
/--?|-=|\+\+?|\+=|!=?|~|\*\*?|\*=|\/=?|%=?|<<=?|>>=?|<=?|>=?|==?|&&?|&=|\^=?|\|\|?|\|=|\?|:/,
- // If there is no $ sign at the beginning highlight (( and )) as
punctuation
- punctuation: /\(\(?|\)\)?|,|;/
- }
- },
- // Command Substitution
- {
- pattern: /\$\([^)]+\)|`[^`]+`/,
- greedy: true,
- inside: {
- variable: /^\$\(|^`|\)$|`$/
- }
- },
- /\$(?:[\w#?*!@]+|\{[^}]+\})/i
- ]
- };
-
- Prism.languages.bash = {
- 'shebang': {
- pattern: /^#!\s*\/bin\/bash|^#!\s*\/bin\/sh/,
- alias: 'important'
- },
- 'comment': {
- pattern: /(^|[^"{\\])#.*/,
- lookbehind: true
- },
- 'string': [
- //Support for Here-Documents https://en.wikipedia.org/wiki/Here_document
- {
- pattern: /((?:^|[^<])<<\s*)["']?(\w+?)["']?\s*\r?\n(?:[\s\S])*?\r?\n\2/,
- lookbehind: true,
- greedy: true,
- inside: insideString
- },
- {
- pattern: /(["'])(?:\\[\s\S]|\$\([^)]+\)|`[^`]+`|(?!\1)[^\\])*\1/,
- greedy: true,
- inside: insideString
- }
- ],
- 'variable': insideString.variable,
- // Originally based on http://ss64.com/bash/
- 'function': {
- pattern:
/(^|[\s;|&])(?:alias|apropos|apt-get|aptitude|aspell|awk|basename|bash|bc|bg|builtin|bzip2|cal|cat|cd|cfdisk|chgrp|chmod|chown|chroot|chkconfig|cksum|clear|cmp|comm|command|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|du|egrep|eject|enable|env|ethtool|eval|exec|expand|expect|export|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|getopts|git|grep|groupadd|groupdel|groupmod|groups|gzip|hash|head|help|hg|history|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|jobs|join|kill|killall|less|link|ln|locate|logname|logout|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|make|man|mkdir|mkfifo|mkisofs|mknod|more|most|mount|mtools|mtr|mv|mmv|nano|netstat|nice|nl|nohup|notify-send|npm|nslookup|open|op|passwd|paste|pathchk|ping|pkill|popd|pr|printcap|printenv|printf|ps|pushd|pv|pwd|quota|quotacheck|quotactl|ram|rar|rcp|read|readarray|readonly|reboot|rename|renice|remsync|rev|rm|rmdir|r
sync|screen|scp|sdiff|sed|seq|service|sftp|shift|shopt|shutdown|sleep|slocate|sort|source|split|ssh|stat|strace|su|sudo|sum|suspend|sync|tail|tar|tee|test|time|timeout|times|touch|top|traceroute|trap|tr|tsort|tty|type|ulimit|umask|umount|unalias|uname|unexpand|uniq|units|unrar|unshar|uptime|useradd|userdel|usermod|users|uuencode|uudecode|v|vdir|vi|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yes|zip)(?=$|[\s;|&])/,
- lookbehind: true
- },
- 'keyword': {
- pattern:
/(^|[\s;|&])(?:let|:|\.|if|then|else|elif|fi|for|break|continue|while|in|case|function|select|do|done|until|echo|exit|return|set|declare)(?=$|[\s;|&])/,
- lookbehind: true
- },
- 'boolean': {
- pattern: /(^|[\s;|&])(?:true|false)(?=$|[\s;|&])/,
- lookbehind: true
- },
- 'operator': /&&?|\|\|?|==?|!=?|<<<?|>>|<=?|>=?|=~/,
- 'punctuation': /\$?\(\(?|\)\)?|\.\.|[{}[\];]/
- };
-
- var inside = insideString.variable[1].inside;
- inside.string = Prism.languages.bash.string;
- inside['function'] = Prism.languages.bash['function'];
- inside.keyword = Prism.languages.bash.keyword;
- inside['boolean'] = Prism.languages.bash['boolean'];
- inside.operator = Prism.languages.bash.operator;
- inside.punctuation = Prism.languages.bash.punctuation;
-
- Prism.languages.shell = Prism.languages.bash;
+ // $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\n' '|'
+ // + LC_ALL, RANDOM, REPLY, SECONDS.
+ // + make sure PS1..4 are here as they are not always set,
+ // - some useless things.
+ var envVars =
'\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG
_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b';
+ var insideString = {
+ 'environment': {
+ pattern: RegExp("\\$" + envVars),
+ alias: 'constant'
+ },
+ 'variable': [
+ // [0]: Arithmetic Environment
+ {
+ pattern: /\$?\(\([\s\S]+?\)\)/,
+ greedy: true,
+ inside: {
+ // If there is a $ sign at the beginning highlight $(( and )) as variable
+ 'variable': [
+ {
+ pattern: /(^\$\(\([\s\S]+)\)\)/,
+ lookbehind: true
+ },
+ /^\$\(\(/
+ ],
+ 'number': /\b0x[\dA-Fa-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee]-?\d+)?/,
+ // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+ 'operator':
/--?|-=|\+\+?|\+=|!=?|~|\*\*?|\*=|\/=?|%=?|<<=?|>>=?|<=?|>=?|==?|&&?|&=|\^=?|\|\|?|\|=|\?|:/,
+ // If there is no $ sign at the beginning highlight (( and )) as punctuation
+ 'punctuation': /\(\(?|\)\)?|,|;/
+ }
+ },
+ // [1]: Command Substitution
+ {
+ pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+ greedy: true,
+ inside: {
+ 'variable': /^\$\(|^`|\)$|`$/
+ }
+ },
+ // [2]: Brace expansion
+ {
+ pattern: /\$\{[^}]+\}/,
+ greedy: true,
+ inside: {
+ 'operator': /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+ 'punctuation': /[\[\]]/,
+ 'environment': {
+ pattern: RegExp("(\\{)" + envVars),
+ lookbehind: true,
+ alias: 'constant'
+ }
+ }
+ },
+ /\$(?:\w+|[#?*!@$])/
+ ],
+ // Escape sequences from echo and printf's manuals, and escaped quotes.
+ 'entity': /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})/
+ };
+
+ Prism.languages.bash = {
+ 'shebang': {
+ pattern: /^#!\s*\/.*/,
+ alias: 'important'
+ },
+ 'comment': {
+ pattern: /(^|[^"{\\$])#.*/,
+ lookbehind: true
+ },
+ 'function-name': [
+ // a) function foo {
+ // b) foo() {
+ // c) function foo() {
+ // but not “foo {”
+ {
+ // a) and c)
+ pattern: /(\bfunction\s+)\w+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+ lookbehind: true,
+ alias: 'function'
+ },
+ {
+ // b)
+ pattern: /\b\w+(?=\s*\(\s*\)\s*\{)/,
+ alias: 'function'
+ }
+ ],
+ // Highlight variable names as variables in for and select beginnings.
+ 'for-or-select': {
+ pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+ alias: 'variable',
+ lookbehind: true
+ },
+ // Highlight variable names as variables in the left-hand part
+ // of assignments (“=” and “+=”).
+ 'assign-left': {
+ pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
+ inside: {
+ 'environment': {
+ pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + envVars),
+ lookbehind: true,
+ alias: 'constant'
+ }
+ },
+ alias: 'variable',
+ lookbehind: true
+ },
+ 'string': [
+ // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+ {
+ pattern: /((?:^|[^<])<<-?\s*)(\w+?)\s*(?:\r?\n|\r)(?:[\s\S])*?(?:\r?\n|\r)\2/,
+ lookbehind: true,
+ greedy: true,
+ inside: insideString
+ },
+ // Here-document with quotes around the tag
+ // → No expansion (so no “inside”).
+ {
+ pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s*(?:\r?\n|\r)(?:[\s\S])*?(?:\r?\n|\r)\3/,
+ lookbehind: true,
+ greedy: true
+ },
+ // “Normal” string
+ {
+ pattern: /(["'])(?:\\[\s\S]|\$\([^)]+\)|`[^`]+`|(?!\1)[^\\])*\1/,
+ greedy: true,
+ inside: insideString
+ }
+ ],
+ 'environment': {
+ pattern: RegExp("\\$?" + envVars),
+ alias: 'constant'
+ },
+ 'variable': insideString.variable,
+ 'function': {
+ pattern:
/(^|[\s;|&]|[<>]\()(?:add|apropos|apt|aptitude|apt-cache|apt-get|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|popd|pr|printcap|printenv|ps|pushd|pv|quota|quota
check|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+ lookbehind: true
+ },
+ 'keyword': {
+ pattern:
/(^|[\s;|&]|[<>]\()(?:if|then|else|elif|fi|for|while|in|case|esac|function|select|do|done|until)(?=$|[)\s;|&])/,
+ lookbehind: true
+ },
+ // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+ 'builtin': {
+ pattern:
/(^|[\s;|&]|[<>]\()(?:\.|:|break|cd|continue|eval|exec|exit|export|getopts|hash|pwd|readonly|return|shift|test|times|trap|umask|unset|alias|bind|builtin|caller|command|declare|echo|enable|help|let|local|logout|mapfile|printf|read|readarray|source|type|typeset|ulimit|unalias|set|shopt)(?=$|[)\s;|&])/,
+ lookbehind: true,
+ // Alias added to make those easier to distinguish from strings.
+ alias: 'class-name'
+ },
+ 'boolean': {
+ pattern: /(^|[\s;|&]|[<>]\()(?:true|false)(?=$|[)\s;|&])/,
+ lookbehind: true
+ },
+ 'file-descriptor': {
+ pattern: /\B&\d\b/,
+ alias: 'important'
+ },
+ 'operator': {
+ // Lots of redirections here, but not just that.
+ pattern: /\d?<>|>\||\+=|==?|!=?|=~|<<[<-]?|[&\d]?>>|\d?[<>]&?|&[>&]?|\|[&|]?|<=?|>=?/,
+ inside: {
+ 'file-descriptor': {
+ pattern: /^\d/,
+ alias: 'important'
+ }
+ }
+ },
+ 'punctuation': /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+ 'number': {
+ pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+ lookbehind: true
+ }
+ };
+
+ /* Patterns in command substitution. */
+ var toBeCopied = [
+ 'comment',
+ 'function-name',
+ 'for-or-select',
+ 'assign-left',
+ 'string',
+ 'environment',
+ 'function',
+ 'keyword',
+ 'builtin',
+ 'boolean',
+ 'file-descriptor',
+ 'operator',
+ 'punctuation',
+ 'number'
+ ];
+ var inside = insideString.variable[1].inside;
+ for(var i = 0; i < toBeCopied.length; i++) {
+ inside[toBeCopied[i]] = Prism.languages.bash[toBeCopied[i]];
+ }
+
+ Prism.languages.shell = Prism.languages.bash;
})(Prism);
Prism.languages.cpp = Prism.languages.extend('c', {
- 'keyword':
/\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,
- 'boolean': /\b(?:true|false)\b/,
- 'operator':
/--?|\+\+?|!=?|<{1,2}=?|>{1,2}=?|->|:{1,2}|={1,2}|\^|~|%|&{1,2}|\|\|?|\?|\*|\/|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/
-});
-
-Prism.languages.insertBefore('cpp', 'keyword', {
- 'class-name': {
- pattern: /(class\s+)\w+/i,
- lookbehind: true
- }
+ 'class-name': {
+ pattern: /(\b(?:class|enum|struct)\s+)\w+/,
+ lookbehind: true
+ },
+ 'keyword':
/\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,
+ 'number': {
+ pattern:
/(?:\b0b[01']+|\b0x(?:[\da-f']+\.?[\da-f']*|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+\.?[\d']*|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]*/i,
+ greedy: true
+ },
+ 'operator':
/>>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+ 'boolean': /\b(?:true|false)\b/
});
Prism.languages.insertBefore('cpp', 'string', {
- 'raw-string': {
- pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
- alias: 'string',
- greedy: true
- }
+ 'raw-string': {
+ pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+ alias: 'string',
+ greedy: true
+ }
});
(function(Prism) {
// Ignore comments starting with { to privilege string interpolation highlighting
-var comment = /#(?!\{).+/,
+ var comment = /#(?!\{).+/,
interpolation = {
- pattern: /#\{[^}]+\}/,
- alias: 'variable'
+ pattern: /#\{[^}]+\}/,
+ alias: 'variable'
};
-Prism.languages.coffeescript = Prism.languages.extend('javascript', {
- 'comment': comment,
- 'string': [
-
- // Strings are multiline
- {
- pattern: /'(?:\\[\s\S]|[^\\'])*'/,
- greedy: true
- },
-
- {
- // Strings are multiline
- pattern: /"(?:\\[\s\S]|[^\\"])*"/,
- greedy: true,
- inside: {
- 'interpolation': interpolation
- }
- }
- ],
- 'keyword':
/\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
- 'class-member': {
- pattern: /@(?!\d)\w+/,
- alias: 'variable'
- }
-});
-
-Prism.languages.insertBefore('coffeescript', 'comment', {
- 'multiline-comment': {
- pattern: /###[\s\S]+?###/,
- alias: 'comment'
- },
-
- // Block regexp can contain comments and interpolation
- 'block-regex': {
- pattern: /\/{3}[\s\S]*?\/{3}/,
- alias: 'regex',
- inside: {
- 'comment': comment,
- 'interpolation': interpolation
- }
- }
-});
-
-Prism.languages.insertBefore('coffeescript', 'string', {
- 'inline-javascript': {
- pattern: /`(?:\\[\s\S]|[^\\`])*`/,
- inside: {
- 'delimiter': {
- pattern: /^`|`$/,
- alias: 'punctuation'
- },
- rest: Prism.languages.javascript
- }
- },
-
- // Block strings
- 'multiline-string': [
- {
- pattern: /'''[\s\S]*?'''/,
- greedy: true,
- alias: 'string'
- },
- {
- pattern: /"""[\s\S]*?"""/,
- greedy: true,
- alias: 'string',
- inside: {
- interpolation: interpolation
- }
- }
- ]
-
-});
-
-Prism.languages.insertBefore('coffeescript', 'keyword', {
- // Object property
- 'property': /(?!\d)\w+(?=\s*:(?!:))/
-});
-
-delete Prism.languages.coffeescript['template-string'];
-
+ Prism.languages.coffeescript = Prism.languages.extend('javascript', {
+ 'comment': comment,
+ 'string': [
+
+ // Strings are multiline
+ {
+ pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+ greedy: true
+ },
+
+ {
+ // Strings are multiline
+ pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ }
+ ],
+ 'keyword':
/\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
+ 'class-member': {
+ pattern: /@(?!\d)\w+/,
+ alias: 'variable'
+ }
+ });
+
+ Prism.languages.insertBefore('coffeescript', 'comment', {
+ 'multiline-comment': {
+ pattern: /###[\s\S]+?###/,
+ alias: 'comment'
+ },
+
+ // Block regexp can contain comments and interpolation
+ 'block-regex': {
+ pattern: /\/{3}[\s\S]*?\/{3}/,
+ alias: 'regex',
+ inside: {
+ 'comment': comment,
+ 'interpolation': interpolation
+ }
+ }
+ });
+
+ Prism.languages.insertBefore('coffeescript', 'string', {
+ 'inline-javascript': {
+ pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+ inside: {
+ 'delimiter': {
+ pattern: /^`|`$/,
+ alias: 'punctuation'
+ },
+ rest: Prism.languages.javascript
+ }
+ },
+
+ // Block strings
+ 'multiline-string': [
+ {
+ pattern: /'''[\s\S]*?'''/,
+ greedy: true,
+ alias: 'string'
+ },
+ {
+ pattern: /"""[\s\S]*?"""/,
+ greedy: true,
+ alias: 'string',
+ inside: {
+ interpolation: interpolation
+ }
+ }
+ ]
+
+ });
+
+ Prism.languages.insertBefore('coffeescript', 'keyword', {
+ // Object property
+ 'property': /(?!\d)\w+(?=\s*:(?!:))/
+ });
+
+ delete Prism.languages.coffeescript['template-string'];
+
+ Prism.languages.coffee = Prism.languages.coffeescript;
}(Prism));
/**
* Original by Samuel Flores
@@ -993,1294 +1190,1461 @@ delete Prism.languages.coffeescript['template-string'];
* constant, builtin, variable, symbol, regex
*/
(function(Prism) {
- Prism.languages.ruby = Prism.languages.extend('clike', {
- 'comment': [
- /#.*/,
- {
- pattern: /^=begin(?:\r?\n|\r)(?:.*(?:\r?\n|\r))*?=end/m,
- greedy: true
- }
- ],
- '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|protected|private|public|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.languages.ruby
- }
- };
-
- Prism.languages.insertBefore('ruby', 'keyword', {
- 'regex': [
- {
- pattern: /%r([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1[gim]{0,3}/,
- greedy: true,
- inside: {
- 'interpolation': interpolation
- }
- },
- {
- pattern: /%r\((?:[^()\\]|\\[\s\S])*\)[gim]{0,3}/,
- greedy: true,
- inside: {
- 'interpolation': interpolation
- }
- },
- {
- // Here we need to specifically allow interpolation
- pattern: /%r\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}[gim]{0,3}/,
- greedy: true,
- inside: {
- 'interpolation': interpolation
- }
- },
- {
- pattern: /%r\[(?:[^\[\]\\]|\\[\s\S])*\][gim]{0,3}/,
- greedy: true,
- inside: {
- 'interpolation': interpolation
- }
- },
- {
- pattern: /%r<(?:[^<>\\]|\\[\s\S])*>[gim]{0,3}/,
- greedy: true,
- inside: {
- 'interpolation': interpolation
- }
- },
- {
- pattern:
/(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\\\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/,
- lookbehind: true,
- greedy: true
- }
- ],
- 'variable': /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
- 'symbol': {
- pattern: /(^|[^:]):[a-zA-Z_]\w*(?:[?!]|\b)/,
- lookbehind: true
- }
- });
-
- Prism.languages.insertBefore('ruby', 'number', {
- 'builtin':
/\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|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]\w*(?:[?!]|\b)/
- });
-
- Prism.languages.ruby.string = [
- {
- pattern: /%[qQiIwWxs]?([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\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|[\s\S])|(?!\1)[^\\\r\n])*\1/,
- greedy: true,
- inside: {
- 'interpolation': interpolation
- }
- }
- ];
+ Prism.languages.ruby = Prism.languages.extend('clike', {
+ 'comment': [
+ /#.*/,
+ {
+ pattern: /^=begin\s[\s\S]*?^=end/m,
+ greedy: true
+ }
+ ],
+ '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|protected|private|public|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.languages.ruby
+ }
+ };
+
+ delete Prism.languages.ruby.function;
+
+ Prism.languages.insertBefore('ruby', 'keyword', {
+ 'regex': [
+ {
+ pattern: /%r([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%r\((?:[^()\\]|\\[\s\S])*\)[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ // Here we need to specifically allow interpolation
+ pattern: /%r\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%r\[(?:[^\[\]\\]|\\[\s\S])*\][gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%r<(?:[^<>\\]|\\[\s\S])*>[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\\\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/,
+ lookbehind: true,
+ greedy: true
+ }
+ ],
+ 'variable': /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+ 'symbol': {
+ pattern: /(^|[^:]):[a-zA-Z_]\w*(?:[?!]|\b)/,
+ lookbehind: true
+ },
+ 'method-definition': {
+ pattern: /(\bdef\s+)[\w.]+/,
+ lookbehind: true,
+ inside: {
+ 'function': /\w+$/,
+ rest: Prism.languages.ruby
+ }
+ }
+ });
+
+ Prism.languages.insertBefore('ruby', 'number', {
+ 'builtin':
/\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|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]\w*(?:[?!]|\b)/
+ });
+
+ Prism.languages.ruby.string = [
+ {
+ pattern: /%[qQiIwWxs]?([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\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|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ }
+ ];
+
+ Prism.languages.rb = Prism.languages.ruby;
}(Prism));
+
Prism.languages.d = Prism.languages.extend('clike', {
- 'string': [
- // r"", x""
- /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/,
- // q"[]", q"()", q"<>", q"{}"
- /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/,
- // q"IDENT
- // ...
- // IDENT"
- /\bq"([_a-zA-Z][_a-zA-Z\d]*)(?:\r?\n|\r)[\s\S]*?(?:\r?\n|\r)\1"/,
- // q"//", q"||", etc.
- /\bq"(.)[\s\S]*?\1"/,
- // Characters
- /'(?:\\'|\\?[^']+)'/,
-
- /(["`])(?:\\[\s\S]|(?!\1)[^\\])*\1[cwd]?/
- ],
-
- 'number': [
- // The lookbehind and the negative look-ahead try to prevent bad highlighting of the ..
operator
- // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
- /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]*/i,
- {
- pattern:
/((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]*/i,
- lookbehind: true
- }
- ],
-
- // In order: $, keywords and special tokens, globally defined symbols
- 'keyword':
/\$|\b(?:abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|public|pure|real|ref|return|scope|shared|short|static|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|__(?:(?:FILE|MODULE|LINE|FUNCTION|PRETTY_FUNCTION|DATE|EOF|TIME|TIMESTAMP|VENDOR|VERSION)__|gshared|traits|vector|parameters)|string|wstring|dstring|size_t|ptrdiff_t)\b/,
- 'operator':
/\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
+ 'string': [
+ // r"", x""
+ /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/,
+ // q"[]", q"()", q"<>", q"{}"
+ /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/,
+ // q"IDENT
+ // ...
+ // IDENT"
+ /\bq"([_a-zA-Z][_a-zA-Z\d]*)(?:\r?\n|\r)[\s\S]*?(?:\r?\n|\r)\1"/,
+ // q"//", q"||", etc.
+ /\bq"(.)[\s\S]*?\1"/,
+ // Characters
+ /'(?:\\'|\\?[^']+)'/,
+
+ /(["`])(?:\\[\s\S]|(?!\1)[^\\])*\1[cwd]?/
+ ],
+
+ 'number': [
+ // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
+ // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
+ /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]*/i,
+ {
+ pattern: /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]*/i,
+ lookbehind: true
+ }
+ ],
+
+ // In order: $, keywords and special tokens, globally defined symbols
+ 'keyword':
/\$|\b(?:abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|public|pure|real|ref|return|scope|shared|short|static|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|__(?:(?:FILE|MODULE|LINE|FUNCTION|PRETTY_FUNCTION|DATE|EOF|TIME|TIMESTAMP|VENDOR|VERSION)__|gshared|traits|vector|parameters)|string|wstring|dstring|size_t|ptrdiff_t)\b/,
+ 'operator':
/\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
});
Prism.languages.d.comment = [
- // Shebang
- /^\s*#!.+/,
- // /+ +/
- {
- // Allow one level of nesting
- pattern: /(^|[^\\])\/\+(?:\/\+[\s\S]*?\+\/|[\s\S])*?\+\//,
- lookbehind: true
- }
+ // Shebang
+ /^\s*#!.+/,
+ // /+ +/
+ {
+ // Allow one level of nesting
+ pattern: /(^|[^\\])\/\+(?:\/\+[\s\S]*?\+\/|[\s\S])*?\+\//,
+ lookbehind: true
+ }
].concat(Prism.languages.d.comment);
Prism.languages.insertBefore('d', 'comment', {
- 'token-string': {
- // Allow one level of nesting
- pattern: /\bq\{(?:\{[^}]*\}|[^}])*\}/,
- alias: 'string'
- }
+ 'token-string': {
+ // Allow one level of nesting
+ pattern: /\bq\{(?:\{[^}]*\}|[^}])*\}/,
+ alias: 'string'
+ }
});
Prism.languages.insertBefore('d', 'keyword', {
- 'property': /\B@\w*/
+ 'property': /\B@\w*/
});
Prism.languages.insertBefore('d', 'function', {
- 'register': {
- // Iasm registers
- pattern:
/\b(?:[ABCD][LHX]|E[ABCD]X|E?(?:BP|SP|DI|SI)|[ECSDGF]S|CR[0234]|DR[012367]|TR[3-7]|X?MM[0-7]|R[ABCD]X|[BS]PL|R[BS]P|[DS]IL|R[DS]I|R(?:[89]|1[0-5])[BWD]?|XMM(?:[89]|1[0-5])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
- alias: 'variable'
- }
+ 'register': {
+ // Iasm registers
+ pattern:
/\b(?:[ABCD][LHX]|E[ABCD]X|E?(?:BP|SP|DI|SI)|[ECSDGF]S|CR[0234]|DR[012367]|TR[3-7]|X?MM[0-7]|R[ABCD]X|[BS]PL|R[BS]P|[DS]IL|R[DS]I|R(?:[89]|1[0-5])[BWD]?|XMM(?:[89]|1[0-5])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
+ alias: 'variable'
+ }
});
Prism.languages.dart = Prism.languages.extend('clike', {
- 'string': [
- {
- pattern: /r?("""|''')[\s\S]*?\1/,
- greedy: true
- },
- {
- pattern: /r?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
- greedy: true
- }
- ],
- 'keyword': [
- /\b(?:async|sync|yield)\*/,
-
/\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|default|deferred|do|dynamic|else|enum|export|external|extends|factory|final|finally|for|get|if|implements|import|in|library|new|null|operator|part|rethrow|return|set|static|super|switch|this|throw|try|typedef|var|void|while|with|yield)\b/
- ],
- 'operator': /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+ 'string': [
+ {
+ pattern: /r?("""|''')[\s\S]*?\1/,
+ greedy: true
+ },
+ {
+ pattern: /r?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+ greedy: true
+ }
+ ],
+ 'keyword': [
+ /\b(?:async|sync|yield)\*/,
+
/\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|default|deferred|do|dynamic|else|enum|export|external|extends|factory|final|finally|for|get|if|implements|import|in|library|new|null|operator|part|rethrow|return|set|static|super|switch|this|throw|try|typedef|var|void|while|with|yield)\b/
+ ],
+ 'operator': /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
});
Prism.languages.insertBefore('dart','function',{
- 'metadata': {
- pattern: /@\w+/,
- alias: 'symbol'
- }
+ 'metadata': {
+ pattern: /@\w+/,
+ alias: 'symbol'
+ }
});
-// Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
-// Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
-
-var _django_template = {
- 'property': {
- pattern: /(?:{{|{%)[\s\S]*?(?:%}|}})/g,
- greedy: true,
- inside: {
- 'string': {
- pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
- greedy: true
- },
- 'keyword':
/\b(?:\||load|verbatim|widthratio|ssi|firstof|for|url|ifchanged|csrf_token|lorem|ifnotequal|autoescape|now|templatetag|debug|cycle|ifequal|regroup|comment|filter|endfilter|if|spaceless|with|extends|block|include|else|empty|endif|endfor|as|endblock|endautoescape|endverbatim|trans|endtrans|[Tt]rue|[Ff]alse|[Nn]one|in|is|static|macro|endmacro|call|endcall|set|endset|raw|endraw)\b/,
- 'operator' : /[-+=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b/,
- 'function':
/\b(?:_|abs|add|addslashes|attr|batch|callable|capfirst|capitalize|center|count|cut|d|date|default|default_if_none|defined|dictsort|dictsortreversed|divisibleby|e|equalto|escape|escaped|escapejs|even|filesizeformat|first|float|floatformat|force_escape|forceescape|format|get_digit|groupby|indent|int|iriencode|iterable|join|last|length|length_is|linebreaks|linebreaksbr|linenumbers|list|ljust|lower|make_list|map|mapping|number|odd|phone2numeric|pluralize|pprint|random|reject|rejectattr|removetags|replace|reverse|rjust|round|safe|safeseq|sameas|select|selectattr|sequence|slice|slugify|sort|string|stringformat|striptags|sum|time|timesince|timeuntil|title|trim|truncate|truncatechars|truncatechars_html|truncatewords|truncatewords_html|undefined|unordered_list|upper|urlencode|urlize|urlizetrunc|wordcount|wordwrap|xmlattr|yesno)\b/,
- 'important': /\b-?\d+(?:\.\d+)?\b/,
- 'variable': /\b\w+?\b/,
- 'punctuation' : /[[\];(),.:]/
- }
- }
-};
-
-Prism.languages.django = Prism.languages.extend('markup', {'comment': /(?:<!--|{#)[\s\S]*?(?:#}|-->)/});
-// Updated html tag pattern to allow template tags inside html tags
-Prism.languages.django.tag.pattern =
/<\/?(?!\d)[^\s>\/=$<]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^>=]+))?)*\s*\/?>/i;
-Prism.languages.insertBefore('django', 'entity', _django_template);
-Prism.languages.insertBefore('inside', 'tag', _django_template, Prism.languages.django.tag);
+(function (Prism) {
-if (Prism.languages.javascript) {
- // Combine js code and template tags painting inside <script> blocks
- Prism.languages.insertBefore('inside', 'string', _django_template, Prism.languages.django.script);
- Prism.languages.django.script.inside.string.inside = _django_template;
-}
-if (Prism.languages.css) {
- // Combine css code and template tags painting inside <style> blocks
- Prism.languages.insertBefore('inside', 'atrule', {'tag': _django_template.property},
Prism.languages.django.style);
- Prism.languages.django.style.inside.string.inside = _django_template;
-}
+ /**
+ * Returns the placeholder for the given language id and index.
+ *
+ * @param {string} language
+ * @param {string|number} index
+ * @returns {string}
+ */
+ function getPlaceholder(language, index) {
+ return '___' + language.toUpperCase() + index + '___';
+ }
+
+ Object.defineProperties(Prism.languages['markup-templating'] = {}, {
+ buildPlaceholders: {
+ /**
+ * Tokenize all inline templating expressions matching `placeholderPattern`.
+ *
+ * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter`
returns
+ * `true` will be replaced.
+ *
+ * @param {object} env The environment of the `before-tokenize` hook.
+ * @param {string} language The language id.
+ * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+ * @param {(match: string) => boolean} [replaceFilter]
+ */
+ value: function (env, language, placeholderPattern, replaceFilter) {
+ if (env.language !== language) {
+ return;
+ }
+
+ var tokenStack = env.tokenStack = [];
+
+ env.code = env.code.replace(placeholderPattern, function (match) {
+ if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
+ return match;
+ }
+ var i = tokenStack.length;
+ var placeholder;
+
+ // Check for existing strings
+ while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1)
+ ++i;
+
+ // Create a sparse array
+ tokenStack[i] = match;
+
+ return placeholder;
+ });
+
+ // Switch the grammar to markup
+ env.grammar = Prism.languages.markup;
+ }
+ },
+ tokenizePlaceholders: {
+ /**
+ * Replace placeholders with proper tokens after tokenizing.
+ *
+ * @param {object} env The environment of the `after-tokenize` hook.
+ * @param {string} language The language id.
+ */
+ value: function (env, language) {
+ if (env.language !== language || !env.tokenStack) {
+ return;
+ }
+
+ // Switch the grammar back
+ env.grammar = Prism.languages[language];
+
+ var j = 0;
+ var keys = Object.keys(env.tokenStack);
+
+ function walkTokens(tokens) {
+ for (var i = 0; i < tokens.length; i++) {
+ // all placeholders are replaced already
+ if (j >= keys.length) {
+ break;
+ }
+
+ var token = tokens[i];
+ if (typeof token === 'string' || (token.content && typeof token.content === 'string')) {
+ var k = keys[j];
+ var t = env.tokenStack[k];
+ var s = typeof token === 'string' ? token : token.content;
+ var placeholder = getPlaceholder(language, k);
+
+ var index = s.indexOf(placeholder);
+ if (index > -1) {
+ ++j;
+
+ var before = s.substring(0, index);
+ var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' +
language, t);
+ var after = s.substring(index + placeholder.length);
+
+ var replacement = [];
+ if (before) {
+ replacement.push.apply(replacement, walkTokens([before]));
+ }
+ replacement.push(middle);
+ if (after) {
+ replacement.push.apply(replacement, walkTokens([after]));
+ }
+
+ if (typeof token === 'string') {
+ tokens.splice.apply(tokens, [i, 1].concat(replacement));
+ } else {
+ token.content = replacement;
+ }
+ }
+ } else if (token.content /* && typeof token.content !== 'string' */) {
+ walkTokens(token.content);
+ }
+ }
+
+ return tokens;
+ }
+
+ walkTokens(env.tokens);
+ }
+ }
+ });
-// Add an Jinja2 alias
-Prism.languages.jinja2 = Prism.languages.django;
+}(Prism));
Prism.languages.elixir = {
- 'comment': {
- pattern: /#.*/m,
- lookbehind: true
- },
- // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo),
~r[foo], ~r{foo}, ~r<foo>
- 'regex': {
- pattern:
/~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
- greedy: true
- },
- 'string': [
- {
- // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo",
~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
- pattern:
/~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
- greedy: true,
- inside: {
- // See interpolation below
- }
- },
- {
- pattern: /("""|''')[\s\S]*?\1/,
- greedy: true,
- inside: {
- // See interpolation below
- }
- },
- {
- // Multi-line strings are allowed
- pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
- greedy: true,
- inside: {
- // See interpolation below
- }
- }
- ],
- 'atom': {
- // Look-behind prevents bad highlighting of the :: operator
- pattern: /(^|[^:]):\w+/,
- lookbehind: true,
- alias: 'symbol'
- },
- // Look-ahead prevents bad highlighting of the :: operator
- 'attr-name': /\w+:(?!:)/,
- 'capture': {
- // Look-behind prevents bad highlighting of the && operator
- pattern: /(^|[^&])&(?:[^&\s\d()][^\s()]*|(?=\())/,
- lookbehind: true,
- alias: 'function'
- },
- 'argument': {
- // Look-behind prevents bad highlighting of the && operator
- pattern: /(^|[^&])&\d+/,
- lookbehind: true,
- alias: 'variable'
- },
- 'attribute': {
- pattern: /@\w+/,
- alias: 'variable'
- },
- 'number': /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
- 'keyword':
/\b(?:after|alias|and|case|catch|cond|def(?:callback|exception|impl|module|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|require|rescue|try|unless|use|when)\b/,
- 'boolean': /\b(?:true|false|nil)\b/,
- 'operator': [
- /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
- {
- // We don't want to match <<
- pattern: /([^<])<(?!<)/,
- lookbehind: true
- },
- {
- // We don't want to match >>
- pattern: /([^>])>(?!>)/,
- lookbehind: true
- }
- ],
- 'punctuation': /<<|>>|[.,%\[\]{}()]/
+ 'comment': /#.*/m,
+ // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo),
~r[foo], ~r{foo}, ~r<foo>
+ 'regex': {
+ pattern:
/~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
+ greedy: true
+ },
+ 'string': [
+ {
+ // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo),
~s[foo], ~s{foo} (with interpolation care), ~s<foo>
+ pattern:
/~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
+ greedy: true,
+ inside: {
+ // See interpolation below
+ }
+ },
+ {
+ pattern: /("""|''')[\s\S]*?\1/,
+ greedy: true,
+ inside: {
+ // See interpolation below
+ }
+ },
+ {
+ // Multi-line strings are allowed
+ pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true,
+ inside: {
+ // See interpolation below
+ }
+ }
+ ],
+ 'atom': {
+ // Look-behind prevents bad highlighting of the :: operator
+ pattern: /(^|[^:]):\w+/,
+ lookbehind: true,
+ alias: 'symbol'
+ },
+ // Look-ahead prevents bad highlighting of the :: operator
+ 'attr-name': /\w+:(?!:)/,
+ 'capture': {
+ // Look-behind prevents bad highlighting of the && operator
+ pattern: /(^|[^&])&(?:[^&\s\d()][^\s()]*|(?=\())/,
+ lookbehind: true,
+ alias: 'function'
+ },
+ 'argument': {
+ // Look-behind prevents bad highlighting of the && operator
+ pattern: /(^|[^&])&\d+/,
+ lookbehind: true,
+ alias: 'variable'
+ },
+ 'attribute': {
+ pattern: /@\w+/,
+ alias: 'variable'
+ },
+ 'number': /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
+ 'keyword':
/\b(?:after|alias|and|case|catch|cond|def(?:callback|exception|impl|module|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|require|rescue|try|unless|use|when)\b/,
+ 'boolean': /\b(?:true|false|nil)\b/,
+ 'operator': [
+ /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
+ {
+ // We don't want to match <<
+ pattern: /([^<])<(?!<)/,
+ lookbehind: true
+ },
+ {
+ // We don't want to match >>
+ pattern: /([^>])>(?!>)/,
+ lookbehind: true
+ }
+ ],
+ 'punctuation': /<<|>>|[.,%\[\]{}()]/
};
Prism.languages.elixir.string.forEach(function(o) {
- o.inside = {
- 'interpolation': {
- pattern: /#\{[^}]+\}/,
- inside: {
- 'delimiter': {
- pattern: /^#\{|\}$/,
- alias: 'punctuation'
- },
- rest: Prism.languages.elixir
- }
- }
- };
+ o.inside = {
+ 'interpolation': {
+ pattern: /#\{[^}]+\}/,
+ inside: {
+ 'delimiter': {
+ pattern: /^#\{|\}$/,
+ alias: 'punctuation'
+ },
+ rest: Prism.languages.elixir
+ }
+ }
+ };
});
-
-Prism.languages['markup-templating'] = {};
-
-Object.defineProperties(Prism.languages['markup-templating'], {
- buildPlaceholders: {
- // Tokenize all inline templating expressions matching placeholderPattern
- // If the replaceFilter function is provided, it will be called with every match.
- // If it returns false, the match will not be replaced.
- value: function (env, language, placeholderPattern, replaceFilter) {
- if (env.language !== language) {
- return;
- }
-
- env.tokenStack = [];
-
- env.code = env.code.replace(placeholderPattern, function(match) {
- if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
- return match;
- }
- var i = env.tokenStack.length;
- // Check for existing strings
- while (env.code.indexOf('___' + language.toUpperCase() + i + '___') !== -1)
- ++i;
-
- // Create a sparse array
- env.tokenStack[i] = match;
-
- return '___' + language.toUpperCase() + i + '___';
- });
-
- // Switch the grammar to markup
- env.grammar = Prism.languages.markup;
- }
- },
- tokenizePlaceholders: {
- // Replace placeholders with proper tokens after tokenizing
- value: function (env, language) {
- if (env.language !== language || !env.tokenStack) {
- return;
- }
-
- // Switch the grammar back
- env.grammar = Prism.languages[language];
-
- var j = 0;
- var keys = Object.keys(env.tokenStack);
- var walkTokens = function (tokens) {
- if (j >= keys.length) {
- return;
- }
- for (var i = 0; i < tokens.length; i++) {
- var token = tokens[i];
- if (typeof token === 'string' || (token.content && typeof
token.content === 'string')) {
- var k = keys[j];
- var t = env.tokenStack[k];
- var s = typeof token === 'string' ? token : token.content;
-
- var index = s.indexOf('___' + language.toUpperCase() + k +
'___');
- if (index > -1) {
- ++j;
- var before = s.substring(0, index);
- var middle = new Prism.Token(language,
Prism.tokenize(t, env.grammar, language), 'language-' + language, t);
- var after = s.substring(index + ('___' +
language.toUpperCase() + k + '___').length);
- var replacement;
- if (before || after) {
- replacement = [before, middle,
after].filter(function (v) { return !!v; });
- walkTokens(replacement);
- } else {
- replacement = middle;
- }
- if (typeof token === 'string') {
- Array.prototype.splice.apply(tokens, [i,
1].concat(replacement));
- } else {
- token.content = replacement;
- }
-
- if (j >= keys.length) {
- break;
- }
- }
- } else if (token.content && typeof token.content !== 'string') {
- walkTokens(token.content);
- }
- }
- };
-
- walkTokens(env.tokens);
- }
- }
-});
Prism.languages.erlang = {
- 'comment': /%.+/,
- 'string': {
- pattern: /"(?:\\.|[^\\"\r\n])*"/,
- greedy: true
- },
- 'quoted-function': {
- pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
- alias: 'function'
- },
- 'quoted-atom': {
- pattern: /'(?:\\.|[^\\'\r\n])+'/,
- alias: 'atom'
- },
- 'boolean': /\b(?:true|false)\b/,
- 'keyword': /\b(?:fun|when|case|of|end|if|receive|after|try|catch)\b/,
- 'number': [
- /\$\\?./,
- /\d+#[a-z0-9]+/i,
- /(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i
- ],
- 'function': /\b[a-z][\w@]*(?=\()/,
- 'variable': {
- // Look-behind is used to prevent wrong highlighting of atoms containing "@"
- pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
- lookbehind: true
- },
- 'operator': [
-
/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:bnot|div|rem|band|bor|bxor|bsl|bsr|not|and|or|xor|orelse|andalso)\b/,
- {
- // We don't want to match <<
- pattern: /(^|[^<])<(?!<)/,
- lookbehind: true
- },
- {
- // We don't want to match >>
- pattern: /(^|[^>])>(?!>)/,
- lookbehind: true
- }
- ],
- 'atom': /\b[a-z][\w@]*/,
- 'punctuation': /[()[\]{}:;,.#|]|<<|>>/
+ 'comment': /%.+/,
+ 'string': {
+ pattern: /"(?:\\.|[^\\"\r\n])*"/,
+ greedy: true
+ },
+ 'quoted-function': {
+ pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
+ alias: 'function'
+ },
+ 'quoted-atom': {
+ pattern: /'(?:\\.|[^\\'\r\n])+'/,
+ alias: 'atom'
+ },
+ 'boolean': /\b(?:true|false)\b/,
+ 'keyword': /\b(?:fun|when|case|of|end|if|receive|after|try|catch)\b/,
+ 'number': [
+ /\$\\?./,
+ /\d+#[a-z0-9]+/i,
+ /(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i
+ ],
+ 'function': /\b[a-z][\w@]*(?=\()/,
+ 'variable': {
+ // Look-behind is used to prevent wrong highlighting of atoms containing "@"
+ pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
+ lookbehind: true
+ },
+ 'operator': [
+
/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:bnot|div|rem|band|bor|bxor|bsl|bsr|not|and|or|xor|orelse|andalso)\b/,
+ {
+ // We don't want to match <<
+ pattern: /(^|[^<])<(?!<)/,
+ lookbehind: true
+ },
+ {
+ // We don't want to match >>
+ pattern: /(^|[^>])>(?!>)/,
+ lookbehind: true
+ }
+ ],
+ 'atom': /\b[a-z][\w@]*/,
+ 'punctuation': /[()[\]{}:;,.#|]|<<|>>/
};
Prism.languages.go = Prism.languages.extend('clike', {
- 'keyword':
/\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
- 'builtin':
/\b(?:bool|byte|complex(?:64|128)|error|float(?:32|64)|rune|string|u?int(?:8|16|32|64)?|uintptr|append|cap|close|complex|copy|delete|imag|len|make|new|panic|print(?:ln)?|real|recover)\b/,
- 'boolean': /\b(?:_|iota|nil|true|false)\b/,
- 'operator': /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
- 'number': /(?:\b0x[a-f\d]+|(?:\b\d+\.?\d*|\B\.\d+)(?:e[-+]?\d+)?)i?/i,
- 'string': {
- pattern: /(["'`])(\\[\s\S]|(?!\1)[^\\])*\1/,
- greedy: true
- }
+ 'keyword':
/\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
+ 'builtin':
/\b(?:bool|byte|complex(?:64|128)|error|float(?:32|64)|rune|string|u?int(?:8|16|32|64)?|uintptr|append|cap|close|complex|copy|delete|imag|len|make|new|panic|print(?:ln)?|real|recover)\b/,
+ 'boolean': /\b(?:_|iota|nil|true|false)\b/,
+ 'operator': /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
+ 'number': /(?:\b0x[a-f\d]+|(?:\b\d+\.?\d*|\B\.\d+)(?:e[-+]?\d+)?)i?/i,
+ 'string': {
+ pattern: /(["'`])(\\[\s\S]|(?!\1)[^\\])*\1/,
+ greedy: true
+ }
});
delete Prism.languages.go['class-name'];
-Prism.languages.java = Prism.languages.extend('clike', {
- 'keyword':
/\b(?:abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while)\b/,
- 'number': /\b0b[01]+\b|\b0x[\da-f]*\.?[\da-fp-]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?[df]?/i,
- 'operator': {
- pattern:
/(^|[^.])(?:\+[+=]?|-[-=]?|!=?|<<?=?|>>?>?=?|==?|&[&=]?|\|[|=]?|\*=?|\/=?|%=?|\^=?|[?:~])/m,
- lookbehind: true
- }
-});
+(function (Prism) {
-Prism.languages.insertBefore('java','function', {
- 'annotation': {
- alias: 'punctuation',
- pattern: /(^|[^.])@\w+/,
- lookbehind: true
- }
-});
+ var keywords =
/\b(?:abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while|var|null|exports|module|open|opens|provides|requires|to|transitive|uses|with)\b/;
+
+ // based on the java naming conventions
+ var className = /\b[A-Z](?:\w*[a-z]\w*)?\b/;
+
+ Prism.languages.java = Prism.languages.extend('clike', {
+ 'class-name': [
+ className,
+
+ // variables and parameters
+ // this to support class names (or generic parameters) which do not contain a lower case letter (also
works for methods)
+ /\b[A-Z]\w*(?=\s+\w+\s*[;,=())])/
+ ],
+ 'keyword': keywords,
+ 'function': [
+ Prism.languages.clike.function,
+ {
+ pattern: /(\:\:)[a-z_]\w*/,
+ lookbehind: true
+ }
+ ],
+ 'number':
/\b0b[01][01_]*L?\b|\b0x[\da-f_]*\.?[\da-f_p+-]+\b|(?:\b\d[\d_]*\.?[\d_]*|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+ 'operator': {
+ pattern: /(^|[^.])(?:<<=?|>>>?=?|->|([-+&|])\2|[?:~]|[-+*/%&|^!=<>]=?)/m,
+ lookbehind: true
+ }
+ });
+
+ Prism.languages.insertBefore('java', 'class-name', {
+ 'annotation': {
+ alias: 'punctuation',
+ pattern: /(^|[^.])@\w+/,
+ lookbehind: true
+ },
+ 'namespace': {
+ pattern:
/(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)[a-z]\w*(\.[a-z]\w*)+/,
+ lookbehind: true,
+ inside: {
+ 'punctuation': /\./,
+ }
+ },
+ 'generics': {
+ pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+ inside: {
+ 'class-name': className,
+ 'keyword': keywords,
+ 'punctuation': /[<>(),.:]/,
+ 'operator': /[?&|]/
+ }
+ }
+ });
+}(Prism));
-Prism.languages.insertBefore('java', 'class-name', {
- 'generics': {
- pattern: /<\s*\w+(?:\.\w+)?(?:\s*,\s*\w+(?:\.\w+)?)*>/i,
- alias: 'function',
- inside: {
- keyword: Prism.languages.java.keyword,
- punctuation: /[<>(),.:]/
- }
- }
-});
+/**
+ * Original by Aaron Harun: http://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/
+ * Modified by Miles Johnson: http://milesj.me
+ *
+ * Supports the following:
+ * - Extends clike syntax
+ * - Support for PHP 5.3+ (namespaces, traits, generators, etc)
+ * - Smarter constant and function matching
+ *
+ * Adds the following new token classes:
+ * constant, delimiter, variable, function, package
+ */
+(function (Prism) {
+ Prism.languages.php = Prism.languages.extend('clike', {
+ 'keyword':
/\b(?:__halt_compiler|abstract|and|array|as|break|callable|case|catch|class|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|eval|exit|extends|final|finally|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|namespace|new|or|parent|print|private|protected|public|require|require_once|return|static|switch|throw|trait|try|unset|use|var|while|xor|yield)\b/i,
+ 'boolean': {
+ pattern: /\b(?:false|true)\b/i,
+ alias: 'constant'
+ },
+ 'constant': [
+ /\b[A-Z_][A-Z0-9_]*\b/,
+ /\b(?:null)\b/i,
+ ],
+ 'comment': {
+ pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+ lookbehind: true
+ }
+ });
+
+ Prism.languages.insertBefore('php', 'string', {
+ 'shell-comment': {
+ pattern: /(^|[^\\])#.*/,
+ lookbehind: true,
+ alias: 'comment'
+ }
+ });
+
+ Prism.languages.insertBefore('php', 'comment', {
+ 'delimiter': {
+ pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+ alias: 'important'
+ }
+ });
+
+ Prism.languages.insertBefore('php', 'keyword', {
+ 'variable': /\$+(?:\w+\b|(?={))/i,
+ 'package': {
+ pattern: /(\\|namespace\s+|use\s+)[\w\\]+/,
+ lookbehind: true,
+ inside: {
+ punctuation: /\\/
+ }
+ }
+ });
+
+ // Must be defined after the function pattern
+ Prism.languages.insertBefore('php', 'operator', {
+ 'property': {
+ pattern: /(->)[\w]+/,
+ lookbehind: true
+ }
+ });
+
+ var string_interpolation = {
+ pattern: /{\$(?:{(?:{[^{}]+}|[^{}]+)}|[^{}])+}|(^|[^\\{])\$+(?:\w+(?:\[.+?]|->\w+)*)/,
+ lookbehind: true,
+ inside: {
+ rest: Prism.languages.php
+ }
+ };
+
+ Prism.languages.insertBefore('php', 'string', {
+ 'nowdoc-string': {
+ pattern: /<<<'([^']+)'(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;/,
+ greedy: true,
+ alias: 'string',
+ inside: {
+ 'delimiter': {
+ pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+ alias: 'symbol',
+ inside: {
+ 'punctuation': /^<<<'?|[';]$/
+ }
+ }
+ }
+ },
+ 'heredoc-string': {
+ pattern:
/<<<(?:"([^"]+)"(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;|([a-z_]\w*)(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\2;)/i,
+ greedy: true,
+ alias: 'string',
+ inside: {
+ 'delimiter': {
+ pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+ alias: 'symbol',
+ inside: {
+ 'punctuation': /^<<<"?|[";]$/
+ }
+ },
+ 'interpolation': string_interpolation // See below
+ }
+ },
+ 'single-quoted-string': {
+ pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+ greedy: true,
+ alias: 'string'
+ },
+ 'double-quoted-string': {
+ pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+ greedy: true,
+ alias: 'string',
+ inside: {
+ 'interpolation': string_interpolation // See below
+ }
+ }
+ });
+ // The different types of PHP strings "replace" the C-like standard string
+ delete Prism.languages.php['string'];
+
+ Prism.hooks.add('before-tokenize', function(env) {
+ if (!/<\?/.test(env.code)) {
+ return;
+ }
+
+ var phpPattern =
/<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#)(?:[^?\n\r]|\?(?!>))*|\/\*[\s\S]*?(?:\*\/|$))*?(?:\?>|$)/ig;
+ Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern);
+ });
+
+ Prism.hooks.add('after-tokenize', function(env) {
+ Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php');
+ });
+
+}(Prism));
Prism.languages.json = {
- 'property': /"(?:\\.|[^\\"\r\n])*"(?=\s*:)/i,
- 'string': {
- pattern: /"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
- greedy: true
- },
- 'number': /-?\d+\.?\d*([Ee][+-]?\d+)?/,
- 'punctuation': /[{}[\],]/,
- 'operator': /:/g,
- 'boolean': /\b(?:true|false)\b/i,
- 'null': /\bnull\b/i
+ 'property': {
+ pattern: /"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+ greedy: true
+ },
+ 'string': {
+ pattern: /"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+ greedy: true
+ },
+ 'comment': /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+ 'number': /-?\d+\.?\d*(e[+-]?\d+)?/i,
+ 'punctuation': /[{}[\],]/,
+ 'operator': /:/,
+ 'boolean': /\b(?:true|false)\b/,
+ 'null': {
+ pattern: /\bnull\b/,
+ alias: 'keyword'
+ }
};
-Prism.languages.jsonp = Prism.languages.json;
-
(function (Prism) {
- Prism.languages.kotlin = Prism.languages.extend('clike', {
- 'keyword': {
- // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
- pattern:
/(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
- lookbehind: true
- },
- 'function': [
- /\w+(?=\s*\()/,
- {
- pattern: /(\.)\w+(?=\s*\{)/,
- lookbehind: 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"];
-
- Prism.languages.insertBefore('kotlin', 'string', {
- 'raw-string': {
- pattern: /("""|''')[\s\S]*?\1/,
- alias: 'string'
- // See interpolation below
- }
- });
- Prism.languages.insertBefore('kotlin', 'keyword', {
- 'annotation': {
- pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
- alias: 'builtin'
- }
- });
- Prism.languages.insertBefore('kotlin', 'function', {
- 'label': {
- pattern: /\w+@|@\w+/,
- 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.kotlin = Prism.languages.extend('clike', {
+ 'keyword': {
+ // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
+ pattern:
/(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+ lookbehind: true
+ },
+ 'function': [
+ /\w+(?=\s*\()/,
+ {
+ pattern: /(\.)\w+(?=\s*\{)/,
+ lookbehind: 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"];
+
+ Prism.languages.insertBefore('kotlin', 'string', {
+ 'raw-string': {
+ pattern: /("""|''')[\s\S]*?\1/,
+ alias: 'string'
+ // See interpolation below
+ }
+ });
+ Prism.languages.insertBefore('kotlin', 'keyword', {
+ 'annotation': {
+ pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+ alias: 'builtin'
+ }
+ });
+ Prism.languages.insertBefore('kotlin', 'function', {
+ 'label': {
+ pattern: /\w+@|@\w+/,
+ 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));
-Prism.languages.lua = {
- 'comment': /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
- // \z may be used to skip the following space
- 'string': {
- pattern:
/(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[\s\S]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
- greedy: true
- },
- 'number':
/\b0x[a-f\d]+\.?[a-f\d]*(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|\.?\d*(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
- 'keyword':
/\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
- 'function': /(?!\d)\w+(?=\s*(?:[({]))/,
- 'operator': [
- /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
- {
- // Match ".." but don't break "..."
- pattern: /(^|[^.])\.\.(?!\.)/,
- lookbehind: true
- }
- ],
- 'punctuation': /[\[\](){},;]|\.+|:+/
-};
(function(Prism) {
- Prism.languages.crystal = Prism.languages.extend('ruby', {
- keyword: [
-
/\b(?:abstract|alias|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|rescue|return|require|select|self|sizeof|struct|super|then|type|typeof|uninitialized|union|unless|until|when|while|with|yield|__DIR__|__END_LINE__|__FILE__|__LINE__)\b/,
- {
- pattern: /(\.\s*)(?:is_a|responds_to)\?/,
- lookbehind: true
- }
- ],
-
- number:
/\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/
- });
-
- Prism.languages.insertBefore('crystal', 'string', {
- attribute: {
- pattern: /@\[.+?\]/,
- alias: 'attr-name',
- inside: {
- delimiter: {
- pattern: /^@\[|\]$/,
- alias: 'tag'
- },
- rest: Prism.languages.crystal
- }
- },
-
- expansion: [
- {
- pattern: /\{\{.+?\}\}/,
- inside: {
- delimiter: {
- pattern: /^\{\{|\}\}$/,
- alias: 'tag'
- },
- rest: Prism.languages.crystal
- }
- },
- {
- pattern: /\{%.+?%\}/,
- inside: {
- delimiter: {
- pattern: /^\{%|%\}$/,
- alias: 'tag'
- },
- rest: Prism.languages.crystal
- }
- }
- ]
- });
+ Prism.languages.crystal = Prism.languages.extend('ruby', {
+ keyword: [
+
/\b(?:abstract|alias|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|rescue|return|require|select|self|sizeof|struct|super|then|type|typeof|uninitialized|union|unless|until|when|while|with|yield|__DIR__|__END_LINE__|__FILE__|__LINE__)\b/,
+ {
+ pattern: /(\.\s*)(?:is_a|responds_to)\?/,
+ lookbehind: true
+ }
+ ],
+
+ number:
/\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/
+ });
+
+ Prism.languages.insertBefore('crystal', 'string', {
+ attribute: {
+ pattern: /@\[.+?\]/,
+ alias: 'attr-name',
+ inside: {
+ delimiter: {
+ pattern: /^@\[|\]$/,
+ alias: 'tag'
+ },
+ rest: Prism.languages.crystal
+ }
+ },
+
+ expansion: [
+ {
+ pattern: /\{\{.+?\}\}/,
+ inside: {
+ delimiter: {
+ pattern: /^\{\{|\}\}$/,
+ alias: 'tag'
+ },
+ rest: Prism.languages.crystal
+ }
+ },
+ {
+ pattern: /\{%.+?%\}/,
+ inside: {
+ delimiter: {
+ pattern: /^\{%|%\}$/,
+ alias: 'tag'
+ },
+ rest: Prism.languages.crystal
+ }
+ }
+ ]
+ });
}(Prism));
+Prism.languages.lua = {
+ 'comment': /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
+ // \z may be used to skip the following space
+ 'string': {
+ pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[\s\S]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
+ greedy: true
+ },
+ 'number':
/\b0x[a-f\d]+\.?[a-f\d]*(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|\.?\d*(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+ 'keyword':
/\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
+ 'function': /(?!\d)\w+(?=\s*(?:[({]))/,
+ 'operator': [
+ /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
+ {
+ // Match ".." but don't break "..."
+ pattern: /(^|[^.])\.\.(?!\.)/,
+ lookbehind: true
+ }
+ ],
+ 'punctuation': /[\[\](){},;]|\.+|:+/
+};
+// Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
+// Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
+
+(function (Prism) {
+
+ Prism.languages.django = {
+ 'comment': /^{#[\s\S]*?#}$/,
+ 'tag': {
+ pattern: /(^{%[+-]?\s*)\w+/,
+ lookbehind: true,
+ alias: 'keyword'
+ },
+ 'delimiter': {
+ pattern: /^{[{%][+-]?|[+-]?[}%]}$/,
+ alias: 'punctuation'
+ },
+ 'string': {
+ pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+ greedy: true
+ },
+ 'filter': {
+ pattern: /(\|)\w+/,
+ lookbehind: true,
+ alias: 'function'
+ },
+ 'test': {
+ pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+ lookbehind: true,
+ alias: 'function'
+ },
+ 'function': /\b[a-z_]\w+(?=\s*\()/i,
+ 'keyword': /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+ 'operator': /[-+*/%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+ 'number': /\b\d+(?:\.\d+)?\b/,
+ 'boolean': /[Tt]rue|[Ff]alse|[Nn]one/,
+ 'variable': /\b\w+?\b/,
+ 'punctuation': /[{}[\](),.:;]/
+ };
+
+
+ var pattern = /{{[\s\S]*?}}|{%[\s\S]*?%}|{#[\s\S]*?#}/g;
+ var markupTemplating = Prism.languages['markup-templating'];
+
+ Prism.hooks.add('before-tokenize', function (env) {
+ markupTemplating.buildPlaceholders(env, 'django', pattern);
+ });
+ Prism.hooks.add('after-tokenize', function (env) {
+ markupTemplating.tokenizePlaceholders(env, 'django');
+ });
+
+ // Add an Jinja2 alias
+ Prism.languages.jinja2 = Prism.languages.django;
+ Prism.hooks.add('before-tokenize', function (env) {
+ markupTemplating.buildPlaceholders(env, 'jinja2', pattern);
+ });
+ Prism.hooks.add('after-tokenize', function (env) {
+ markupTemplating.tokenizePlaceholders(env, 'jinja2');
+ });
+
+})(Prism);
+
+Prism.languages.matlab = {
+ 'comment': [
+ /%\{[\s\S]*?\}%/,
+ /%.+/
+ ],
+ 'string': {
+ pattern: /\B'(?:''|[^'\r\n])*'/,
+ greedy: true
+ },
+ // FIXME We could handle imaginary numbers as a whole
+ 'number': /(?:\b\d+\.?\d*|\B\.\d+)(?:[eE][+-]?\d+)?(?:[ij])?|\b[ij]\b/,
+ 'keyword':
/\b(?:break|case|catch|continue|else|elseif|end|for|function|if|inf|NaN|otherwise|parfor|pause|pi|return|switch|try|while)\b/,
+ 'function': /(?!\d)\w+(?=\s*\()/,
+ 'operator': /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/,
+ 'punctuation': /\.{3}|[.,;\[\](){}!]/
+};
+Prism.languages.typescript = Prism.languages.extend('javascript', {
+ // From JavaScript Prism keyword list and TypeScript language spec:
https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#221-reserved-words
+ 'keyword':
/\b(?:abstract|as|async|await|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|var|void|while|with|yield)\b/,
+ 'builtin': /\b(?:string|Function|any|number|boolean|Array|symbol|console|Promise|unknown|never)\b/,
+});
+
+Prism.languages.ts = Prism.languages.typescript;
+
Prism.languages.nginx = Prism.languages.extend('clike', {
- 'comment': {
- pattern: /(^|[^"{\\])#.*/,
- lookbehind: true
- },
- 'keyword':
/\b(?:CONTENT_|DOCUMENT_|GATEWAY_|HTTP_|HTTPS|if_not_empty|PATH_|QUERY_|REDIRECT_|REMOTE_|REQUEST_|SCGI|SCRIPT_|SERVER_|http|events|accept_mutex|accept_mutex_delay|access_log|add_after_body|add_before_body|add_header|addition_types|aio|alias|allow|ancient_browser|ancient_browser_value|auth|auth_basic|auth_basic_user_file|auth_http|auth_http_header|auth_http_timeout|autoindex|autoindex_exact_size|autoindex_localtime|break|charset|charset_map|charset_types|chunked_transfer_encoding|client_body_buffer_size|client_body_in_file_only|client_body_in_single_buffer|client_body_temp_path|client_body_timeout|client_header_buffer_size|client_header_timeout|client_max_body_size|connection_pool_size|create_full_put_path|daemon|dav_access|dav_methods|debug_connection|debug_points|default_type|deny|devpoll_changes|devpoll_events|directio|directio_alignment|disable_symlinks|empty_gif|env|epoll_events|error_log|error_page|expires|fastcgi_buffer_size|fastcgi_buffers|fastcgi_busy_buffers_si
ze|fastcgi_cache|fastcgi_cache_bypass|fastcgi_cache_key|fastcgi_cache_lock|fastcgi_cache_lock_timeout|fastcgi_cache_methods|fastcgi_cache_min_uses|fastcgi_cache_path|fastcgi_cache_purge|fastcgi_cache_use_stale|fastcgi_cache_valid|fastcgi_connect_timeout|fastcgi_hide_header|fastcgi_ignore_client_abort|fastcgi_ignore_headers|fastcgi_index|fastcgi_intercept_errors|fastcgi_keep_conn|fastcgi_max_temp_file_size|fastcgi_next_upstream|fastcgi_no_cache|fastcgi_param|fastcgi_pass|fastcgi_pass_header|fastcgi_read_timeout|fastcgi_redirect_errors|fastcgi_send_timeout|fastcgi_split_path_info|fastcgi_store|fastcgi_store_access|fastcgi_temp_file_write_size|fastcgi_temp_path|flv|geo|geoip_city|geoip_country|google_perftools_profiles|gzip|gzip_buffers|gzip_comp_level|gzip_disable|gzip_http_version|gzip_min_length|gzip_proxied|gzip_static|gzip_types|gzip_vary|if|if_modified_since|ignore_invalid_headers|image_filter|image_filter_buffer|image_filter_jpeg_quality|image_filter_sharpen|image_filter_transpa
rency|imap_capabilities|imap_client_buffer|include|index|internal|ip_hash|keepalive|keepalive_disable|keepalive_requests|keepalive_timeout|kqueue_changes|kqueue_events|large_client_header_buffers|limit_conn|limit_conn_log_level|limit_conn_zone|limit_except|limit_rate|limit_rate_after|limit_req|limit_req_log_level|limit_req_zone|limit_zone|lingering_close|lingering_time|lingering_timeout|listen|location|lock_file|log_format|log_format_combined|log_not_found|log_subrequest|map|map_hash_bucket_size|map_hash_max_size|master_process|max_ranges|memcached_buffer_size|memcached_connect_timeout|memcached_next_upstream|memcached_pass|memcached_read_timeout|memcached_send_timeout|merge_slashes|min_delete_depth|modern_browser|modern_browser_value|mp4|mp4_buffer_size|mp4_max_buffer_size|msie_padding|msie_refresh|multi_accept|open_file_cache|open_file_cache_errors|open_file_cache_min_uses|open_file_cache_valid|open_log_file_cache|optimize_server_names|override_charset|pcre_jit|perl|perl_modules|p
erl_require|perl_set|pid|pop3_auth|pop3_capabilities|port_in_redirect|post_action|postpone_output|protocol|proxy|proxy_buffer|proxy_buffer_size|proxy_buffering|proxy_buffers|proxy_busy_buffers_size|proxy_cache|proxy_cache_bypass|proxy_cache_key|proxy_cache_lock|proxy_cache_lock_timeout|proxy_cache_methods|proxy_cache_min_uses|proxy_cache_path|proxy_cache_use_stale|proxy_cache_valid|proxy_connect_timeout|proxy_cookie_domain|proxy_cookie_path|proxy_headers_hash_bucket_size|proxy_headers_hash_max_size|proxy_hide_header|proxy_http_version|proxy_ignore_client_abort|proxy_ignore_headers|proxy_intercept_errors|proxy_max_temp_file_size|proxy_method|proxy_next_upstream|proxy_no_cache|proxy_pass|proxy_pass_error_message|proxy_pass_header|proxy_pass_request_body|proxy_pass_request_headers|proxy_read_timeout|proxy_redirect|proxy_redirect_errors|proxy_send_lowat|proxy_send_timeout|proxy_set_body|proxy_set_header|proxy_ssl_session_reuse|proxy_store|proxy_store_access|proxy_temp_file_write_size|pr
oxy_temp_path|proxy_timeout|proxy_upstream_fail_timeout|proxy_upstream_max_fails|random_index|read_ahead|real_ip_header|recursive_error_pages|request_pool_size|reset_timedout_connection|resolver|resolver_timeout|return|rewrite|root|rtsig_overflow_events|rtsig_overflow_test|rtsig_overflow_threshold|rtsig_signo|satisfy|satisfy_any|secure_link_secret|send_lowat|send_timeout|sendfile|sendfile_max_chunk|server|server_name|server_name_in_redirect|server_names_hash_bucket_size|server_names_hash_max_size|server_tokens|set|set_real_ip_from|smtp_auth|smtp_capabilities|so_keepalive|source_charset|split_clients|ssi|ssi_silent_errors|ssi_types|ssi_value_length|ssl|ssl_certificate|ssl_certificate_key|ssl_ciphers|ssl_client_certificate|ssl_crl|ssl_dhparam|ssl_engine|ssl_prefer_server_ciphers|ssl_protocols|ssl_session_cache|ssl_session_timeout|ssl_verify_client|ssl_verify_depth|starttls|stub_status|sub_filter|sub_filter_once|sub_filter_types|tcp_nodelay|tcp_nopush|timeout|timer_resolution|try_files
|types|types_hash_bucket_size|types_hash_max_size|underscores_in_headers|uninitialized_variable_warn|upstream|use|user|userid|userid_domain|userid_expires|userid_name|userid_p3p|userid_path|userid_service|valid_referers|variables_hash_bucket_size|variables_hash_max_size|worker_connections|worker_cpu_affinity|worker_priority|worker_processes|worker_rlimit_core|worker_rlimit_nofile|worker_rlimit_sigpending|working_directory|xclient|xml_entities|xslt_entities|xslt_stylesheet|xslt_types)\b/i
+ 'comment': {
+ pattern: /(^|[^"{\\])#.*/,
+ lookbehind: true
+ },
+ 'keyword':
/\b(?:CONTENT_|DOCUMENT_|GATEWAY_|HTTP_|HTTPS|if_not_empty|PATH_|QUERY_|REDIRECT_|REMOTE_|REQUEST_|SCGI|SCRIPT_|SERVER_|http|events|accept_mutex|accept_mutex_delay|access_log|add_after_body|add_before_body|add_header|addition_types|aio|alias|allow|ancient_browser|ancient_browser_value|auth|auth_basic|auth_basic_user_file|auth_http|auth_http_header|auth_http_timeout|autoindex|autoindex_exact_size|autoindex_localtime|break|charset|charset_map|charset_types|chunked_transfer_encoding|client_body_buffer_size|client_body_in_file_only|client_body_in_single_buffer|client_body_temp_path|client_body_timeout|client_header_buffer_size|client_header_timeout|client_max_body_size|connection_pool_size|create_full_put_path|daemon|dav_access|dav_methods|debug_connection|debug_points|default_type|deny|devpoll_changes|devpoll_events|directio|directio_alignment|disable_symlinks|empty_gif|env|epoll_events|error_log|error_page|expires|fastcgi_buffer_size|fastcgi_buffers|fastcgi_busy_buffers_s
ize|fastcgi_cache|fastcgi_cache_bypass|fastcgi_cache_key|fastcgi_cache_lock|fastcgi_cache_lock_timeout|fastcgi_cache_methods|fastcgi_cache_min_uses|fastcgi_cache_path|fastcgi_cache_purge|fastcgi_cache_use_stale|fastcgi_cache_valid|fastcgi_connect_timeout|fastcgi_hide_header|fastcgi_ignore_client_abort|fastcgi_ignore_headers|fastcgi_index|fastcgi_intercept_errors|fastcgi_keep_conn|fastcgi_max_temp_file_size|fastcgi_next_upstream|fastcgi_no_cache|fastcgi_param|fastcgi_pass|fastcgi_pass_header|fastcgi_read_timeout|fastcgi_redirect_errors|fastcgi_send_timeout|fastcgi_split_path_info|fastcgi_store|fastcgi_store_access|fastcgi_temp_file_write_size|fastcgi_temp_path|flv|geo|geoip_city|geoip_country|google_perftools_profiles|gzip|gzip_buffers|gzip_comp_level|gzip_disable|gzip_http_version|gzip_min_length|gzip_proxied|gzip_static|gzip_types|gzip_vary|if|if_modified_since|ignore_invalid_headers|image_filter|image_filter_buffer|image_filter_jpeg_quality|image_filter_sharpen|image_filter_transp
arency|imap_capabilities|imap_client_buffer|include|index|internal|ip_hash|keepalive|keepalive_disable|keepalive_requests|keepalive_timeout|kqueue_changes|kqueue_events|large_client_header_buffers|limit_conn|limit_conn_log_level|limit_conn_zone|limit_except|limit_rate|limit_rate_after|limit_req|limit_req_log_level|limit_req_zone|limit_zone|lingering_close|lingering_time|lingering_timeout|listen|location|lock_file|log_format|log_format_combined|log_not_found|log_subrequest|map|map_hash_bucket_size|map_hash_max_size|master_process|max_ranges|memcached_buffer_size|memcached_connect_timeout|memcached_next_upstream|memcached_pass|memcached_read_timeout|memcached_send_timeout|merge_slashes|min_delete_depth|modern_browser|modern_browser_value|mp4|mp4_buffer_size|mp4_max_buffer_size|msie_padding|msie_refresh|multi_accept|open_file_cache|open_file_cache_errors|open_file_cache_min_uses|open_file_cache_valid|open_log_file_cache|optimize_server_names|override_charset|pcre_jit|perl|perl_modules|
perl_require|perl_set|pid|pop3_auth|pop3_capabilities|port_in_redirect|post_action|postpone_output|protocol|proxy|proxy_buffer|proxy_buffer_size|proxy_buffering|proxy_buffers|proxy_busy_buffers_size|proxy_cache|proxy_cache_bypass|proxy_cache_key|proxy_cache_lock|proxy_cache_lock_timeout|proxy_cache_methods|proxy_cache_min_uses|proxy_cache_path|proxy_cache_use_stale|proxy_cache_valid|proxy_connect_timeout|proxy_cookie_domain|proxy_cookie_path|proxy_headers_hash_bucket_size|proxy_headers_hash_max_size|proxy_hide_header|proxy_http_version|proxy_ignore_client_abort|proxy_ignore_headers|proxy_intercept_errors|proxy_max_temp_file_size|proxy_method|proxy_next_upstream|proxy_no_cache|proxy_pass|proxy_pass_error_message|proxy_pass_header|proxy_pass_request_body|proxy_pass_request_headers|proxy_read_timeout|proxy_redirect|proxy_redirect_errors|proxy_send_lowat|proxy_send_timeout|proxy_set_body|proxy_set_header|proxy_ssl_session_reuse|proxy_store|proxy_store_access|proxy_temp_file_write_size|p
roxy_temp_path|proxy_timeout|proxy_upstream_fail_timeout|proxy_upstream_max_fails|random_index|read_ahead|real_ip_header|recursive_error_pages|request_pool_size|reset_timedout_connection|resolver|resolver_timeout|return|rewrite|root|rtsig_overflow_events|rtsig_overflow_test|rtsig_overflow_threshold|rtsig_signo|satisfy|satisfy_any|secure_link_secret|send_lowat|send_timeout|sendfile|sendfile_max_chunk|server|server_name|server_name_in_redirect|server_names_hash_bucket_size|server_names_hash_max_size|server_tokens|set|set_real_ip_from|smtp_auth|smtp_capabilities|so_keepalive|source_charset|split_clients|ssi|ssi_silent_errors|ssi_types|ssi_value_length|ssl|ssl_certificate|ssl_certificate_key|ssl_ciphers|ssl_client_certificate|ssl_crl|ssl_dhparam|ssl_engine|ssl_prefer_server_ciphers|ssl_protocols|ssl_session_cache|ssl_session_timeout|ssl_verify_client|ssl_verify_depth|starttls|stub_status|sub_filter|sub_filter_once|sub_filter_types|tcp_nodelay|tcp_nopush|timeout|timer_resolution|try_file
s|types|types_hash_bucket_size|types_hash_max_size|underscores_in_headers|uninitialized_variable_warn|upstream|use|user|userid|userid_domain|userid_expires|userid_name|userid_p3p|userid_path|userid_service|valid_referers|variables_hash_bucket_size|variables_hash_max_size|worker_connections|worker_cpu_affinity|worker_priority|worker_processes|worker_rlimit_core|worker_rlimit_nofile|worker_rlimit_sigpending|working_directory|xclient|xml_entities|xslt_entities|xslt_stylesheet|xslt_types|ssl_session_tickets|ssl_stapling|ssl_stapling_verify|ssl_ecdh_curve|ssl_trusted_certificate|more_set_headers|ssl_early_data)\b/i
});
Prism.languages.insertBefore('nginx', 'keyword', {
- 'variable': /\$[a-z_]+/i
+ 'variable': /\$[a-z_]+/i
});
+
Prism.languages.nim = {
- 'comment': /#.*/,
- // Double-quoted strings can be prefixed by an identifier (Generalized raw string literals)
- // Character literals are handled specifically to prevent issues with numeric type suffixes
- 'string': {
- pattern:
/(?:(?:\b(?!\d)(?:\w|\\x[8-9a-fA-F][0-9a-fA-F])+)?(?:"""[\s\S]*?"""(?!")|"(?:\\[\s\S]|""|[^"\\])*")|'(?:\\(?:\d+|x[\da-fA-F]{2}|.)|[^'])')/,
- greedy: true
- },
- // The negative look ahead prevents wrong highlighting of the .. operator
- 'number':
/\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)(?:'?[iuf]\d*)?/,
- 'keyword':
/\b(?:addr|as|asm|atomic|bind|block|break|case|cast|concept|const|continue|converter|defer|discard|distinct|do|elif|else|end|enum|except|export|finally|for|from|func|generic|if|import|include|interface|iterator|let|macro|method|mixin|nil|object|out|proc|ptr|raise|ref|return|static|template|try|tuple|type|using|var|when|while|with|without|yield)\b/,
- 'function': {
- pattern: /(?:(?!\d)(?:\w|\\x[8-9a-fA-F][0-9a-fA-F])+|`[^`\r\n]+`)\*?(?:\[[^\]]+\])?(?=\s*\()/,
- inside: {
- 'operator': /\*$/
- }
- },
- // We don't want to highlight operators inside backticks
- 'ignore': {
- pattern: /`[^`\r\n]+`/,
- inside: {
- 'punctuation': /`/
- }
- },
- 'operator': {
- // Look behind and look ahead prevent wrong highlighting of punctuations [. .] {. .} (. .)
- // but allow the slice operator .. to take precedence over them
- // One can define his own operators in Nim so all combination of operators might be an
operator.
- pattern:
/(^|[({\[](?=\.\.)|(?![({\[]\.).)(?:(?:[=+\-*\/<>@$~&%|!?^:\\]|\.\.|\.(?![)}\]]))+|\b(?:and|div|of|or|in|is|isnot|mod|not|notin|shl|shr|xor)\b)/m,
- lookbehind: true
- },
- 'punctuation': /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/
+ 'comment': /#.*/,
+ // Double-quoted strings can be prefixed by an identifier (Generalized raw string literals)
+ // Character literals are handled specifically to prevent issues with numeric type suffixes
+ 'string': {
+ pattern:
/(?:(?:\b(?!\d)(?:\w|\\x[8-9a-fA-F][0-9a-fA-F])+)?(?:"""[\s\S]*?"""(?!")|"(?:\\[\s\S]|""|[^"\\])*")|'(?:\\(?:\d+|x[\da-fA-F]{2}|.)|[^'])')/,
+ greedy: true
+ },
+ // The negative look ahead prevents wrong highlighting of the .. operator
+ 'number': /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)(?:'?[iuf]\d*)?/,
+ 'keyword':
/\b(?:addr|as|asm|atomic|bind|block|break|case|cast|concept|const|continue|converter|defer|discard|distinct|do|elif|else|end|enum|except|export|finally|for|from|func|generic|if|import|include|interface|iterator|let|macro|method|mixin|nil|object|out|proc|ptr|raise|ref|return|static|template|try|tuple|type|using|var|when|while|with|without|yield)\b/,
+ 'function': {
+ pattern: /(?:(?!\d)(?:\w|\\x[8-9a-fA-F][0-9a-fA-F])+|`[^`\r\n]+`)\*?(?:\[[^\]]+\])?(?=\s*\()/,
+ inside: {
+ 'operator': /\*$/
+ }
+ },
+ // We don't want to highlight operators inside backticks
+ 'ignore': {
+ pattern: /`[^`\r\n]+`/,
+ inside: {
+ 'punctuation': /`/
+ }
+ },
+ 'operator': {
+ // Look behind and look ahead prevent wrong highlighting of punctuations [. .] {. .} (. .)
+ // but allow the slice operator .. to take precedence over them
+ // One can define his own operators in Nim so all combination of operators might be an operator.
+ pattern:
/(^|[({\[](?=\.\.)|(?![({\[]\.).)(?:(?:[=+\-*\/<>@$~&%|!?^:\\]|\.\.|\.(?![)}\]]))+|\b(?:and|div|of|or|in|is|isnot|mod|not|notin|shl|shr|xor)\b)/m,
+ lookbehind: true
+ },
+ 'punctuation': /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/
};
Prism.languages.perl = {
- 'comment': [
- {
- // POD
- pattern: /(^\s*)=\w+[\s\S]*?=cut.*/m,
- lookbehind: true
- },
- {
- pattern: /(^|[^\\$])#.*/,
- lookbehind: true
- }
- ],
- // TODO Could be nice to handle Heredoc too.
- 'string': [
- // q/.../
- {
- pattern: /\b(?:q|qq|qx|qw)\s*([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/,
- greedy: true
- },
-
- // q a...a
- {
- pattern: /\b(?:q|qq|qx|qw)\s+([a-zA-Z0-9])(?:(?!\1)[^\\]|\\[\s\S])*\1/,
- greedy: true
- },
-
- // q(...)
- {
- pattern: /\b(?:q|qq|qx|qw)\s*\((?:[^()\\]|\\[\s\S])*\)/,
- greedy: true
- },
-
- // q{...}
- {
- pattern: /\b(?:q|qq|qx|qw)\s*\{(?:[^{}\\]|\\[\s\S])*\}/,
- greedy: true
- },
-
- // q[...]
- {
- pattern: /\b(?:q|qq|qx|qw)\s*\[(?:[^[\]\\]|\\[\s\S])*\]/,
- greedy: true
- },
-
- // q<...>
- {
- pattern: /\b(?:q|qq|qx|qw)\s*<(?:[^<>\\]|\\[\s\S])*>/,
- greedy: true
- },
-
- // "...", `...`
- {
- pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
- greedy: true
- },
-
- // '...'
- // FIXME Multi-line single-quoted strings are not supported as they would break variables
containing '
- {
- pattern: /'(?:[^'\\\r\n]|\\.)*'/,
- greedy: true
- }
- ],
- 'regex': [
- // m/.../
- {
- pattern:
/\b(?:m|qr)\s*([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1[msixpodualngc]*/,
- greedy: true
- },
-
- // m a...a
- {
- pattern: /\b(?:m|qr)\s+([a-zA-Z0-9])(?:(?!\1)[^\\]|\\[\s\S])*\1[msixpodualngc]*/,
- greedy: true
- },
-
- // m(...)
- {
- pattern: /\b(?:m|qr)\s*\((?:[^()\\]|\\[\s\S])*\)[msixpodualngc]*/,
- greedy: true
- },
-
- // m{...}
- {
- pattern: /\b(?:m|qr)\s*\{(?:[^{}\\]|\\[\s\S])*\}[msixpodualngc]*/,
- greedy: true
- },
-
- // m[...]
- {
- pattern: /\b(?:m|qr)\s*\[(?:[^[\]\\]|\\[\s\S])*\][msixpodualngc]*/,
- greedy: true
- },
-
- // m<...>
- {
- pattern: /\b(?:m|qr)\s*<(?:[^<>\\]|\\[\s\S])*>[msixpodualngc]*/,
- greedy: true
- },
-
- // The lookbehinds prevent -s from breaking
- // FIXME We don't handle change of separator like s(...)[...]
- // s/.../.../
- {
- pattern:
/(^|[^-]\b)(?:s|tr|y)\s*([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2[msixpodualngcer]*/,
- lookbehind: true,
- greedy: true
- },
-
- // s a...a...a
- {
- pattern:
/(^|[^-]\b)(?:s|tr|y)\s+([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2[msixpodualngcer]*/,
- lookbehind: true,
- greedy: true
- },
-
- // s(...)(...)
- {
- pattern:
/(^|[^-]\b)(?:s|tr|y)\s*\((?:[^()\\]|\\[\s\S])*\)\s*\((?:[^()\\]|\\[\s\S])*\)[msixpodualngcer]*/,
- lookbehind: true,
- greedy: true
- },
-
- // s{...}{...}
- {
- pattern:
/(^|[^-]\b)(?:s|tr|y)\s*\{(?:[^{}\\]|\\[\s\S])*\}\s*\{(?:[^{}\\]|\\[\s\S])*\}[msixpodualngcer]*/,
- lookbehind: true,
- greedy: true
- },
-
- // s[...][...]
- {
- pattern:
/(^|[^-]\b)(?:s|tr|y)\s*\[(?:[^[\]\\]|\\[\s\S])*\]\s*\[(?:[^[\]\\]|\\[\s\S])*\][msixpodualngcer]*/,
- lookbehind: true,
- greedy: true
- },
-
- // s<...><...>
- {
- pattern:
/(^|[^-]\b)(?:s|tr|y)\s*<(?:[^<>\\]|\\[\s\S])*>\s*<(?:[^<>\\]|\\[\s\S])*>[msixpodualngcer]*/,
- lookbehind: true,
- greedy: true
- },
-
- // /.../
- // The look-ahead tries to prevent two divisions on
- // the same line from being highlighted as regex.
- // This does not support multi-line regex.
- {
- pattern:
/\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(lt|gt|le|ge|eq|ne|cmp|not|and|or|xor|x)\b))/,
- greedy: true
- }
- ],
-
- // FIXME Not sure about the handling of ::, ', and #
- 'variable': [
- // ${^POSTMATCH}
- /[&*$@%]\{\^[A-Z]+\}/,
- // $^V
- /[&*$@%]\^[A-Z_]/,
- // ${...}
- /[&*$@%]#?(?=\{)/,
- // $foo
- /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+)+(?:::)*/i,
- // $1
- /[&*$@%]\d+/,
- // $_, @_, %!
- // The negative lookahead prevents from breaking the %= operator
- /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
- ],
- 'filehandle': {
- // <>, <FOO>, _
- pattern: /<(?![<=])\S*>|\b_\b/,
- alias: 'symbol'
- },
- 'vstring': {
- // v1.2, 1.2.3
- pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
- alias: 'string'
- },
- 'function': {
- pattern: /sub [a-z0-9_]+/i,
- inside: {
- keyword: /sub/
- }
- },
- 'keyword':
/\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
- 'number':
/\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:\d(?:_?\d)*)?\.?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
- 'operator':
/-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:lt|gt|le|ge|eq|ne|cmp|not|and|or|xor)\b/,
- 'punctuation': /[{}[\];(),:]/
+ 'comment': [
+ {
+ // POD
+ pattern: /(^\s*)=\w+[\s\S]*?=cut.*/m,
+ lookbehind: true
+ },
+ {
+ pattern: /(^|[^\\$])#.*/,
+ lookbehind: true
+ }
+ ],
+ // TODO Could be nice to handle Heredoc too.
+ 'string': [
+ // q/.../
+ {
+ pattern: /\b(?:q|qq|qx|qw)\s*([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+ greedy: true
+ },
+
+ // q a...a
+ {
+ pattern: /\b(?:q|qq|qx|qw)\s+([a-zA-Z0-9])(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+ greedy: true
+ },
+
+ // q(...)
+ {
+ pattern: /\b(?:q|qq|qx|qw)\s*\((?:[^()\\]|\\[\s\S])*\)/,
+ greedy: true
+ },
+
+ // q{...}
+ {
+ pattern: /\b(?:q|qq|qx|qw)\s*\{(?:[^{}\\]|\\[\s\S])*\}/,
+ greedy: true
+ },
+
+ // q[...]
+ {
+ pattern: /\b(?:q|qq|qx|qw)\s*\[(?:[^[\]\\]|\\[\s\S])*\]/,
+ greedy: true
+ },
+
+ // q<...>
+ {
+ pattern: /\b(?:q|qq|qx|qw)\s*<(?:[^<>\\]|\\[\s\S])*>/,
+ greedy: true
+ },
+
+ // "...", `...`
+ {
+ pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+ greedy: true
+ },
+
+ // '...'
+ // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
+ {
+ pattern: /'(?:[^'\\\r\n]|\\.)*'/,
+ greedy: true
+ }
+ ],
+ 'regex': [
+ // m/.../
+ {
+ pattern: /\b(?:m|qr)\s*([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1[msixpodualngc]*/,
+ greedy: true
+ },
+
+ // m a...a
+ {
+ pattern: /\b(?:m|qr)\s+([a-zA-Z0-9])(?:(?!\1)[^\\]|\\[\s\S])*\1[msixpodualngc]*/,
+ greedy: true
+ },
+
+ // m(...)
+ {
+ pattern: /\b(?:m|qr)\s*\((?:[^()\\]|\\[\s\S])*\)[msixpodualngc]*/,
+ greedy: true
+ },
+
+ // m{...}
+ {
+ pattern: /\b(?:m|qr)\s*\{(?:[^{}\\]|\\[\s\S])*\}[msixpodualngc]*/,
+ greedy: true
+ },
+
+ // m[...]
+ {
+ pattern: /\b(?:m|qr)\s*\[(?:[^[\]\\]|\\[\s\S])*\][msixpodualngc]*/,
+ greedy: true
+ },
+
+ // m<...>
+ {
+ pattern: /\b(?:m|qr)\s*<(?:[^<>\\]|\\[\s\S])*>[msixpodualngc]*/,
+ greedy: true
+ },
+
+ // The lookbehinds prevent -s from breaking
+ // FIXME We don't handle change of separator like s(...)[...]
+ // s/.../.../
+ {
+ pattern:
/(^|[^-]\b)(?:s|tr|y)\s*([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2[msixpodualngcer]*/,
+ lookbehind: true,
+ greedy: true
+ },
+
+ // s a...a...a
+ {
+ pattern:
/(^|[^-]\b)(?:s|tr|y)\s+([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2[msixpodualngcer]*/,
+ lookbehind: true,
+ greedy: true
+ },
+
+ // s(...)(...)
+ {
+ pattern:
/(^|[^-]\b)(?:s|tr|y)\s*\((?:[^()\\]|\\[\s\S])*\)\s*\((?:[^()\\]|\\[\s\S])*\)[msixpodualngcer]*/,
+ lookbehind: true,
+ greedy: true
+ },
+
+ // s{...}{...}
+ {
+ pattern:
/(^|[^-]\b)(?:s|tr|y)\s*\{(?:[^{}\\]|\\[\s\S])*\}\s*\{(?:[^{}\\]|\\[\s\S])*\}[msixpodualngcer]*/,
+ lookbehind: true,
+ greedy: true
+ },
+
+ // s[...][...]
+ {
+ pattern:
/(^|[^-]\b)(?:s|tr|y)\s*\[(?:[^[\]\\]|\\[\s\S])*\]\s*\[(?:[^[\]\\]|\\[\s\S])*\][msixpodualngcer]*/,
+ lookbehind: true,
+ greedy: true
+ },
+
+ // s<...><...>
+ {
+ pattern: /(^|[^-]\b)(?:s|tr|y)\s*<(?:[^<>\\]|\\[\s\S])*>\s*<(?:[^<>\\]|\\[\s\S])*>[msixpodualngcer]*/,
+ lookbehind: true,
+ greedy: true
+ },
+
+ // /.../
+ // The look-ahead tries to prevent two divisions on
+ // the same line from being highlighted as regex.
+ // This does not support multi-line regex.
+ {
+ pattern:
/\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(lt|gt|le|ge|eq|ne|cmp|not|and|or|xor|x)\b))/,
+ greedy: true
+ }
+ ],
+
+ // FIXME Not sure about the handling of ::, ', and #
+ 'variable': [
+ // ${^POSTMATCH}
+ /[&*$@%]\{\^[A-Z]+\}/,
+ // $^V
+ /[&*$@%]\^[A-Z_]/,
+ // ${...}
+ /[&*$@%]#?(?=\{)/,
+ // $foo
+ /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+)+(?:::)*/i,
+ // $1
+ /[&*$@%]\d+/,
+ // $_, @_, %!
+ // The negative lookahead prevents from breaking the %= operator
+ /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
+ ],
+ 'filehandle': {
+ // <>, <FOO>, _
+ pattern: /<(?![<=])\S*>|\b_\b/,
+ alias: 'symbol'
+ },
+ 'vstring': {
+ // v1.2, 1.2.3
+ pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
+ alias: 'string'
+ },
+ 'function': {
+ pattern: /sub [a-z0-9_]+/i,
+ inside: {
+ keyword: /sub/
+ }
+ },
+ 'keyword':
/\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
+ 'number':
/\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:\d(?:_?\d)*)?\.?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
+ 'operator':
/-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:lt|gt|le|ge|eq|ne|cmp|not|and|or|xor)\b/,
+ 'punctuation': /[{}[\];(),:]/
};
-/**
- * Original by Aaron Harun: http://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/
- * Modified by Miles Johnson: http://milesj.me
- *
- * Supports the following:
- * - Extends clike syntax
- * - Support for PHP 5.3+ (namespaces, traits, generators, etc)
- * - Smarter constant and function matching
- *
- * Adds the following new token classes:
- * constant, delimiter, variable, function, package
- */
-(function (Prism) {
- Prism.languages.php = Prism.languages.extend('clike', {
- 'keyword':
/\b(?:and|or|xor|array|as|break|case|cfunction|class|const|continue|declare|default|die|do|else|elseif|enddeclare|endfor|endforeach|endif|endswitch|endwhile|extends|for|foreach|function|include|include_once|global|if|new|return|static|switch|use|require|require_once|var|while|abstract|interface|public|implements|private|protected|parent|throw|null|echo|print|trait|namespace|final|yield|goto|instanceof|finally|try|catch)\b/i,
- 'constant': /\b[A-Z0-9_]{2,}\b/,
- 'comment': {
- pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
- lookbehind: true
- }
- });
-
- Prism.languages.insertBefore('php', 'string', {
- 'shell-comment': {
- pattern: /(^|[^\\])#.*/,
- lookbehind: true,
- alias: 'comment'
- }
- });
-
- Prism.languages.insertBefore('php', 'keyword', {
- 'delimiter': {
- pattern: /\?>|<\?(?:php|=)?/i,
- alias: 'important'
- },
- 'variable': /\$+(?:\w+\b|(?={))/i,
- 'package': {
- pattern: /(\\|namespace\s+|use\s+)[\w\\]+/,
- lookbehind: true,
- inside: {
- punctuation: /\\/
- }
- }
- });
-
- // Must be defined after the function pattern
- Prism.languages.insertBefore('php', 'operator', {
- 'property': {
- pattern: /(->)[\w]+/,
- lookbehind: true
- }
- });
-
- Prism.languages.insertBefore('php', 'string', {
- 'nowdoc-string': {
- pattern: /<<<'([^']+)'(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;/,
- greedy: true,
- alias: 'string',
- inside: {
- 'delimiter': {
- pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
- alias: 'symbol',
- inside: {
- 'punctuation': /^<<<'?|[';]$/
- }
- }
- }
- },
- 'heredoc-string': {
- pattern:
/<<<(?:"([^"]+)"(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;|([a-z_]\w*)(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\2;)/i,
- greedy: true,
- alias: 'string',
- inside: {
- 'delimiter': {
- pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
- alias: 'symbol',
- inside: {
- 'punctuation': /^<<<"?|[";]$/
- }
- },
- 'interpolation': null // See below
- }
- },
- 'single-quoted-string': {
- pattern: /'(?:\\[\s\S]|[^\\'])*'/,
- greedy: true,
- alias: 'string'
- },
- 'double-quoted-string': {
- pattern: /"(?:\\[\s\S]|[^\\"])*"/,
- greedy: true,
- alias: 'string',
- inside: {
- 'interpolation': null // See below
- }
- }
- });
- // The different types of PHP strings "replace" the C-like standard string
- delete Prism.languages.php['string'];
-
- var string_interpolation = {
- pattern: /{\$(?:{(?:{[^{}]+}|[^{}]+)}|[^{}])+}|(^|[^\\{])\$+(?:\w+(?:\[.+?]|->\w+)*)/,
- lookbehind: true,
- inside: {
- rest: Prism.languages.php
- }
- };
- Prism.languages.php['heredoc-string'].inside['interpolation'] = string_interpolation;
- Prism.languages.php['double-quoted-string'].inside['interpolation'] = string_interpolation;
-
- Prism.hooks.add('before-tokenize', function(env) {
- if (!/(?:<\?php|<\?)/ig.test(env.code)) {
- return;
- }
-
- var phpPattern = /(?:<\?php|<\?)[\s\S]*?(?:\?>|$)/ig;
- Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern);
- });
-
- Prism.hooks.add('after-tokenize', function(env) {
- Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php');
- });
-
-}(Prism));
-Prism.languages.sql= {
- 'comment': {
- pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
- lookbehind: true
- },
- 'string' : {
- pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\])*\2/,
- greedy: true,
- lookbehind: true
- },
- 'variable': /@[\w.$]+|@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
- 'function':
/\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\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(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|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|HOUR|IDENTITY(?:_INSERT|COL)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|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|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURNS?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER
)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?:
ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
- 'boolean': /\b(?:TRUE|FALSE|NULL)\b/i,
- 'number': /\b0x[\da-f]+\b|\b\d+\.?\d*|\B\.\d+\b/i,
- 'operator':
/[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|IN|LIKE|NOT|OR|IS|DIV|REGEXP|RLIKE|SOUNDS
LIKE|XOR)\b/i,
- 'punctuation': /[;[\]()`,.]/
+Prism.languages.sql = {
+ 'comment': {
+ pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+ lookbehind: true
+ },
+ 'variable': [
+ {
+ pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
+ greedy: true
+ },
+ /@[\w.$]+/
+ ],
+ 'string': {
+ pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
+ greedy: true,
+ lookbehind: true
+ },
+ 'function': /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\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(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|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|HOUR|IDENTITY(?:_INSERT|COL)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|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|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURNS?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USE
R)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?:
ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
+ 'boolean': /\b(?:TRUE|FALSE|NULL)\b/i,
+ 'number': /\b0x[\da-f]+\b|\b\d+\.?\d*|\B\.\d+\b/i,
+ 'operator':
/[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|IN|LIKE|NOT|OR|IS|DIV|REGEXP|RLIKE|SOUNDS
LIKE|XOR)\b/i,
+ 'punctuation': /[;[\]()`,.]/
};
+
Prism.languages.scss = Prism.languages.extend('css', {
- 'comment': {
- pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
- lookbehind: true
- },
- 'atrule': {
- pattern: /@[\w-]+(?:\([^()]+\)|[^(])*?(?=\s+[{;])/,
- inside: {
- 'rule': /@[\w-]+/
- // See rest below
- }
- },
- // url, compassified
- '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)
- // it can contain some characters that aren't used for defining rules or end of selector, & (parent
selector), or interpolated variable
- // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a
property (because an interpolated var
- // can "pass" as a selector- e.g: proper#{$erty})
- // 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,
- inside: {
- 'parent': {
- pattern: /&/,
- alias: 'important'
- },
- 'placeholder': /%[-\w]+/,
- 'variable': /\$[-\w]+|#\{\$[-\w]+\}/
- }
- }
+ 'comment': {
+ pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+ lookbehind: true
+ },
+ 'atrule': {
+ pattern: /@[\w-]+(?:\([^()]+\)|[^(])*?(?=\s+[{;])/,
+ inside: {
+ 'rule': /@[\w-]+/
+ // See rest below
+ }
+ },
+ // url, compassified
+ '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)
+ // it can contain some characters that aren't used for defining rules or end of selector, & (parent
selector), or interpolated variable
+ // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property
(because an interpolated var
+ // can "pass" as a selector- e.g: proper#{$erty})
+ // 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,
+ inside: {
+ 'parent': {
+ pattern: /&/,
+ alias: 'important'
+ },
+ 'placeholder': /%[-\w]+/,
+ 'variable': /\$[-\w]+|#\{\$[-\w]+\}/
+ }
+ },
+ 'property': {
+ pattern: /(?:[\w-]|\$[-\w]+|#\{\$[-\w]+\})+(?=\s*:)/,
+ inside: {
+ 'variable': /\$[-\w]+|#\{\$[-\w]+\}/
+ }
+ }
});
Prism.languages.insertBefore('scss', 'atrule', {
- 'keyword': [
- /@(?:if|else(?:
if)?|for|each|while|import|extend|debug|warn|mixin|include|function|return|content)/i,
- {
- pattern: /( +)(?:from|through)(?= )/,
- lookbehind: true
- }
- ]
+ 'keyword': [
+ /@(?:if|else(?: if)?|for|each|while|import|extend|debug|warn|mixin|include|function|return|content)/i,
+ {
+ pattern: /( +)(?:from|through)(?= )/,
+ lookbehind: true
+ }
+ ]
});
-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]+\}/
+ // var and interpolated vars
+ 'variable': /\$[-\w]+|#\{\$[-\w]+\}/
});
Prism.languages.insertBefore('scss', 'function', {
- 'placeholder': {
- pattern: /%[-\w]+/,
- alias: 'selector'
- },
- 'statement': {
- pattern: /\B!(?:default|optional)\b/i,
- alias: 'keyword'
- },
- 'boolean': /\b(?:true|false)\b/,
- 'null': /\bnull\b/,
- 'operator': {
- pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|or|not)(?=\s)/,
- lookbehind: true
- }
+ 'placeholder': {
+ pattern: /%[-\w]+/,
+ alias: 'selector'
+ },
+ 'statement': {
+ pattern: /\B!(?:default|optional)\b/i,
+ alias: 'keyword'
+ },
+ 'boolean': /\b(?:true|false)\b/,
+ 'null': {
+ pattern: /\bnull\b/,
+ alias: 'keyword'
+ },
+ 'operator': {
+ pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|or|not)(?=\s)/,
+ lookbehind: true
+ }
});
Prism.languages.scss['atrule'].inside.rest = Prism.languages.scss;
+
Prism.languages.python = {
- 'comment': {
- pattern: /(^|[^\\])#.*/,
- lookbehind: true
- },
- 'triple-quoted-string': {
- pattern: /("""|''')[\s\S]+?\1/,
- greedy: true,
- alias: 'string'
- },
- 'string': {
- pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
- greedy: true
- },
- 'function': {
- pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
- lookbehind: true
- },
- 'class-name': {
- pattern: /(\bclass\s+)\w+/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|nonlocal|pass|print|raise|return|try|while|with|yield)\b/,
-
'builtin':/\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
- 'boolean': /\b(?:True|False|None)\b/,
- 'number':
/(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
- 'operator': /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b/,
- 'punctuation': /[{}[\];(),.:]/
+ 'comment': {
+ pattern: /(^|[^\\])#.*/,
+ lookbehind: true
+ },
+ 'string-interpolation': {
+ pattern: /(?:f|rf|fr)(?:("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+ greedy: true,
+ inside: {
+ 'interpolation': {
+ // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+ pattern: /((?:^|[^{])(?:{{)*){(?!{)(?:[^{}]|{(?!{)(?:[^{}]|{(?!{)(?:[^{}])+})+})+}/,
+ lookbehind: true,
+ inside: {
+ 'format-spec': {
+ pattern: /(:)[^:(){}]+(?=}$)/,
+ lookbehind: true
+ },
+ 'conversion-option': {
+ pattern: //,
+ alias: 'punctuation'
+ },
+ rest: null
+ }
+ },
+ 'string': /[\s\S]+/
+ }
+ },
+ 'triple-quoted-string': {
+ pattern: /(?:[rub]|rb|br)?("""|''')[\s\S]+?\1/i,
+ greedy: true,
+ alias: 'string'
+ },
+ 'string': {
+ pattern: /(?:[rub]|rb|br)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+ greedy: true
+ },
+ 'function': {
+ pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+ lookbehind: true
+ },
+ 'class-name': {
+ pattern: /(\bclass\s+)\w+/i,
+ lookbehind: true
+ },
+ 'decorator': {
+ pattern: /(^\s*)@\w+(?:\.\w+)*/i,
+ lookbehind: true,
+ alias: ['annotation', 'punctuation'],
+ inside: {
+ 'punctuation': /\./
+ }
+ },
+ 'keyword':
/\b(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+ 'builtin':
/\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+ 'boolean': /\b(?:True|False|None)\b/,
+ 'number': /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
+ 'operator': /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+ 'punctuation': /[{}[\];(),.:]/
};
+Prism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python;
+
+Prism.languages.py = Prism.languages.python;
(function(Prism) {
-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{'">=]+|\{(?:\{(?:\{[^}]*\}|[^{}])*\}|[^{}])+\}))?|\{\.{3}[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\}))*\s*\/?)?>/i;
-
-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.insertBefore('inside', 'attr-name', {
- 'spread': {
- pattern: /\{\.{3}[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\}/,
- inside: {
- 'punctuation': /\.{3}|[{}.]/,
- 'attr-value': /\w+/
- }
- }
-}, 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'
- },
- rest: Prism.languages.jsx
- },
- 'alias': 'language-javascript'
- }
-}, Prism.languages.jsx.tag);
+ 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{'">=]+|\{(?:\{(?:\{[^}]*\}|[^{}])*\}|[^{}])+\}))?|\{\.{3}[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\}))*\s*\/?)?>/i;
+
+ 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.insertBefore('inside', 'attr-name', {
+ 'spread': {
+ pattern: /\{\.{3}[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\}/,
+ inside: {
+ 'punctuation': /\.{3}|[{}.]/,
+ 'attr-value': /\w+/
+ }
+ }
+ }, 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'
+ },
+ rest: Prism.languages.jsx
+ },
+ 'alias': 'language-javascript'
+ }
+ }, 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
- } else {
- // Opening tag
- openedTags.push({
- tagName: stringifyToken(token.content[0].content[1]),
- openedBraces: 0
- });
- }
- }
- } 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++;
-
- } 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--;
-
- } 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);
- }
- 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);
- }
- }
-
- 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;
- }
- walkTokens(env.tokens);
-});
+ 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
+ } else {
+ // Opening tag
+ openedTags.push({
+ tagName: stringifyToken(token.content[0].content[1]),
+ openedBraces: 0
+ });
+ }
+ }
+ } 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++;
+
+ } 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--;
+
+ } 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);
+ }
+ 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);
+ }
+ }
+
+ 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;
+ }
+ walkTokens(env.tokens);
+ });
}(Prism));
-Prism.languages.typescript = Prism.languages.extend('javascript', {
- // From JavaScript Prism keyword list and TypeScript language spec:
https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#221-reserved-words
- 'keyword':
/\b(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|var|void|while|with|yield|module|declare|constructor|namespace|abstract|require|type)\b/,
- 'builtin': /\b(?:string|Function|any|number|boolean|Array|symbol|console)\b/,
-});
-
-Prism.languages.ts = Prism.languages.typescript;
/* TODO
Add support for Markdown notation inside doc comments
Add support for nested block comments...
@@ -2289,108 +2653,111 @@ Prism.languages.ts = Prism.languages.typescript;
*/
Prism.languages.rust = {
- 'comment': [
- {
- pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
- lookbehind: true
- },
- {
- pattern: /(^|[^\\:])\/\/.*/,
- lookbehind: true
- }
- ],
- 'string': [
- {
- pattern: /b?r(#*)"(?:\\.|(?!"\1)[^\\\r\n])*"\1/,
- greedy: true
- },
- {
- pattern: /b?"(?:\\.|[^\\\r\n"])*"/,
- greedy: true
- }
- ],
- 'char': {
- pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u{(?:[\da-fA-F]_*){1,6}|.)|[^\\\r\n\t'])'/,
- alias: 'string'
- },
- 'lifetime-annotation': {
- pattern: /'[^\s>']+/,
- alias: 'symbol'
- },
- '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: /#!?\[.+?\]/,
- greedy: true,
- alias: 'attr-name'
- },
-
- 'function': [
- /\w+(?=\s*\()/,
- // Macros can use parens or brackets
- /\w+!(?=\s*\(|\[)/
- ],
- 'macro-rules': {
- pattern: /\w+!/,
- 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': /[-+*\/%!^]=?|=[=>]?|@|&[&=]?|\|[|=]?|<<?=?|>>?=?/
+ 'comment': [
+ {
+ pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+ lookbehind: true
+ },
+ {
+ pattern: /(^|[^\\:])\/\/.*/,
+ lookbehind: true
+ }
+ ],
+ 'string': [
+ {
+ pattern: /b?r(#*)"(?:\\.|(?!"\1)[^\\\r\n])*"\1/,
+ greedy: true
+ },
+ {
+ pattern: /b?"(?:\\.|[^\\\r\n"])*"/,
+ greedy: true
+ }
+ ],
+ 'char': {
+ pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u{(?:[\da-fA-F]_*){1,6}|.)|[^\\\r\n\t'])'/,
+ alias: 'string'
+ },
+ 'lifetime-annotation': {
+ pattern: /'[^\s>']+/,
+ alias: 'symbol'
+ },
+ 'keyword':
/\b(?:abstract|alignof|as|async|await|be|box|break|const|continue|crate|do|dyn|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|Self|struct|super|true|trait|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+
+ 'attribute': {
+ pattern: /#!?\[.+?\]/,
+ greedy: true,
+ alias: 'attr-name'
+ },
+
+ 'function': [
+ /\w+(?=\s*\()/,
+ // Macros can use parens or brackets
+ /\w+!(?=\s*\(|\[)/
+ ],
+ 'macro-rules': {
+ pattern: /\w+!/,
+ 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': /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+ 'operator': /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
};
+
Prism.languages.yaml = {
- 'scalar': {
- pattern: /([\-:]\s*(?:![^\s]+)?[ \t]*[|>])[ \t]*(?:((?:\r?\n|\r)[
\t]+)[^\r\n]+(?:\2[^\r\n]+)*)/,
- lookbehind: true,
- alias: 'string'
- },
- 'comment': /#.*/,
- 'key': {
- pattern: /(\s*(?:^|[:\-,[{\r\n?])[ \t]*(?:![^\s]+)?[ \t]*)[^\r\n{[\]},#\s]+?(?=\s*:\s)/,
- lookbehind: true,
- alias: 'atrule'
- },
- 'directive': {
- pattern: /(^[ \t]*)%.+/m,
- lookbehind: true,
- alias: 'important'
- },
- 'datetime': {
- pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:\d{4}-\d\d?-\d\d?(?:[tT]|[
\t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?[
\t]*(?:Z|[-+]\d\d?(?::\d{2})?)?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?)(?=[ \t]*(?:$|,|]|}))/m,
- lookbehind: true,
- alias: 'number'
- },
- 'boolean': {
- pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:true|false)[ \t]*(?=$|,|]|})/im,
- lookbehind: true,
- alias: 'important'
- },
- 'null': {
- pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:null|~)[ \t]*(?=$|,|]|})/im,
- lookbehind: true,
- alias: 'important'
- },
- 'string': {
- pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)("|')(?:(?!\2)[^\\\r\n]|\\.)*\2(?=[
\t]*(?:$|,|]|}))/m,
- lookbehind: true,
- greedy: true
- },
- 'number': {
- pattern: /([:\-,[{]\s*(?:![^\s]+)?[
\t]*)[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+\.?\d*|\.?\d+)(?:e[+-]?\d+)?|\.inf|\.nan)[ \t]*(?=$|,|]|})/im,
- lookbehind: true
- },
- 'tag': /![^\s]+/,
- 'important': /[&*][\w]+/,
- 'punctuation': /---|[:[\]{}\-,|>?]|\.\.\./
+ 'scalar': {
+ pattern: /([\-:]\s*(?:![^\s]+)?[ \t]*[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)[^\r\n]+(?:\2[^\r\n]+)*)/,
+ lookbehind: true,
+ alias: 'string'
+ },
+ 'comment': /#.*/,
+ 'key': {
+ pattern: /(\s*(?:^|[:\-,[{\r\n?])[ \t]*(?:![^\s]+)?[ \t]*)[^\r\n{[\]},#\s]+?(?=\s*:\s)/,
+ lookbehind: true,
+ alias: 'atrule'
+ },
+ 'directive': {
+ pattern: /(^[ \t]*)%.+/m,
+ lookbehind: true,
+ alias: 'important'
+ },
+ 'datetime': {
+ pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?[
\t]*(?:Z|[-+]\d\d?(?::\d{2})?)?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?)(?=[ \t]*(?:$|,|]|}))/m,
+ lookbehind: true,
+ alias: 'number'
+ },
+ 'boolean': {
+ pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:true|false)[ \t]*(?=$|,|]|})/im,
+ lookbehind: true,
+ alias: 'important'
+ },
+ 'null': {
+ pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:null|~)[ \t]*(?=$|,|]|})/im,
+ lookbehind: true,
+ alias: 'important'
+ },
+ 'string': {
+ pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)("|')(?:(?!\2)[^\\\r\n]|\\.)*\2(?=[ \t]*(?:$|,|]|}|\s*#))/m,
+ lookbehind: true,
+ greedy: true
+ },
+ 'number': {
+ pattern: /([:\-,[{]\s*(?:![^\s]+)?[
\t]*)[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+\.?\d*|\.?\d+)(?:e[+-]?\d+)?|\.inf|\.nan)[ \t]*(?=$|,|]|})/im,
+ lookbehind: true
+ },
+ 'tag': /![^\s]+/,
+ 'important': /[&*][\w]+/,
+ 'punctuation': /---|[:[\]{}\-,|>?]|\.\.\./
};
+
+Prism.languages.yml = Prism.languages.yaml;
diff --git a/lib/docs/filters/octave/clean_html.rb b/lib/docs/filters/octave/clean_html.rb
index cae7ec1c..835a9406 100644
--- a/lib/docs/filters/octave/clean_html.rb
+++ b/lib/docs/filters/octave/clean_html.rb
@@ -22,11 +22,11 @@ module Docs
css('.example').each do |node|
node.name = 'pre'
node['data-language'] = 'matlab'
- node.content = node.content
+ node.content = node.content.strip
end
- css('a[name] + dl').each do |node|
- node['id'] = node.previous['name']
+ css('a[name] + dl, a[name] + h4').each do |node|
+ node['id'] = node.previous_element['name']
end
css('dt > a[name]', 'th > a[name]').each do |node|
@@ -39,6 +39,7 @@ module Docs
node.parent.content = node.content
end
+ xpath('//td[text()=" " and not(descendant::*)]').remove
end
end
end
diff --git a/lib/docs/filters/octave/entries.rb b/lib/docs/filters/octave/entries.rb
index 70b29df1..2e5c0de6 100644
--- a/lib/docs/filters/octave/entries.rb
+++ b/lib/docs/filters/octave/entries.rb
@@ -2,17 +2,19 @@ module Docs
class Octave
class EntriesFilter < Docs::EntriesFilter
def get_name
- at_css('h1').content
+ at_css('h1').content.sub(/(A?[0-9.]+ )/, '')
end
def get_type
+ return 'Manual: Appendices' if name.start_with?('Appendix')
+ return 'Manual: Indexes' if name.end_with?('Index')
'Manual'
end
def additional_entries
css('dl:not([compact]) > dt').each_with_object [] do |node, entries|
- name = node.content.gsub(/[A-z0-9\,… ]*\=/,'').strip
- entries << [name, node['id'], 'Functions']
+ name = node.content.gsub(/[A-z0-9\,… ]*\=/, '').strip.split(' ')[0]
+ entries << [name, node['id'], 'Functions'] unless node['id'] =~ /-\d+\Z/
end
end
end
diff --git a/lib/docs/scrapers/octave.rb b/lib/docs/scrapers/octave.rb
index 1b8e70c0..e6e6592c 100644
--- a/lib/docs/scrapers/octave.rb
+++ b/lib/docs/scrapers/octave.rb
@@ -27,7 +27,7 @@ module Docs
© 1996–2018 John W. Eaton<br>
Permission is granted to make and distribute verbatim copies of this manual provided the copyright
notice and this permission notice are preserved on all copies.<br/>
Permission is granted to copy and distribute modified versions of this manual under the conditions for
verbatim copying, provided that the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.</br>
-Permission is granted to copy and distribute translations of this manual into another language, under the
above conditions for modified versions.</br>
+Permission is granted to copy and distribute translations of this manual into another language, under the
above conditions for modified versions.
HTML
def get_latest_version(opts)
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
