/* PrismJS 1.29.0 https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+bash+c+cpp+cmake+coffeescript+crystal+d+dart+diff+django+elixir+erlang+go+groovy+java+json+julia+kotlin+latex+lua+markdown+markup-templating+matlab+nginx+nim+nix+ocaml+perl+php+python+qml+r+jsx+ruby+rust+scss+scala+shell-session+sql+typescript+yaml+zig */ /// <reference lib="WebWorker"/> var _self = (typeof window !== 'undefined') ? window // if in browser : ( (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) ? self // if in worker : {} // if in node js ); /** * Prism: Lightweight, robust, elegant syntax highlighting * * @license MIT <https://opensource.org/licenses/MIT> * @author Lea Verou <https://lea.verou.me> * @namespace * @public */ var Prism = (function (_self) { // Private helper vars var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i; var uniqueId = 0; // The grammar object for plaintext var plainTextGrammar = {}; var _ = { /** * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load * additional languages or plugins yourself. * * By setting this value to `true`, Prism will not automatically highlight all code elements on the page. * * You obviously have to change this value before the automatic highlighting started. To do this, you can add an * empty Prism object into the global scope before loading the Prism script like this: * * ```js * window.Prism = window.Prism || {}; * Prism.manual = true; * // add a new <script> to load Prism's script * ``` * * @default false * @type {boolean} * @memberof Prism * @public */ manual: _self.Prism && _self.Prism.manual, /** * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your * own worker, you don't want it to do this. * * By setting this value to `true`, Prism will not add its own listeners to the worker. * * You obviously have to change this value before Prism executes. To do this, you can add an * empty Prism object into the global scope before loading the Prism script like this: * * ```js * window.Prism = window.Prism || {}; * Prism.disableWorkerMessageHandler = true; * // Load Prism's script * ``` * * @default false * @type {boolean} * @memberof Prism * @public */ disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler, /** * A namespace for utility methods. * * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may * change or disappear at any time. * * @namespace * @memberof Prism */ util: { encode: function encode(tokens) { if (tokens instanceof Token) { return new Token(tokens.type, encode(tokens.content), tokens.alias); } else if (Array.isArray(tokens)) { return tokens.map(encode); } else { return tokens.replace(/&/g, '&').replace(/</g, '<').replace(/\u00a0/g, ' '); } }, /** * Returns the name of the type of the given value. * * @param {any} o * @returns {string} * @example * type(null) === 'Null' * type(undefined) === 'Undefined' * type(123) === 'Number' * type('foo') === 'String' * type(true) === 'Boolean' * type([1, 2]) === 'Array' * type({}) === 'Object' * type(String) === 'Function' * type(/abc+/) === 'RegExp' */ type: function (o) { return Object.prototype.toString.call(o).slice(8, -1); }, /** * Returns a unique number for the given object. Later calls will still return the same number. * * @param {Object} obj * @returns {number} */ objId: function (obj) { if (!obj['__id']) { Object.defineProperty(obj, '__id', { value: ++uniqueId }); } return obj['__id']; }, /** * Creates a deep clone of the given object. * * The main intended use of this function is to clone language definitions. * * @param {T} o * @param {Record<number, any>} [visited] * @returns {T} * @template T */ clone: function deepClone(o, visited) { visited = visited || {}; var clone; var id; switch (_.util.type(o)) { case 'Object': id = _.util.objId(o); if (visited[id]) { return visited[id]; } clone = /** @type {Record<string, any>} */ ({}); visited[id] = clone; for (var key in o) { if (o.hasOwnProperty(key)) { clone[key] = deepClone(o[key], visited); } } return /** @type {any} */ (clone); case 'Array': id = _.util.objId(o); if (visited[id]) { return visited[id]; } clone = []; visited[id] = clone; (/** @type {Array} */(/** @type {any} */(o))).forEach(function (v, i) { clone[i] = deepClone(v, visited); }); return /** @type {any} */ (clone); default: return o; } }, /** * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class. * * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned. * * @param {Element} element * @returns {string} */ getLanguage: function (element) { while (element) { var m = lang.exec(element.className); if (m) { return m[1].toLowerCase(); } element = element.parentElement; } return 'none'; }, /** * Sets the Prism `language-xxxx` class of the given element. * * @param {Element} element * @param {string} language * @returns {void} */ setLanguage: function (element, language) { // remove all `language-xxxx` classes // (this might leave behind a leading space) element.className = element.className.replace(RegExp(lang, 'gi'), ''); // add the new `language-xxxx` class // (using `classList` will automatically clean up spaces for us) element.classList.add('language-' + language); }, /** * Returns the script element that is currently executing. * * This does __not__ work for line script element. * * @returns {HTMLScriptElement | null} */ currentScript: function () { if (typeof document === 'undefined') { return null; } if ('currentScript' in document && 1 < 2 /* hack to trip TS' flow analysis */) { return /** @type {any} */ (document.currentScript); } // IE11 workaround // we'll get the src of the current script by parsing IE11's error stack trace // this will not work for inline scripts try { throw new Error(); } catch (err) { // Get file src url from stack. Specifically works with the format of stack traces in IE. // A stack will look like this: // // Error // at _.util.currentScript (http://localhost/components/prism-core.js:119:5) // at Global code (http://localhost/components/prism-core.js:606:1) var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) || [])[1]; if (src) { var scripts = document.getElementsByTagName('script'); for (var i in scripts) { if (scripts[i].src == src) { return scripts[i]; } } } return null; } }, /** * Returns whether a given class is active for `element`. * * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the * given class is just the given class with a `no-` prefix. * * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its * ancestors have the given class or the negated version of it, then the default activation will be returned. * * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated * version of it, the class is considered active. * * @param {Element} element * @param {string} className * @param {boolean} [defaultActivation=false] * @returns {boolean} */ isActive: function (element, className, defaultActivation) { var no = 'no-' + className; while (element) { var classList = element.classList; if (classList.contains(className)) { return true; } if (classList.contains(no)) { return false; } element = element.parentElement; } return !!defaultActivation; } }, /** * This namespace contains all currently loaded languages and the some helper functions to create and modify languages. * * @namespace * @memberof Prism * @public */ languages: { /** * The grammar for plain, unformatted text. */ plain: plainTextGrammar, plaintext: plainTextGrammar, text: plainTextGrammar, txt: plainTextGrammar, /** * Creates a deep copy of the language with the given id and appends the given tokens. * * If a token in `redef` also appears in the copied language, then the existing token in the copied language * will be overwritten at its original position. * * ## Best practices * * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language) * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to * understand the language definition because, normally, the order of tokens matters in Prism grammars. * * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens. * Furthermore, all non-overwriting tokens should be placed after the overwriting ones. * * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`. * @param {Grammar} redef The new tokens to append. * @returns {Grammar} The new language created. * @public * @example * Prism.languages['css-with-colors'] = Prism.languages.extend('css', { * // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token * // at its original position * 'comment': { ... }, * // CSS doesn't have a 'color' token, so this token will be appended * 'color': /\b(?:red|green|blue)\b/ * }); */ extend: function (id, redef) { var lang = _.util.clone(_.languages[id]); for (var key in redef) { lang[key] = redef[key]; } return lang; }, /** * Inserts tokens _before_ another token in a language definition or any other grammar. * * ## Usage * * This helper method makes it easy to modify existing languages. For example, the CSS language definition * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do * this: * * ```js * Prism.languages.markup.style = { * // token * }; * ``` * * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens * before existing tokens. For the CSS example above, you would use it like this: * * ```js * Prism.languages.insertBefore('markup', 'cdata', { * 'style': { * // token * } * }); * ``` * * ## Special cases * * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar * will be ignored. * * This behavior can be used to insert tokens after `before`: * * ```js * Prism.languages.insertBefore('markup', 'comment', { * 'comment': Prism.languages.markup.comment, * // tokens after 'comment' * }); * ``` * * ## Limitations * * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily * deleting properties which is necessary to insert at arbitrary positions. * * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object. * Instead, it will create a new object and replace all references to the target object with the new one. This * can be done without temporarily deleting properties, so the iteration order is well-defined. * * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if * you hold the target object in a variable, then the value of the variable will not change. * * ```js * var oldMarkup = Prism.languages.markup; * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... }); * * assert(oldMarkup !== Prism.languages.markup); * assert(newMarkup === Prism.languages.markup); * ``` * * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the * object to be modified. * @param {string} before The key to insert before. * @param {Grammar} insert An object containing the key-value pairs to be inserted. * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the * object to be modified. * * Defaults to `Prism.languages`. * @returns {Grammar} The new grammar object. * @public */ insertBefore: function (inside, before, insert, root) { root = root || /** @type {any} */ (_.languages); var grammar = root[inside]; /** @type {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]; } } } // 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]; var 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: {}, /** * This is the most high-level function in Prism’s API. * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on * each one of them. * * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`. * * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}. * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}. * @memberof Prism * @public */ highlightAll: function (async, callback) { _.highlightAllUnder(document, async, callback); }, /** * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls * {@link Prism.highlightElement} on each one of them. * * The following hooks will be run: * 1. `before-highlightall` * 2. `before-all-elements-highlight` * 3. All hooks of {@link Prism.highlightElement} for each element. * * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted. * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers. * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done. * @memberof Prism * @public */ highlightAllUnder: function (container, async, callback) { var env = { callback: callback, container: container, selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code' }; _.hooks.run('before-highlightall', env); env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector)); _.hooks.run('before-all-elements-highlight', env); for (var i = 0, element; (element = env.elements[i++]);) { _.highlightElement(element, async === true, env.callback); } }, /** * Highlights the code inside a single element. * * The following hooks will be run: * 1. `before-sanity-check` * 2. `before-highlight` * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`. * 4. `before-insert` * 5. `after-highlight` * 6. `complete` * * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for * the element's language. * * @param {Element} element The element containing the code. * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier. * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default). * * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for * asynchronous highlighting to work. You can build your own bundle on the * [Download page](https://prismjs.com/download.html). * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done. * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously. * @memberof Prism * @public */ highlightElement: function (element, async, callback) { // Find language var language = _.util.getLanguage(element); var grammar = _.languages[language]; // Set language on the element, if not present _.util.setLanguage(element, language); // Set language on the parent, for styling var parent = element.parentElement; if (parent && parent.nodeName.toLowerCase() === 'pre') { _.util.setLanguage(parent, language); } var code = element.textContent; var env = { element: element, language: language, grammar: grammar, code: code }; function insertHighlightedCode(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); // plugins may change/add the parent/element parent = env.element.parentElement; if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) { parent.setAttribute('tabindex', '0'); } if (!env.code) { _.hooks.run('complete', env); callback && callback.call(env.element); 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)); } }, /** * Low-level function, only use if you know what you’re doing. It accepts a string of text as input * and the language definitions to use, and returns a string with the HTML produced. * * The following hooks will be run: * 1. `before-tokenize` * 2. `after-tokenize` * 3. `wrap`: On each {@link Token}. * * @param {string} text A string with the code to be highlighted. * @param {Grammar} grammar An object containing the tokens to use. * * Usually a language definition like `Prism.languages.markup`. * @param {string} language The name of the language definition passed to `grammar`. * @returns {string} The highlighted HTML. * @memberof Prism * @public * @example * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript'); */ highlight: function (text, grammar, language) { var env = { code: text, grammar: grammar, language: language }; _.hooks.run('before-tokenize', env); if (!env.grammar) { throw new Error('The language "' + env.language + '" has no grammar.'); } env.tokens = _.tokenize(env.code, env.grammar); _.hooks.run('after-tokenize', env); return Token.stringify(_.util.encode(env.tokens), env.language); }, /** * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input * and the language definitions to use, and returns an array with the tokenized code. * * When the language definition includes nested tokens, the function is called recursively on each of these tokens. * * This method could be useful in other contexts as well, as a very crude parser. * * @param {string} text A string with the code to be highlighted. * @param {Grammar} grammar An object containing the tokens to use. * * Usually a language definition like `Prism.languages.markup`. * @returns {TokenStream} An array of strings and tokens, a token stream. * @memberof Prism * @public * @example * let code = `var foo = 0;`; * let tokens = Prism.tokenize(code, Prism.languages.javascript); * tokens.forEach(token => { * if (token instanceof Prism.Token && token.type === 'number') { * console.log(`Found numeric literal: ${token.content}`); * } * }); */ tokenize: function (text, grammar) { var rest = grammar.rest; if (rest) { for (var token in rest) { grammar[token] = rest[token]; } delete grammar.rest; } var tokenList = new LinkedList(); addAfter(tokenList, tokenList.head, text); matchGrammar(text, tokenList, grammar, tokenList.head, 0); return toArray(tokenList); }, /** * @namespace * @memberof Prism * @public */ hooks: { all: {}, /** * Adds the given callback to the list of callbacks for the given hook. * * The callback will be invoked when the hook it is registered for is run. * Hooks are usually directly run by a highlight function but you can also run hooks yourself. * * One callback function can be registered to multiple hooks and the same hook multiple times. * * @param {string} name The name of the hook. * @param {HookCallback} callback The callback function which is given environment variables. * @public */ add: function (name, callback) { var hooks = _.hooks.all; hooks[name] = hooks[name] || []; hooks[name].push(callback); }, /** * Runs a hook invoking all registered callbacks with the given environment variables. * * Callbacks will be invoked synchronously and in the order in which they were registered. * * @param {string} name The name of the hook. * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered. * @public */ run: function (name, env) { var callbacks = _.hooks.all[name]; if (!callbacks || !callbacks.length) { return; } for (var i = 0, callback; (callback = callbacks[i++]);) { callback(env); } } }, Token: Token }; _self.Prism = _; // Typescript note: // The following can be used to import the Token type in JSDoc: // // @typedef {InstanceType<import("./prism-core")["Token"]>} Token /** * Creates a new token. * * @param {string} type See {@link Token#type type} * @param {string | TokenStream} content See {@link Token#content content} * @param {string|string[]} [alias] The alias(es) of the token. * @param {string} [matchedStr=""] A copy of the full string this token was created from. * @class * @global * @public */ function Token(type, content, alias, matchedStr) { /** * The type of the token. * * This is usually the key of a pattern in a {@link Grammar}. * * @type {string} * @see GrammarToken * @public */ this.type = type; /** * The strings or tokens contained by this token. * * This will be a token stream if the pattern matched also defined an `inside` grammar. * * @type {string | TokenStream} * @public */ this.content = content; /** * The alias(es) of the token. * * @type {string|string[]} * @see GrammarToken * @public */ this.alias = alias; // Copy of the full string this token was created from this.length = (matchedStr || '').length | 0; } /** * A token stream is an array of strings and {@link Token Token} objects. * * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process * them. * * 1. No adjacent strings. * 2. No empty strings. * * The only exception here is the token stream that only contains the empty string and nothing else. * * @typedef {Array<string | Token>} TokenStream * @global * @public */ /** * Converts the given token or token stream to an HTML representation. * * The following hooks will be run: * 1. `wrap`: On each {@link Token}. * * @param {string | Token | TokenStream} o The token or token stream to be converted. * @param {string} language The name of current language. * @returns {string} The HTML representation of the token or token stream. * @memberof Token * @static */ Token.stringify = function stringify(o, language) { if (typeof o == 'string') { return o; } if (Array.isArray(o)) { var s = ''; o.forEach(function (e) { s += stringify(e, language); }); return s; } var env = { type: o.type, content: stringify(o.content, language), tag: 'span', classes: ['token', o.type], attributes: {}, language: language }; var aliases = o.alias; if (aliases) { if (Array.isArray(aliases)) { Array.prototype.push.apply(env.classes, aliases); } else { env.classes.push(aliases); } } _.hooks.run('wrap', env); var attributes = ''; for (var name in env.attributes) { attributes += ' ' + name + '="' + (env.attributes[name] || '').replace(/"/g, '"') + '"'; } return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + attributes + '>' + env.content + '</' + env.tag + '>'; }; /** * @param {RegExp} pattern * @param {number} pos * @param {string} text * @param {boolean} lookbehind * @returns {RegExpExecArray | null} */ function matchPattern(pattern, pos, text, lookbehind) { pattern.lastIndex = pos; var match = pattern.exec(text); if (match && lookbehind && match[1]) { // change the match to remove the text matched by the Prism lookbehind group var lookbehindLength = match[1].length; match.index += lookbehindLength; match[0] = match[0].slice(lookbehindLength); } return match; } /** * @param {string} text * @param {LinkedList<string | Token>} tokenList * @param {any} grammar * @param {LinkedListNode<string | Token>} startNode * @param {number} startPos * @param {RematchOptions} [rematch] * @returns {void} * @private * * @typedef RematchOptions * @property {string} cause * @property {number} reach */ function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) { for (var token in grammar) { if (!grammar.hasOwnProperty(token) || !grammar[token]) { continue; } var patterns = grammar[token]; patterns = Array.isArray(patterns) ? patterns : [patterns]; for (var j = 0; j < patterns.length; ++j) { if (rematch && rematch.cause == token + ',' + j) { return; } var patternObj = patterns[j]; var inside = patternObj.inside; var lookbehind = !!patternObj.lookbehind; var greedy = !!patternObj.greedy; var alias = patternObj.alias; if (greedy && !patternObj.pattern.global) { // Without the global flag, lastIndex won't work var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0]; patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g'); } /** @type {RegExp} */ var pattern = patternObj.pattern || patternObj; for ( // iterate the token list and keep track of the current token/string position var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next ) { if (rematch && pos >= rematch.reach) { break; } var str = currentNode.value; if (tokenList.length > text.length) { // Something went terribly wrong, ABORT, ABORT! return; } if (str instanceof Token) { continue; } var removeCount = 1; // this is the to parameter of removeBetween var match; if (greedy) { match = matchPattern(pattern, pos, text, lookbehind); if (!match || match.index >= text.length) { break; } var from = match.index; var to = match.index + match[0].length; var p = pos; // find the node that contains the match p += currentNode.value.length; while (from >= p) { currentNode = currentNode.next; p += currentNode.value.length; } // adjust pos (and p) p -= currentNode.value.length; pos = p; // the current node is a Token, then the match starts inside another Token, which is invalid if (currentNode.value instanceof Token) { continue; } // find the last node which is affected by this match for ( var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string'); k = k.next ) { removeCount++; p += k.value.length; } removeCount--; // replace with the new match str = text.slice(pos, p); match.index -= pos; } else { match = matchPattern(pattern, 0, str, lookbehind); if (!match) { continue; } } // eslint-disable-next-line no-redeclare var from = match.index; var matchStr = match[0]; var before = str.slice(0, from); var after = str.slice(from + matchStr.length); var reach = pos + str.length; if (rematch && reach > rematch.reach) { rematch.reach = reach; } var removeFrom = currentNode.prev; if (before) { removeFrom = addAfter(tokenList, removeFrom, before); pos += before.length; } removeRange(tokenList, removeFrom, removeCount); var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr); currentNode = addAfter(tokenList, removeFrom, wrapped); if (after) { addAfter(tokenList, currentNode, after); } if (removeCount > 1) { // at least one Token object was removed, so we have to do some rematching // this can only happen if the current pattern is greedy /** @type {RematchOptions} */ var nestedRematch = { cause: token + ',' + j, reach: reach }; matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch); // the reach might have been extended because of the rematching if (rematch && nestedRematch.reach > rematch.reach) { rematch.reach = nestedRematch.reach; } } } } } } /** * @typedef LinkedListNode * @property {T} value * @property {LinkedListNode<T> | null} prev The previous node. * @property {LinkedListNode<T> | null} next The next node. * @template T * @private */ /** * @template T * @private */ function LinkedList() { /** @type {LinkedListNode<T>} */ var head = { value: null, prev: null, next: null }; /** @type {LinkedListNode<T>} */ var tail = { value: null, prev: head, next: null }; head.next = tail; /** @type {LinkedListNode<T>} */ this.head = head; /** @type {LinkedListNode<T>} */ this.tail = tail; this.length = 0; } /** * Adds a new node with the given value to the list. * * @param {LinkedList<T>} list * @param {LinkedListNode<T>} node * @param {T} value * @returns {LinkedListNode<T>} The added node. * @template T */ function addAfter(list, node, value) { // assumes that node != list.tail && values.length >= 0 var next = node.next; var newNode = { value: value, prev: node, next: next }; node.next = newNode; next.prev = newNode; list.length++; return newNode; } /** * Removes `count` nodes after the given node. The given node will not be removed. * * @param {LinkedList<T>} list * @param {LinkedListNode<T>} node * @param {number} count * @template T */ function removeRange(list, node, count) { var next = node.next; for (var i = 0; i < count && next !== list.tail; i++) { next = next.next; } node.next = next; next.prev = node; list.length -= i; } /** * @param {LinkedList<T>} list * @returns {T[]} * @template T */ function toArray(list) { var array = []; var node = list.head.next; while (node !== list.tail) { array.push(node.value); node = node.next; } return array; } 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); var lang = message.language; var code = message.code; var immediateClose = message.immediateClose; _self.postMessage(_.highlight(code, _.languages[lang], lang)); if (immediateClose) { _self.close(); } }, false); } return _; } // Get current script and highlight var script = _.util.currentScript(); if (script) { _.filename = script.src; if (script.hasAttribute('data-manual')) { _.manual = true; } } function highlightAutomaticallyCallback() { if (!_.manual) { _.highlightAll(); } } if (!_.manual) { // If the document state is "loading", then we'll use DOMContentLoaded. // If the document state is "interactive" and the prism.js script is deferred, then we'll also use the // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they // might take longer one animation frame to execute which can create a race condition where only some plugins have // been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded. // See https://github.com/PrismJS/prism/issues/2102 var readyState = document.readyState; if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) { document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback); } else { if (window.requestAnimationFrame) { window.requestAnimationFrame(highlightAutomaticallyCallback); } else { window.setTimeout(highlightAutomaticallyCallback, 16); } } } return _; }(_self)); if (typeof module !== 'undefined' && module.exports) { module.exports = Prism; } // hack for components to work correctly in node.js if (typeof global !== 'undefined') { global.Prism = Prism; } // some additional documentation/types /** * The expansion of a simple `RegExp` literal to support additional properties. * * @typedef GrammarToken * @property {RegExp} pattern The regular expression of the token. * @property {boolean} [lookbehind=false] If `true`, then the first capturing group of `pattern` will (effectively) * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token. * @property {boolean} [greedy=false] Whether the token is greedy. * @property {string|string[]} [alias] An optional alias or list of aliases. * @property {Grammar} [inside] The nested grammar of this token. * * The `inside` grammar will be used to tokenize the text value of each token of this kind. * * This can be used to make nested and even recursive language definitions. * * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into * each another. * @global * @public */ /** * @typedef Grammar * @type {Object<string, RegExp | GrammarToken | Array<RegExp | GrammarToken>>} * @property {Grammar} [rest] An optional grammar object that will be appended to this grammar. * @global * @public */ /** * A function which will invoked after an element was successfully highlighted. * * @callback HighlightCallback * @param {Element} element The element successfully highlighted. * @returns {void} * @global * @public */ /** * @callback HookCallback * @param {Object<string, any>} env The environment variables of the hook. * @returns {void} * @global * @public */ ; Prism.languages.markup = { 'comment': { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy: true }, 'prolog': { pattern: /<\?[\s\S]+?\?>/, greedy: true }, 'doctype': { // https://www.w3.org/TR/xml/#NT-doctypedecl pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i, greedy: true, inside: { 'internal-subset': { pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/, lookbehind: true, greedy: true, inside: null // see below }, 'string': { pattern: /"[^"]*"|'[^']*'/, greedy: true }, 'punctuation': /^<!|>$|[[\]]/, 'doctype-tag': /^DOCTYPE/i, 'name': /[^\s<>'"]+/ } }, 'cdata': { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, greedy: true }, 'tag': { pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/, greedy: true, inside: { 'tag': { pattern: /^<\/?[^\s>\/]+/, inside: { 'punctuation': /^<\/?/, 'namespace': /^[^\s>\/:]+:/ } }, 'special-attr': [], 'attr-value': { pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/, inside: { 'punctuation': [ { pattern: /^=/, alias: 'attr-equals' }, { pattern: /^(\s*)["']|["']$/, lookbehind: true } ] } }, 'punctuation': /\/?>/, 'attr-name': { pattern: /[^\s>\/]+/, inside: { 'namespace': /^[^\s>\/:]+:/ } } } }, 'entity': [ { pattern: /&[\da-z]{1,8};/i, alias: 'named-entity' }, /&#x?[\da-f]{1,8};/i ] }; Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity']; Prism.languages.markup['doctype'].inside['internal-subset'].inside = Prism.languages.markup; // 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(/&/, '&'); } }); 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(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () { return tagName; }), 'i'), lookbehind: true, greedy: true, inside: inside }; Prism.languages.insertBefore('markup', 'cdata', def); } }); Object.defineProperty(Prism.languages.markup.tag, 'addAttribute', { /** * Adds an pattern to highlight languages embedded in HTML attributes. * * An example of an inlined language is CSS with `style` attributes. * * @param {string} attrName 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 * addAttribute('style', 'css'); */ value: function (attrName, lang) { Prism.languages.markup.tag.inside['special-attr'].push({ pattern: RegExp( /(^|["'\s])/.source + '(?:' + attrName + ')' + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, 'i' ), lookbehind: true, inside: { 'attr-name': /^[^\s=]+/, 'attr-value': { pattern: /=[\s\S]+/, inside: { 'value': { pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/, lookbehind: true, alias: [lang, 'language-' + lang], inside: Prism.languages[lang] }, 'punctuation': [ { pattern: /^=/, alias: 'attr-equals' }, /"|'/ ] } } } }); } }); Prism.languages.html = Prism.languages.markup; Prism.languages.mathml = Prism.languages.markup; Prism.languages.svg = Prism.languages.markup; Prism.languages.xml = Prism.languages.extend('markup', {}); Prism.languages.ssml = Prism.languages.xml; Prism.languages.atom = Prism.languages.xml; Prism.languages.rss = Prism.languages.xml; (function (Prism) { var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/; Prism.languages.css = { 'comment': /\/\*[\s\S]*?\*\//, 'atrule': { pattern: RegExp('@[\\w-](?:' + /[^;{\s"']|\s+(?!\s)/.source + '|' + string.source + ')*?' + /(?:;|(?=\s*\{))/.source), inside: { 'rule': /^@[\w-]+/, 'selector-function-argument': { pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/, lookbehind: true, alias: 'selector' }, 'keyword': { pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/, lookbehind: true } // See rest below } }, 'url': { // https://drafts.csswg.org/css-values-3/#urls pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'), greedy: true, inside: { 'function': /^url/i, 'punctuation': /^\(|\)$/, 'string': { pattern: RegExp('^' + string.source + '$'), alias: 'url' } } }, 'selector': { pattern: RegExp('(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'), lookbehind: true }, 'string': { pattern: string, greedy: true }, 'property': { pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i, lookbehind: true }, 'important': /!important\b/i, 'function': { pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i, lookbehind: true }, 'punctuation': /[(){};:,]/ }; Prism.languages.css['atrule'].inside.rest = Prism.languages.css; var markup = Prism.languages.markup; if (markup) { markup.tag.addInlined('style', 'css'); markup.tag.addAttribute('style', 'css'); } }(Prism)); Prism.languages.clike = { 'comment': [ { pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, lookbehind: true, greedy: true }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: true, greedy: true } ], 'string': { pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, greedy: true }, 'class-name': { pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i, lookbehind: true, inside: { 'punctuation': /[.\\]/ } }, 'keyword': /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/, 'boolean': /\b(?:false|true)\b/, 'function': /\b\w+(?=\()/, 'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, 'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/, 'punctuation': /[{}[\];(),.:]/ }; Prism.languages.javascript = Prism.languages.extend('clike', { 'class-name': [ Prism.languages.clike['class-name'], { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/, lookbehind: true } ], 'keyword': [ { pattern: /((?:^|\})\s*)catch\b/, lookbehind: true }, { pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/, lookbehind: true }, ], // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444) 'function': /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/, 'number': { pattern: RegExp( /(^|[^\w$])/.source + '(?:' + ( // constant /NaN|Infinity/.source + '|' + // binary integer /0[bB][01]+(?:_[01]+)*n?/.source + '|' + // octal integer /0[oO][0-7]+(?:_[0-7]+)*n?/.source + '|' + // hexadecimal integer /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + '|' + // decimal bigint /\d+(?:_\d+)*n/.source + '|' + // decimal number (integer or float) but no bigint /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source ) + ')' + /(?![\w$])/.source ), lookbehind: true }, 'operator': /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/ }); Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/; Prism.languages.insertBefore('javascript', 'keyword', { 'regex': { pattern: RegExp( // lookbehind // eslint-disable-next-line regexp/no-dupe-characters-character-class /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern: // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible // with the only syntax, so we have to define 2 different regex patterns. /\//.source + '(?:' + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + '|' + // `v` flag syntax. This supports 3 levels of nested character classes. /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ')' + // lookahead /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source ), lookbehind: true, greedy: true, inside: { 'regex-source': { pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/, lookbehind: true, alias: 'language-regex', inside: Prism.languages.regex }, 'regex-delimiter': /^\/|\/$/, 'regex-flags': /^[a-z]+$/, } }, // This must be declared before keyword because we use "function" inside the look-forward 'function-variable': { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/, alias: 'function' }, 'parameter': [ { pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/, lookbehind: true, inside: Prism.languages.javascript }, { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, lookbehind: true, inside: Prism.languages.javascript }, { pattern: /(\(\s*)(?!\s)(?:[^()\s]|\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]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/, lookbehind: true, inside: Prism.languages.javascript } ], 'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/ }); Prism.languages.insertBefore('javascript', 'string', { 'hashbang': { pattern: /^#!.*/, greedy: true, alias: 'comment' }, '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]+/ } }, 'string-property': { pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m, lookbehind: true, greedy: true, alias: 'property' } }); Prism.languages.insertBefore('javascript', 'operator', { 'literal-property': { pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, lookbehind: true, alias: 'property' }, }); if (Prism.languages.markup) { Prism.languages.markup.tag.addInlined('script', 'javascript'); // add attribute support for all DOM events. // https://developer.mozilla.org/en-US/docs/Web/Events#Standard_events Prism.languages.markup.tag.addAttribute( /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, 'javascript' ); } Prism.languages.js = Prism.languages.javascript; (function (Prism) { // $ 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 commandAfterHeredoc = { pattern: /(^(["']?)\w+\2)[ \t]+\S.*/, lookbehind: true, alias: 'punctuation', // this looks reasonably well in all themes inside: null // see below }; var insideString = { 'bash': commandAfterHeredoc, '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}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/ }; 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+(?:\.\w+)*(?=\+?=)/, inside: { 'environment': { pattern: RegExp('(^|[\\s;|&]|[<>]\\()' + envVars), lookbehind: true, alias: 'constant' } }, alias: 'variable', lookbehind: true }, // Highlight parameter names as variables 'parameter': { pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/, alias: 'variable', lookbehind: true }, 'string': [ // Support for Here-documents https://en.wikipedia.org/wiki/Here_document { pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\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[\s\S]*?(?:\r?\n|\r)\3/, lookbehind: true, greedy: true, inside: { 'bash': commandAfterHeredoc } }, // “Normal” string { // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/, lookbehind: true, greedy: true, inside: insideString }, { // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html pattern: /(^|[^$\\])'[^']*'/, lookbehind: true, greedy: true }, { // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html pattern: /\$'(?:[^'\\]|\\[\s\S])*'/, greedy: true, inside: { 'entity': insideString.entity } } ], 'environment': { pattern: RegExp('\\$?' + envVars), alias: 'constant' }, 'variable': insideString.variable, 'function': { pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|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|java|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|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|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|sysctl|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|vcpkg|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;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/, lookbehind: true }, // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html 'builtin': { pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/, lookbehind: true, // Alias added to make those easier to distinguish from strings. alias: 'class-name' }, 'boolean': { pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\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 } }; commandAfterHeredoc.inside = Prism.languages.bash; /* Patterns in command substitution. */ var toBeCopied = [ 'comment', 'function-name', 'for-or-select', 'assign-left', 'parameter', '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.sh = Prism.languages.bash; Prism.languages.shell = Prism.languages.bash; }(Prism)); Prism.languages.c = Prism.languages.extend('clike', { 'comment': { pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: true }, 'string': { // https://en.cppreference.com/w/c/language/string_literal pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: true }, 'class-name': { pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/, lookbehind: true }, 'keyword': /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/, 'function': /\b[a-z_]\w*(?=\s*\()/i, 'number': /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i, 'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/ }); Prism.languages.insertBefore('c', 'string', { 'char': { // https://en.cppreference.com/w/c/language/character_constant pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/, greedy: true } }); Prism.languages.insertBefore('c', 'string', { 'macro': { // allow for multiline macro definitions // spaces after the # character compile fine with gcc pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im, lookbehind: true, greedy: true, alias: 'property', inside: { 'string': [ { // highlight the path of the include statement as a string pattern: /^(#\s*include\s*)<[^>]+>/, lookbehind: true }, Prism.languages.c['string'] ], 'char': Prism.languages.c['char'], 'comment': Prism.languages.c['comment'], 'macro-name': [ { pattern: /(^#\s*define\s+)\w+\b(?!\()/i, lookbehind: true }, { pattern: /(^#\s*define\s+)\w+\b(?=\()/i, lookbehind: true, alias: 'function' } ], // highlight macro directives as keywords 'directive': { pattern: /^(#\s*)[a-z]+/, lookbehind: true, alias: 'keyword' }, 'directive-hash': /^#/, 'punctuation': /##|\\(?=[\r\n])/, 'expression': { pattern: /\S[\s\S]*/, inside: Prism.languages.c } } } }); Prism.languages.insertBefore('c', 'function', { // highlight predefined macros as constants 'constant': /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }); delete Prism.languages.c['boolean']; (function (Prism) { var keyword = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/; var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function () { return keyword.source; }); Prism.languages.cpp = Prism.languages.extend('c', { 'class-name': [ { pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source .replace(/<keyword>/g, function () { return keyword.source; })), lookbehind: true }, // This is intended to capture the class name of method implementations like: // void foo::bar() const {} // However! The `foo` in the above example could also be a namespace, so we only capture the class name if // it starts with an uppercase letter. This approximation should give decent results. /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like: // Foo::~Foo() {} /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template // parameters, so it can't be a namespace (until C++ adds generic namespaces). /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/ ], 'keyword': keyword, 'number': { pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i, greedy: true }, 'operator': />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/, 'boolean': /\b(?:false|true)\b/ }); Prism.languages.insertBefore('cpp', 'string', { 'module': { // https://en.cppreference.com/w/cpp/language/modules pattern: RegExp( /(\b(?:import|module)\s+)/.source + '(?:' + // header-name /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + '|' + // module name or partition or both /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function () { return modName; }) + ')' ), lookbehind: true, greedy: true, inside: { 'string': /^[<"][\s\S]+/, 'operator': /:/, 'punctuation': /\./ } }, 'raw-string': { pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/, alias: 'string', greedy: true } }); Prism.languages.insertBefore('cpp', 'keyword', { 'generic-function': { pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i, inside: { 'function': /^\w+/, 'generic': { pattern: /<[\s\S]+/, alias: 'class-name', inside: Prism.languages.cpp } } } }); Prism.languages.insertBefore('cpp', 'operator', { 'double-colon': { pattern: /::/, alias: 'punctuation' } }); Prism.languages.insertBefore('cpp', 'class-name', { // the base clause is an optional list of parent classes // https://en.cppreference.com/w/cpp/language/class 'base-clause': { pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/, lookbehind: true, greedy: true, inside: Prism.languages.extend('cpp', {}) } }); Prism.languages.insertBefore('inside', 'double-colon', { // All untokenized words that are not namespaces should be class names 'class-name': /\b[a-z_]\w*\b(?!\s*::)/i }, Prism.languages.cpp['base-clause']); }(Prism)); Prism.languages.cmake = { 'comment': /#.*/, 'string': { pattern: /"(?:[^\\"]|\\.)*"/, greedy: true, inside: { 'interpolation': { pattern: /\$\{(?:[^{}$]|\$\{[^{}$]*\})*\}/, inside: { 'punctuation': /\$\{|\}/, 'variable': /\w+/ } } } }, 'variable': /\b(?:CMAKE_\w+|\w+_(?:(?:BINARY|SOURCE)_DIR|DESCRIPTION|HOMEPAGE_URL|ROOT|VERSION(?:_MAJOR|_MINOR|_PATCH|_TWEAK)?)|(?:ANDROID|APPLE|BORLAND|BUILD_SHARED_LIBS|CACHE|CPACK_(?:ABSOLUTE_DESTINATION_FILES|COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY|ERROR_ON_ABSOLUTE_INSTALL_DESTINATION|INCLUDE_TOPLEVEL_DIRECTORY|INSTALL_DEFAULT_DIRECTORY_PERMISSIONS|INSTALL_SCRIPT|PACKAGING_INSTALL_PREFIX|SET_DESTDIR|WARN_ON_ABSOLUTE_INSTALL_DESTINATION)|CTEST_(?:BINARY_DIRECTORY|BUILD_COMMAND|BUILD_NAME|BZR_COMMAND|BZR_UPDATE_OPTIONS|CHANGE_ID|CHECKOUT_COMMAND|CONFIGURATION_TYPE|CONFIGURE_COMMAND|COVERAGE_COMMAND|COVERAGE_EXTRA_FLAGS|CURL_OPTIONS|CUSTOM_(?:COVERAGE_EXCLUDE|ERROR_EXCEPTION|ERROR_MATCH|ERROR_POST_CONTEXT|ERROR_PRE_CONTEXT|MAXIMUM_FAILED_TEST_OUTPUT_SIZE|MAXIMUM_NUMBER_OF_(?:ERRORS|WARNINGS)|MAXIMUM_PASSED_TEST_OUTPUT_SIZE|MEMCHECK_IGNORE|POST_MEMCHECK|POST_TEST|PRE_MEMCHECK|PRE_TEST|TESTS_IGNORE|WARNING_EXCEPTION|WARNING_MATCH)|CVS_CHECKOUT|CVS_COMMAND|CVS_UPDATE_OPTIONS|DROP_LOCATION|DROP_METHOD|DROP_SITE|DROP_SITE_CDASH|DROP_SITE_PASSWORD|DROP_SITE_USER|EXTRA_COVERAGE_GLOB|GIT_COMMAND|GIT_INIT_SUBMODULES|GIT_UPDATE_CUSTOM|GIT_UPDATE_OPTIONS|HG_COMMAND|HG_UPDATE_OPTIONS|LABELS_FOR_SUBPROJECTS|MEMORYCHECK_(?:COMMAND|COMMAND_OPTIONS|SANITIZER_OPTIONS|SUPPRESSIONS_FILE|TYPE)|NIGHTLY_START_TIME|P4_CLIENT|P4_COMMAND|P4_OPTIONS|P4_UPDATE_OPTIONS|RUN_CURRENT_SCRIPT|SCP_COMMAND|SITE|SOURCE_DIRECTORY|SUBMIT_URL|SVN_COMMAND|SVN_OPTIONS|SVN_UPDATE_OPTIONS|TEST_LOAD|TEST_TIMEOUT|TRIGGER_SITE|UPDATE_COMMAND|UPDATE_OPTIONS|UPDATE_VERSION_ONLY|USE_LAUNCHERS)|CYGWIN|ENV|EXECUTABLE_OUTPUT_PATH|GHS-MULTI|IOS|LIBRARY_OUTPUT_PATH|MINGW|MSVC(?:10|11|12|14|60|70|71|80|90|_IDE|_TOOLSET_VERSION|_VERSION)?|MSYS|PROJECT_NAME|UNIX|WIN32|WINCE|WINDOWS_PHONE|WINDOWS_STORE|XCODE))\b/, 'property': /\b(?:cxx_\w+|(?:ARCHIVE_OUTPUT_(?:DIRECTORY|NAME)|COMPILE_DEFINITIONS|COMPILE_PDB_NAME|COMPILE_PDB_OUTPUT_DIRECTORY|EXCLUDE_FROM_DEFAULT_BUILD|IMPORTED_(?:IMPLIB|LIBNAME|LINK_DEPENDENT_LIBRARIES|LINK_INTERFACE_LANGUAGES|LINK_INTERFACE_LIBRARIES|LINK_INTERFACE_MULTIPLICITY|LOCATION|NO_SONAME|OBJECTS|SONAME)|INTERPROCEDURAL_OPTIMIZATION|LIBRARY_OUTPUT_DIRECTORY|LIBRARY_OUTPUT_NAME|LINK_FLAGS|LINK_INTERFACE_LIBRARIES|LINK_INTERFACE_MULTIPLICITY|LOCATION|MAP_IMPORTED_CONFIG|OSX_ARCHITECTURES|OUTPUT_NAME|PDB_NAME|PDB_OUTPUT_DIRECTORY|RUNTIME_OUTPUT_DIRECTORY|RUNTIME_OUTPUT_NAME|STATIC_LIBRARY_FLAGS|VS_CSHARP|VS_DOTNET_REFERENCEPROP|VS_DOTNET_REFERENCE|VS_GLOBAL_SECTION_POST|VS_GLOBAL_SECTION_PRE|VS_GLOBAL|XCODE_ATTRIBUTE)_\w+|\w+_(?:CLANG_TIDY|COMPILER_LAUNCHER|CPPCHECK|CPPLINT|INCLUDE_WHAT_YOU_USE|OUTPUT_NAME|POSTFIX|VISIBILITY_PRESET)|ABSTRACT|ADDITIONAL_MAKE_CLEAN_FILES|ADVANCED|ALIASED_TARGET|ALLOW_DUPLICATE_CUSTOM_TARGETS|ANDROID_(?:ANT_ADDITIONAL_OPTIONS|API|API_MIN|ARCH|ASSETS_DIRECTORIES|GUI|JAR_DEPENDENCIES|NATIVE_LIB_DEPENDENCIES|NATIVE_LIB_DIRECTORIES|PROCESS_MAX|PROGUARD|PROGUARD_CONFIG_PATH|SECURE_PROPS_PATH|SKIP_ANT_STEP|STL_TYPE)|ARCHIVE_OUTPUT_DIRECTORY|ATTACHED_FILES|ATTACHED_FILES_ON_FAIL|AUTOGEN_(?:BUILD_DIR|ORIGIN_DEPENDS|PARALLEL|SOURCE_GROUP|TARGETS_FOLDER|TARGET_DEPENDS)|AUTOMOC|AUTOMOC_(?:COMPILER_PREDEFINES|DEPEND_FILTERS|EXECUTABLE|MACRO_NAMES|MOC_OPTIONS|SOURCE_GROUP|TARGETS_FOLDER)|AUTORCC|AUTORCC_EXECUTABLE|AUTORCC_OPTIONS|AUTORCC_SOURCE_GROUP|AUTOUIC|AUTOUIC_EXECUTABLE|AUTOUIC_OPTIONS|AUTOUIC_SEARCH_PATHS|BINARY_DIR|BUILDSYSTEM_TARGETS|BUILD_RPATH|BUILD_RPATH_USE_ORIGIN|BUILD_WITH_INSTALL_NAME_DIR|BUILD_WITH_INSTALL_RPATH|BUNDLE|BUNDLE_EXTENSION|CACHE_VARIABLES|CLEAN_NO_CUSTOM|COMMON_LANGUAGE_RUNTIME|COMPATIBLE_INTERFACE_(?:BOOL|NUMBER_MAX|NUMBER_MIN|STRING)|COMPILE_(?:DEFINITIONS|FEATURES|FLAGS|OPTIONS|PDB_NAME|PDB_OUTPUT_DIRECTORY)|COST|CPACK_DESKTOP_SHORTCUTS|CPACK_NEVER_OVERWRITE|CPACK_PERMANENT|CPACK_STARTUP_SHORTCUTS|CPACK_START_MENU_SHORTCUTS|CPACK_WIX_ACL|CROSSCOMPILING_EMULATOR|CUDA_EXTENSIONS|CUDA_PTX_COMPILATION|CUDA_RESOLVE_DEVICE_SYMBOLS|CUDA_SEPARABLE_COMPILATION|CUDA_STANDARD|CUDA_STANDARD_REQUIRED|CXX_EXTENSIONS|CXX_STANDARD|CXX_STANDARD_REQUIRED|C_EXTENSIONS|C_STANDARD|C_STANDARD_REQUIRED|DEBUG_CONFIGURATIONS|DEFINE_SYMBOL|DEFINITIONS|DEPENDS|DEPLOYMENT_ADDITIONAL_FILES|DEPLOYMENT_REMOTE_DIRECTORY|DISABLED|DISABLED_FEATURES|ECLIPSE_EXTRA_CPROJECT_CONTENTS|ECLIPSE_EXTRA_NATURES|ENABLED_FEATURES|ENABLED_LANGUAGES|ENABLE_EXPORTS|ENVIRONMENT|EXCLUDE_FROM_ALL|EXCLUDE_FROM_DEFAULT_BUILD|EXPORT_NAME|EXPORT_PROPERTIES|EXTERNAL_OBJECT|EchoString|FAIL_REGULAR_EXPRESSION|FIND_LIBRARY_USE_LIB32_PATHS|FIND_LIBRARY_USE_LIB64_PATHS|FIND_LIBRARY_USE_LIBX32_PATHS|FIND_LIBRARY_USE_OPENBSD_VERSIONING|FIXTURES_CLEANUP|FIXTURES_REQUIRED|FIXTURES_SETUP|FOLDER|FRAMEWORK|Fortran_FORMAT|Fortran_MODULE_DIRECTORY|GENERATED|GENERATOR_FILE_NAME|GENERATOR_IS_MULTI_CONFIG|GHS_INTEGRITY_APP|GHS_NO_SOURCE_GROUP_FILE|GLOBAL_DEPENDS_DEBUG_MODE|GLOBAL_DEPENDS_NO_CYCLES|GNUtoMS|HAS_CXX|HEADER_FILE_ONLY|HELPSTRING|IMPLICIT_DEPENDS_INCLUDE_TRANSFORM|IMPORTED|IMPORTED_(?:COMMON_LANGUAGE_RUNTIME|CONFIGURATIONS|GLOBAL|IMPLIB|LIBNAME|LINK_DEPENDENT_LIBRARIES|LINK_INTERFACE_(?:LANGUAGES|LIBRARIES|MULTIPLICITY)|LOCATION|NO_SONAME|OBJECTS|SONAME)|IMPORT_PREFIX|IMPORT_SUFFIX|INCLUDE_DIRECTORIES|INCLUDE_REGULAR_EXPRESSION|INSTALL_NAME_DIR|INSTALL_RPATH|INSTALL_RPATH_USE_LINK_PATH|INTERFACE_(?:AUTOUIC_OPTIONS|COMPILE_DEFINITIONS|COMPILE_FEATURES|COMPILE_OPTIONS|INCLUDE_DIRECTORIES|LINK_DEPENDS|LINK_DIRECTORIES|LINK_LIBRARIES|LINK_OPTIONS|POSITION_INDEPENDENT_CODE|SOURCES|SYSTEM_INCLUDE_DIRECTORIES)|INTERPROCEDURAL_OPTIMIZATION|IN_TRY_COMPILE|IOS_INSTALL_COMBINED|JOB_POOLS|JOB_POOL_COMPILE|JOB_POOL_LINK|KEEP_EXTENSION|LABELS|LANGUAGE|LIBRARY_OUTPUT_DIRECTORY|LINKER_LANGUAGE|LINK_(?:DEPENDS|DEPENDS_NO_SHARED|DIRECTORIES|FLAGS|INTERFACE_LIBRARIES|INTERFACE_MULTIPLICITY|LIBRARIES|OPTIONS|SEARCH_END_STATIC|SEARCH_START_STATIC|WHAT_YOU_USE)|LISTFILE_STACK|LOCATION|MACOSX_BUNDLE|MACOSX_BUNDLE_INFO_PLIST|MACOSX_FRAMEWORK_INFO_PLIST|MACOSX_PACKAGE_LOCATION|MACOSX_RPATH|MACROS|MANUALLY_ADDED_DEPENDENCIES|MEASUREMENT|MODIFIED|NAME|NO_SONAME|NO_SYSTEM_FROM_IMPORTED|OBJECT_DEPENDS|OBJECT_OUTPUTS|OSX_ARCHITECTURES|OUTPUT_NAME|PACKAGES_FOUND|PACKAGES_NOT_FOUND|PARENT_DIRECTORY|PASS_REGULAR_EXPRESSION|PDB_NAME|PDB_OUTPUT_DIRECTORY|POSITION_INDEPENDENT_CODE|POST_INSTALL_SCRIPT|PREDEFINED_TARGETS_FOLDER|PREFIX|PRE_INSTALL_SCRIPT|PRIVATE_HEADER|PROCESSORS|PROCESSOR_AFFINITY|PROJECT_LABEL|PUBLIC_HEADER|REPORT_UNDEFINED_PROPERTIES|REQUIRED_FILES|RESOURCE|RESOURCE_LOCK|RULE_LAUNCH_COMPILE|RULE_LAUNCH_CUSTOM|RULE_LAUNCH_LINK|RULE_MESSAGES|RUNTIME_OUTPUT_DIRECTORY|RUN_SERIAL|SKIP_AUTOGEN|SKIP_AUTOMOC|SKIP_AUTORCC|SKIP_AUTOUIC|SKIP_BUILD_RPATH|SKIP_RETURN_CODE|SOURCES|SOURCE_DIR|SOVERSION|STATIC_LIBRARY_FLAGS|STATIC_LIBRARY_OPTIONS|STRINGS|SUBDIRECTORIES|SUFFIX|SYMBOLIC|TARGET_ARCHIVES_MAY_BE_SHARED_LIBS|TARGET_MESSAGES|TARGET_SUPPORTS_SHARED_LIBS|TESTS|TEST_INCLUDE_FILE|TEST_INCLUDE_FILES|TIMEOUT|TIMEOUT_AFTER_MATCH|TYPE|USE_FOLDERS|VALUE|VARIABLES|VERSION|VISIBILITY_INLINES_HIDDEN|VS_(?:CONFIGURATION_TYPE|COPY_TO_OUT_DIR|DEBUGGER_(?:COMMAND|COMMAND_ARGUMENTS|ENVIRONMENT|WORKING_DIRECTORY)|DEPLOYMENT_CONTENT|DEPLOYMENT_LOCATION|DOTNET_REFERENCES|DOTNET_REFERENCES_COPY_LOCAL|INCLUDE_IN_VSIX|IOT_STARTUP_TASK|KEYWORD|RESOURCE_GENERATOR|SCC_AUXPATH|SCC_LOCALPATH|SCC_PROJECTNAME|SCC_PROVIDER|SDK_REFERENCES|SHADER_(?:DISABLE_OPTIMIZATIONS|ENABLE_DEBUG|ENTRYPOINT|FLAGS|MODEL|OBJECT_FILE_NAME|OUTPUT_HEADER_FILE|TYPE|VARIABLE_NAME)|STARTUP_PROJECT|TOOL_OVERRIDE|USER_PROPS|WINRT_COMPONENT|WINRT_EXTENSIONS|WINRT_REFERENCES|XAML_TYPE)|WILL_FAIL|WIN32_EXECUTABLE|WINDOWS_EXPORT_ALL_SYMBOLS|WORKING_DIRECTORY|WRAP_EXCLUDE|XCODE_(?:EMIT_EFFECTIVE_PLATFORM_NAME|EXPLICIT_FILE_TYPE|FILE_ATTRIBUTES|LAST_KNOWN_FILE_TYPE|PRODUCT_TYPE|SCHEME_(?:ADDRESS_SANITIZER|ADDRESS_SANITIZER_USE_AFTER_RETURN|ARGUMENTS|DISABLE_MAIN_THREAD_CHECKER|DYNAMIC_LIBRARY_LOADS|DYNAMIC_LINKER_API_USAGE|ENVIRONMENT|EXECUTABLE|GUARD_MALLOC|MAIN_THREAD_CHECKER_STOP|MALLOC_GUARD_EDGES|MALLOC_SCRIBBLE|MALLOC_STACK|THREAD_SANITIZER(?:_STOP)?|UNDEFINED_BEHAVIOUR_SANITIZER(?:_STOP)?|ZOMBIE_OBJECTS))|XCTEST)\b/, 'keyword': /\b(?:add_compile_definitions|add_compile_options|add_custom_command|add_custom_target|add_definitions|add_dependencies|add_executable|add_library|add_link_options|add_subdirectory|add_test|aux_source_directory|break|build_command|build_name|cmake_host_system_information|cmake_minimum_required|cmake_parse_arguments|cmake_policy|configure_file|continue|create_test_sourcelist|ctest_build|ctest_configure|ctest_coverage|ctest_empty_binary_directory|ctest_memcheck|ctest_read_custom_files|ctest_run_script|ctest_sleep|ctest_start|ctest_submit|ctest_test|ctest_update|ctest_upload|define_property|else|elseif|enable_language|enable_testing|endforeach|endfunction|endif|endmacro|endwhile|exec_program|execute_process|export|export_library_dependencies|file|find_file|find_library|find_package|find_path|find_program|fltk_wrap_ui|foreach|function|get_cmake_property|get_directory_property|get_filename_component|get_property|get_source_file_property|get_target_property|get_test_property|if|include|include_directories|include_external_msproject|include_guard|include_regular_expression|install|install_files|install_programs|install_targets|link_directories|link_libraries|list|load_cache|load_command|macro|make_directory|mark_as_advanced|math|message|option|output_required_files|project|qt_wrap_cpp|qt_wrap_ui|remove|remove_definitions|return|separate_arguments|set|set_directory_properties|set_property|set_source_files_properties|set_target_properties|set_tests_properties|site_name|source_group|string|subdir_depends|subdirs|target_compile_definitions|target_compile_features|target_compile_options|target_include_directories|target_link_directories|target_link_libraries|target_link_options|target_sources|try_compile|try_run|unset|use_mangled_mesa|utility_source|variable_requires|variable_watch|while|write_file)(?=\s*\()\b/, 'boolean': /\b(?:FALSE|OFF|ON|TRUE)\b/, 'namespace': /\b(?:INTERFACE|PRIVATE|PROPERTIES|PUBLIC|SHARED|STATIC|TARGET_OBJECTS)\b/, 'operator': /\b(?:AND|DEFINED|EQUAL|GREATER|LESS|MATCHES|NOT|OR|STREQUAL|STRGREATER|STRLESS|VERSION_EQUAL|VERSION_GREATER|VERSION_LESS)\b/, 'inserted': { pattern: /\b\w+::\w+\b/, alias: 'class-name' }, 'number': /\b\d+(?:\.\d+)*\b/, 'function': /\b[a-z_]\w*(?=\s*\()\b/i, 'punctuation': /[()>}]|\$[<{]/ }; (function (Prism) { // Ignore comments starting with { to privilege string interpolation highlighting var comment = /#(?!\{).+/; var interpolation = { 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' }, 'script': { pattern: /[\s\S]+/, alias: 'language-javascript', inside: 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 * * Adds the following new token classes: * constant, builtin, variable, symbol, regex */ (function (Prism) { Prism.languages.ruby = Prism.languages.extend('clike', { 'comment': { pattern: /#.*|^=begin\s[\s\S]*?^=end/m, greedy: true }, 'class-name': { pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/, lookbehind: true, inside: { 'punctuation': /[.\\]/ } }, 'keyword': /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/, 'operator': /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/, 'punctuation': /[(){}[\].,;]/, }); Prism.languages.insertBefore('ruby', 'operator', { 'double-colon': { pattern: /::/, alias: 'punctuation' }, }); var interpolation = { pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/, lookbehind: true, inside: { 'content': { pattern: /^(#\{)[\s\S]+(?=\}$)/, lookbehind: true, inside: Prism.languages.ruby }, 'delimiter': { pattern: /^#\{|\}$/, alias: 'punctuation' } } }; delete Prism.languages.ruby.function; var percentExpression = '(?:' + [ /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source, /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source, /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source, /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source, /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source ].join('|') + ')'; var symbolName = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source; Prism.languages.insertBefore('ruby', 'keyword', { 'regex-literal': [ { pattern: RegExp(/%r/.source + percentExpression + /[egimnosux]{0,6}/.source), greedy: true, inside: { 'interpolation': interpolation, 'regex': /[\s\S]+/ } }, { pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/, lookbehind: true, greedy: true, inside: { 'interpolation': interpolation, 'regex': /[\s\S]+/ } } ], 'variable': /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/, 'symbol': [ { pattern: RegExp(/(^|[^:]):/.source + symbolName), lookbehind: true, greedy: true }, { pattern: RegExp(/([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source), lookbehind: true, greedy: true }, ], 'method-definition': { pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/, lookbehind: true, inside: { 'function': /\b\w+$/, 'keyword': /^self\b/, 'class-name': /^\w+/, 'punctuation': /\./ } } }); Prism.languages.insertBefore('ruby', 'string', { 'string-literal': [ { pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression), greedy: true, inside: { 'interpolation': interpolation, 'string': /[\s\S]+/ } }, { pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/, greedy: true, inside: { 'interpolation': interpolation, 'string': /[\s\S]+/ } }, { pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i, alias: 'heredoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i, inside: { 'symbol': /\b\w+/, 'punctuation': /^<<[-~]?/ } }, 'interpolation': interpolation, 'string': /[\s\S]+/ } }, { pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i, alias: 'heredoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i, inside: { 'symbol': /\b\w+/, 'punctuation': /^<<[-~]?'|'$/, } }, 'string': /[\s\S]+/ } } ], 'command-literal': [ { pattern: RegExp(/%x/.source + percentExpression), greedy: true, inside: { 'interpolation': interpolation, 'command': { pattern: /[\s\S]+/, alias: 'string' } } }, { pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/, greedy: true, inside: { 'interpolation': interpolation, 'command': { pattern: /[\s\S]+/, alias: 'string' } } } ] }); delete Prism.languages.ruby.string; Prism.languages.insertBefore('ruby', 'number', { 'builtin': /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/, 'constant': /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/ }); Prism.languages.rb = Prism.languages.ruby; }(Prism)); (function (Prism) { Prism.languages.crystal = Prism.languages.extend('ruby', { 'keyword': [ /\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\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/, 'operator': [ /->/, Prism.languages.ruby.operator, ], 'punctuation': /[(){}[\].,;\\]/, }); Prism.languages.insertBefore('crystal', 'string-literal', { 'attribute': { pattern: /@\[.*?\]/, inside: { 'delimiter': { pattern: /^@\[|\]$/, alias: 'punctuation' }, 'attribute': { pattern: /^(\s*)\w+/, lookbehind: true, alias: 'class-name' }, 'args': { pattern: /\S(?:[\s\S]*\S)?/, inside: Prism.languages.crystal }, } }, 'expansion': { pattern: /\{(?:\{.*?\}|%.*?%)\}/, inside: { 'content': { pattern: /^(\{.)[\s\S]+(?=.\}$)/, lookbehind: true, inside: Prism.languages.crystal }, 'delimiter': { pattern: /^\{[\{%]|[\}%]\}$/, alias: 'operator' } } }, 'char': { pattern: /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/, greedy: true } }); }(Prism)); Prism.languages.d = Prism.languages.extend('clike', { 'comment': [ { // Shebang pattern: /^\s*#!.+/, greedy: true }, { pattern: RegExp(/(^|[^\\])/.source + '(?:' + [ // /+ comment +/ // Allow one level of nesting /\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source, // // comment /\/\/.*/.source, // /* comment */ /\/\*[\s\S]*?\*\//.source ].join('|') + ')'), lookbehind: true, greedy: true } ], 'string': [ { pattern: RegExp([ // r"", x"" /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source, // q"[]", q"()", q"<>", q"{}" /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source, // q"IDENT // ... // IDENT" /\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source, // q"//", q"||", etc. // eslint-disable-next-line regexp/strict /\bq"(.)[\s\S]*?\2"/.source, // eslint-disable-next-line regexp/strict /(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source ].join('|'), 'm'), greedy: true }, { pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/, greedy: true, alias: 'token-string' } ], // In order: $, keywords and special tokens, globally defined symbols 'keyword': /\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|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|dstring|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|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|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|wstring)\b/, '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]{0,4}/i, { pattern: /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i, lookbehind: true } ], 'operator': /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/ }); Prism.languages.insertBefore('d', 'string', { // Characters // 'a', '\\', '\n', '\xFF', '\377', '\uFFFF', '\U0010FFFF', '\quot' 'char': /'(?:\\(?:\W|\w+)|[^\\])'/ }); Prism.languages.insertBefore('d', 'keyword', { 'property': /\B@\w*/ }); Prism.languages.insertBefore('d', 'function', { 'register': { // Iasm registers pattern: /\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/, alias: 'variable' } }); (function (Prism) { var keywords = [ /\b(?:async|sync|yield)\*/, /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/ ]; // Handles named imports, such as http.Client var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source; // based on the dart naming conventions var className = { pattern: RegExp(packagePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source), lookbehind: true, inside: { 'namespace': { pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/, inside: { 'punctuation': /\./ } }, } }; Prism.languages.dart = 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) pattern: RegExp(packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source), lookbehind: true, inside: className.inside } ], 'keyword': keywords, 'operator': /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/ }); Prism.languages.insertBefore('dart', 'string', { 'string-literal': { pattern: /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/, greedy: true, inside: { 'interpolation': { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/, lookbehind: true, inside: { 'punctuation': /^\$\{?|\}$/, 'expression': { pattern: /[\s\S]+/, inside: Prism.languages.dart } } }, 'string': /[\s\S]+/ } }, 'string': undefined }); Prism.languages.insertBefore('dart', 'class-name', { 'metadata': { pattern: /@\w+/, alias: 'function' } }); Prism.languages.insertBefore('dart', 'class-name', { 'generics': { pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/, inside: { 'class-name': className, 'keyword': keywords, 'punctuation': /[<>(),.:]/, 'operator': /[?&|]/ } }, }); }(Prism)); (function (Prism) { Prism.languages.diff = { 'coord': [ // Match all kinds of coord lines (prefixed by "+++", "---" or "***"). /^(?:\*{3}|-{3}|\+{3}).*$/m, // Match "@@ ... @@" coord lines in unified diff. /^@@.*@@$/m, // Match coord lines in normal diff (starts with a number). /^\d.*$/m ] // deleted, inserted, unchanged, diff }; /** * A map from the name of a block to its line prefix. * * @type {Object<string, string>} */ var PREFIXES = { 'deleted-sign': '-', 'deleted-arrow': '<', 'inserted-sign': '+', 'inserted-arrow': '>', 'unchanged': ' ', 'diff': '!', }; // add a token for each prefix Object.keys(PREFIXES).forEach(function (name) { var prefix = PREFIXES[name]; var alias = []; if (!/^\w+$/.test(name)) { // "deleted-sign" -> "deleted" alias.push(/\w+/.exec(name)[0]); } if (name === 'diff') { alias.push('bold'); } Prism.languages.diff[name] = { pattern: RegExp('^(?:[' + prefix + '].*(?:\r\n?|\n|(?![\\s\\S])))+', 'm'), alias: alias, inside: { 'line': { pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/, lookbehind: true }, 'prefix': { pattern: /[\s\S]/, alias: /\w+/.exec(name)[0] } } }; }); // make prefixes available to Diff plugin Object.defineProperty(Prism.languages.diff, 'PREFIXES', { value: PREFIXES }); }(Prism)); (function (Prism) { /** * 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); } } }); }(Prism)); // 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': /[Ff]alse|[Nn]one|[Tt]rue/, '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.elixir = { 'doc': { pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/, inside: { 'attribute': /^@\w+/, 'string': /['"][\s\S]+/ } }, 'comment': { pattern: /#.*/, greedy: 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' }, 'module': { pattern: /\b[A-Z]\w*\b/, alias: 'class-name' }, // Look-ahead prevents bad highlighting of the :: operator 'attr-name': /\b\w+\??:(?!:)/, 'argument': { // Look-behind prevents bad highlighting of the && operator pattern: /(^|[^&])&\d+/, lookbehind: true, alias: 'variable' }, 'attribute': { pattern: /@\w+/, alias: 'variable' }, 'function': /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/, 'number': /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i, 'keyword': /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/, 'boolean': /\b(?:false|nil|true)\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 } } }; }); 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(?:false|true)\b/, 'keyword': /\b(?:after|begin|case|catch|end|fun|if|of|receive|try|when)\b/, 'number': [ /\$\\?./, /\b\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(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\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', { 'string': { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/, lookbehind: true, 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/, 'boolean': /\b(?:_|false|iota|nil|true)\b/, 'number': [ // binary and octal integers /\b0(?:b[01_]+|o[0-7_]+)i?\b/i, // hexadecimal integers and floats /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i, // decimal integers and floats /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i ], 'operator': /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./, 'builtin': /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/ }); Prism.languages.insertBefore('go', 'string', { 'char': { pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/, greedy: true } }); delete Prism.languages.go['class-name']; (function (Prism) { var interpolation = { pattern: /((?:^|[^\\$])(?:\\{2})*)\$(?:\w+|\{[^{}]*\})/, lookbehind: true, inside: { 'interpolation-punctuation': { pattern: /^\$\{?|\}$/, alias: 'punctuation' }, 'expression': { pattern: /[\s\S]+/, inside: null // see below } } }; Prism.languages.groovy = Prism.languages.extend('clike', { 'string': { // https://groovy-lang.org/syntax.html#_dollar_slashy_string pattern: /'''(?:[^\\]|\\[\s\S])*?'''|'(?:\\.|[^\\'\r\n])*'/, greedy: true }, 'keyword': /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/, 'number': /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i, 'operator': { pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/, lookbehind: true }, 'punctuation': /\.+|[{}[\];(),:$]/ }); Prism.languages.insertBefore('groovy', 'string', { 'shebang': { pattern: /#!.+/, alias: 'comment', greedy: true }, 'interpolation-string': { // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with // simple division (see JS regex), so find a fix maybe? pattern: /"""(?:[^\\]|\\[\s\S])*?"""|(["/])(?:\\.|(?!\1)[^\\\r\n])*\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/, greedy: true, inside: { 'interpolation': interpolation, 'string': /[\s\S]+/ } } }); Prism.languages.insertBefore('groovy', 'punctuation', { 'spock-block': /\b(?:and|cleanup|expect|given|setup|then|when|where):/ }); Prism.languages.insertBefore('groovy', 'function', { 'annotation': { pattern: /(^|[^.])@\w+/, lookbehind: true, alias: 'punctuation' } }); interpolation.inside.expression.inside = Prism.languages.groovy; }(Prism)); (function (Prism) { var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/; // full package (optional) + parent classes (optional) var classNamePrefix = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source; // based on the java naming conventions var className = { pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source), lookbehind: true, inside: { 'namespace': { pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/, inside: { 'punctuation': /\./ } }, 'punctuation': /\./ } }; Prism.languages.java = Prism.languages.extend('clike', { 'string': { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/, lookbehind: true, greedy: true }, 'class-name': [ className, { // variables, parameters, and constructor references // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods) pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source), lookbehind: true, inside: className.inside }, { // class names based on keyword // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods) pattern: RegExp(/(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + classNamePrefix + /[A-Z]\w*\b/.source), lookbehind: true, inside: className.inside } ], 'keyword': keywords, 'function': [ Prism.languages.clike.function, { pattern: /(::\s*)[a-z_]\w*/, lookbehind: true } ], 'number': /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i, 'operator': { pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m, lookbehind: true }, 'constant': /\b[A-Z][A-Z_\d]+\b/ }); Prism.languages.insertBefore('java', 'string', { 'triple-quoted-string': { // http://openjdk.java.net/jeps/355#Description pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/, greedy: true, alias: 'string' }, 'char': { pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/, greedy: true } }); Prism.languages.insertBefore('java', 'class-name', { 'annotation': { pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/, lookbehind: true, alias: 'punctuation' }, 'generics': { pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/, inside: { 'class-name': className, 'keyword': keywords, 'punctuation': /[<>(),.:]/, 'operator': /[?&|]/ } }, 'import': [ { pattern: RegExp(/(\bimport\s+)/.source + classNamePrefix + /(?:[A-Z]\w*|\*)(?=\s*;)/.source), lookbehind: true, inside: { 'namespace': className.inside.namespace, 'punctuation': /\./, 'operator': /\*/, 'class-name': /\w+/ } }, { pattern: RegExp(/(\bimport\s+static\s+)/.source + classNamePrefix + /(?:\w+|\*)(?=\s*;)/.source), lookbehind: true, alias: 'static', inside: { 'namespace': className.inside.namespace, 'static': /\b\w+$/, 'punctuation': /\./, 'operator': /\*/, 'class-name': /\w+/ } } ], 'namespace': { pattern: RegExp( /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/ .source.replace(/<keyword>/g, function () { return keywords.source; })), lookbehind: true, inside: { 'punctuation': /\./, } } }); }(Prism)); // https://www.json.org/json-en.html Prism.languages.json = { 'property': { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/, lookbehind: true, greedy: true }, 'string': { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/, lookbehind: true, greedy: true }, 'comment': { pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: true }, 'number': /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, 'punctuation': /[{}[\],]/, 'operator': /:/, 'boolean': /\b(?:false|true)\b/, 'null': { pattern: /\bnull\b/, alias: 'keyword' } }; Prism.languages.webmanifest = Prism.languages.json; Prism.languages.julia = { 'comment': { // support one level of nested comments // https://github.com/JuliaLang/julia/pull/6128 pattern: /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/, lookbehind: true }, 'regex': { // https://docs.julialang.org/en/v1/manual/strings/#Regular-Expressions-1 pattern: /r"(?:\\.|[^"\\\r\n])*"[imsx]{0,4}/, greedy: true }, 'string': { // https://docs.julialang.org/en/v1/manual/strings/#String-Basics-1 // https://docs.julialang.org/en/v1/manual/strings/#non-standard-string-literals-1 // https://docs.julialang.org/en/v1/manual/running-external-programs/#Running-External-Programs-1 pattern: /"""[\s\S]+?"""|(?:\b\w+)?"(?:\\.|[^"\\\r\n])*"|`(?:[^\\`\r\n]|\\.)*`/, greedy: true }, 'char': { // https://docs.julialang.org/en/v1/manual/strings/#man-characters-1 pattern: /(^|[^\w'])'(?:\\[^\r\n][^'\r\n]*|[^\\\r\n])'/, lookbehind: true, greedy: true }, 'keyword': /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/, 'boolean': /\b(?:false|true)\b/, 'number': /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+(?:_[\da-f]+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[efp][+-]?\d+(?:_\d+)*)?j?/i, // https://docs.julialang.org/en/v1/manual/mathematical-operations/ // https://docs.julialang.org/en/v1/manual/mathematical-operations/#Operator-Precedence-and-Associativity-1 'operator': /&&|\|\||[-+*^%÷⊻&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥'√∛]/, 'punctuation': /::?|[{}[\]();,.?]/, // https://docs.julialang.org/en/v1/base/numbers/#Base.im 'constant': /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[πℯ]/ }; (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': [ { pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/, greedy: true }, { pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/, lookbehind: true, greedy: true } ], 'number': /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/, 'operator': /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/ }); delete Prism.languages.kotlin['class-name']; var interpolationInside = { 'interpolation-punctuation': { pattern: /^\$\{?|\}$/, alias: 'punctuation' }, 'expression': { pattern: /[\s\S]+/, inside: Prism.languages.kotlin } }; Prism.languages.insertBefore('kotlin', 'string', { // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions 'string-literal': [ { pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/, alias: 'multiline', inside: { 'interpolation': { pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i, inside: interpolationInside }, 'string': /[\s\S]+/ } }, { pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/, alias: 'singleline', inside: { 'interpolation': { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i, lookbehind: true, inside: interpolationInside }, 'string': /[\s\S]+/ } } ], 'char': { // https://kotlinlang.org/spec/expressions.html#character-literals pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/, greedy: true } }); delete Prism.languages.kotlin['string']; Prism.languages.insertBefore('kotlin', 'keyword', { 'annotation': { pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/, alias: 'builtin' } }); Prism.languages.insertBefore('kotlin', 'function', { 'label': { pattern: /\b\w+@|@\w+\b/, alias: 'symbol' } }); Prism.languages.kt = Prism.languages.kotlin; Prism.languages.kts = Prism.languages.kotlin; }(Prism)); (function (Prism) { var funcPattern = /\\(?:[^a-z()[\]]|[a-z*]+)/i; var insideEqu = { 'equation-command': { pattern: funcPattern, alias: 'regex' } }; Prism.languages.latex = { 'comment': /%.*/, // the verbatim environment prints whitespace to the document 'cdata': { pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/, lookbehind: true }, /* * equations can be between $$ $$ or $ $ or \( \) or \[ \] * (all are multiline) */ 'equation': [ { pattern: /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/, inside: insideEqu, alias: 'string' }, { pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/, lookbehind: true, inside: insideEqu, alias: 'string' } ], /* * arguments which are keywords or references are highlighted * as keywords */ 'keyword': { pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/, lookbehind: true }, 'url': { pattern: /(\\url\{)[^}]+(?=\})/, lookbehind: true }, /* * section or chapter headlines are highlighted as bold so that * they stand out more */ 'headline': { pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/, lookbehind: true, alias: 'class-name' }, 'function': { pattern: funcPattern, alias: 'selector' }, 'punctuation': /[[\]{}&]/ }; Prism.languages.tex = Prism.languages.latex; Prism.languages.context = Prism.languages.latex; }(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|[^z]))*\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) { // Allow only one line break var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source; /** * This function is intended for the creation of the bold or italic pattern. * * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped. * * _Note:_ Keep in mind that this adds a capturing group. * * @param {string} pattern * @returns {RegExp} */ function createInline(pattern) { pattern = pattern.replace(/<inner>/g, function () { return inner; }); return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + '(?:' + pattern + ')'); } var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source; var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function () { return tableCell; }); var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source; Prism.languages.markdown = Prism.languages.extend('markup', {}); Prism.languages.insertBefore('markdown', 'prolog', { 'front-matter-block': { pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/, lookbehind: true, greedy: true, inside: { 'punctuation': /^---|---$/, 'front-matter': { pattern: /\S+(?:\s+\S+)*/, alias: ['yaml', 'language-yaml'], inside: Prism.languages.yaml } } }, 'blockquote': { // > ... pattern: /^>(?:[\t ]*>)*/m, alias: 'punctuation' }, 'table': { pattern: RegExp('^' + tableRow + tableLine + '(?:' + tableRow + ')*', 'm'), inside: { 'table-data-rows': { pattern: RegExp('^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$'), lookbehind: true, inside: { 'table-data': { pattern: RegExp(tableCell), inside: Prism.languages.markdown }, 'punctuation': /\|/ } }, 'table-line': { pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'), lookbehind: true, inside: { 'punctuation': /\||:?-{3,}:?/ } }, 'table-header-row': { pattern: RegExp('^' + tableRow + '$'), inside: { 'table-header': { pattern: RegExp(tableCell), alias: 'important', inside: Prism.languages.markdown }, 'punctuation': /\|/ } } } }, 'code': [ { // Prefixed by 4 spaces or 1 tab and preceded by an empty line pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, lookbehind: true, alias: 'keyword' }, { // ```optional language // code block // ``` pattern: /^```[\s\S]*?^```$/m, greedy: true, inside: { 'code-block': { pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, lookbehind: true }, 'code-language': { pattern: /^(```).+/, lookbehind: true }, 'punctuation': /```/ } } ], 'title': [ { // title 1 // ======= // title 2 // ------- pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, alias: 'important', inside: { punctuation: /==+$|--+$/ } }, { // # title 1 // ###### title 6 pattern: /(^\s*)#.+/m, lookbehind: true, alias: 'important', inside: { punctuation: /^#+|#+$/ } } ], 'hr': { // *** // --- // * * * // ----------- pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, lookbehind: true, alias: 'punctuation' }, 'list': { // * item // + item // - item // 1. item pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, lookbehind: true, alias: 'punctuation' }, 'url-reference': { // [id]: http://example.com "Optional title" // [id]: http://example.com 'Optional title' // [id]: http://example.com (Optional title) // [id]: <http://example.com> "Optional title" pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, inside: { 'variable': { pattern: /^(!?\[)[^\]]+/, lookbehind: true }, 'string': /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, 'punctuation': /^[\[\]!:]|[<>]/ }, alias: 'url' }, 'bold': { // **strong** // __strong__ // allow one nested instance of italic text using the same delimiter pattern: createInline(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source), lookbehind: true, greedy: true, inside: { 'content': { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: true, inside: {} // see below }, 'punctuation': /\*\*|__/ } }, 'italic': { // *em* // _em_ // allow one nested instance of bold text using the same delimiter pattern: createInline(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source), lookbehind: true, greedy: true, inside: { 'content': { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: true, inside: {} // see below }, 'punctuation': /[*_]/ } }, 'strike': { // ~~strike through~~ // ~strike~ // eslint-disable-next-line regexp/strict pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source), lookbehind: true, greedy: true, inside: { 'content': { pattern: /(^~~?)[\s\S]+(?=\1$)/, lookbehind: true, inside: {} // see below }, 'punctuation': /~~?/ } }, 'code-snippet': { // `code` // ``code`` pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, lookbehind: true, greedy: true, alias: ['code', 'keyword'] }, 'url': { // [example](http://example.com "Optional title") // [example][id] // [example] [id] pattern: createInline(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source), lookbehind: true, greedy: true, inside: { 'operator': /^!/, 'content': { pattern: /(^\[)[^\]]+(?=\])/, lookbehind: true, inside: {} // see below }, 'variable': { pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, lookbehind: true }, 'url': { pattern: /(^\]\()[^\s)]+/, lookbehind: true }, 'string': { pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, lookbehind: true } } } }); ['url', 'bold', 'italic', 'strike'].forEach(function (token) { ['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach(function (inside) { if (token !== inside) { Prism.languages.markdown[token].inside.content.inside[inside] = Prism.languages.markdown[inside]; } }); }); Prism.hooks.add('after-tokenize', function (env) { if (env.language !== 'markdown' && env.language !== 'md') { return; } function walkTokens(tokens) { if (!tokens || typeof tokens === 'string') { return; } for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; if (token.type !== 'code') { walkTokens(token.content); continue; } /* * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token * is optional. But the grammar is defined so that there is only one case we have to handle: * * token.content = [ * <span class="punctuation">```</span>, * <span class="code-language">xxxx</span>, * '\n', // exactly one new lines (\r or \n or \r\n) * <span class="code-block">...</span>, * '\n', // exactly one new lines again * <span class="punctuation">```</span> * ]; */ var codeLang = token.content[1]; var codeBlock = token.content[3]; if (codeLang && codeBlock && codeLang.type === 'code-language' && codeBlock.type === 'code-block' && typeof codeLang.content === 'string') { // this might be a language that Prism does not support // do some replacements to support C++, C#, and F# var lang = codeLang.content.replace(/\b#/g, 'sharp').replace(/\b\+\+/g, 'pp'); // only use the first word lang = (/[a-z][\w-]*/i.exec(lang) || [''])[0].toLowerCase(); var alias = 'language-' + lang; // add alias if (!codeBlock.alias) { codeBlock.alias = [alias]; } else if (typeof codeBlock.alias === 'string') { codeBlock.alias = [codeBlock.alias, alias]; } else { codeBlock.alias.push(alias); } } } } walkTokens(env.tokens); }); Prism.hooks.add('wrap', function (env) { if (env.type !== 'code-block') { return; } var codeLang = ''; for (var i = 0, l = env.classes.length; i < l; i++) { var cls = env.classes[i]; var match = /language-(.+)/.exec(cls); if (match) { codeLang = match[1]; break; } } var grammar = Prism.languages[codeLang]; if (!grammar) { if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) { var id = 'md-' + new Date().valueOf() + '-' + Math.floor(Math.random() * 1e16); env.attributes['id'] = id; Prism.plugins.autoloader.loadLanguages(codeLang, function () { var ele = document.getElementById(id); if (ele) { ele.innerHTML = Prism.highlight(ele.textContent, Prism.languages[codeLang], codeLang); } }); } } else { env.content = Prism.highlight(textContent(env.content), grammar, codeLang); } }); var tagPattern = RegExp(Prism.languages.markup.tag.pattern.source, 'gi'); /** * A list of known entity names. * * This will always be incomplete to save space. The current list is the one used by lowdash's unescape function. * * @see {@link https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/unescape.js#L2} */ var KNOWN_ENTITY_NAMES = { 'amp': '&', 'lt': '<', 'gt': '>', 'quot': '"', }; // IE 11 doesn't support `String.fromCodePoint` var fromCodePoint = String.fromCodePoint || String.fromCharCode; /** * Returns the text content of a given HTML source code string. * * @param {string} html * @returns {string} */ function textContent(html) { // remove all tags var text = html.replace(tagPattern, ''); // decode known entities text = text.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function (m, code) { code = code.toLowerCase(); if (code[0] === '#') { var value; if (code[1] === 'x') { value = parseInt(code.slice(2), 16); } else { value = Number(code.slice(1)); } return fromCodePoint(value); } else { var known = KNOWN_ENTITY_NAMES[code]; if (known) { return known; } // unable to decode return m; } }); return text; } Prism.languages.md = Prism.languages.markdown; }(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(?:NaN|break|case|catch|continue|else|elseif|end|for|function|if|inf|otherwise|parfor|pause|pi|return|switch|try|while)\b/, 'function': /\b(?!\d)\w+(?=\s*\()/, 'operator': /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/, 'punctuation': /\.{3}|[.,;\[\](){}!]/ }; (function (Prism) { var variable = /\$(?:\w[a-z\d]*(?:_[^\x00-\x1F\s"'\\()$]*)?|\{[^}\s"'\\]+\})/i; Prism.languages.nginx = { 'comment': { pattern: /(^|[\s{};])#.*/, lookbehind: true, greedy: true }, 'directive': { pattern: /(^|\s)\w(?:[^;{}"'\\\s]|\\.|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\s+(?:#.*(?!.)|(?![#\s])))*?(?=\s*[;{])/, lookbehind: true, greedy: true, inside: { 'string': { pattern: /((?:^|[^\\])(?:\\\\)*)(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/, lookbehind: true, greedy: true, inside: { 'escape': { pattern: /\\["'\\nrt]/, alias: 'entity' }, 'variable': variable } }, 'comment': { pattern: /(\s)#.*/, lookbehind: true, greedy: true }, 'keyword': { pattern: /^\S+/, greedy: true }, // other patterns 'boolean': { pattern: /(\s)(?:off|on)(?!\S)/, lookbehind: true }, 'number': { pattern: /(\s)\d+[a-z]*(?!\S)/i, lookbehind: true }, 'variable': variable } }, 'punctuation': /[{};]/ }; }(Prism)); Prism.languages.nim = { 'comment': { pattern: /#.*/, greedy: true }, 'string': { // Double-quoted strings can be prefixed by an identifier (Generalized raw string literals) pattern: /(?:\b(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+)?(?:"""[\s\S]*?"""(?!")|"(?:\\[\s\S]|""|[^"\\])*")/, greedy: true }, 'char': { // Character literals are handled specifically to prevent issues with numeric type suffixes pattern: /'(?:\\(?:\d+|x[\da-fA-F]{0,2}|.)|[^'])'/, greedy: true }, 'function': { pattern: /(?:(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+|`[^`\r\n]+`)\*?(?:\[[^\]]+\])?(?=\s*\()/, greedy: true, inside: { 'operator': /\*$/ } }, // We don't want to highlight operators (and anything really) inside backticks 'identifier': { pattern: /`[^`\r\n]+`/, greedy: true, inside: { 'punctuation': /`/ } }, // 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/, '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|in|is|isnot|mod|not|notin|of|or|shl|shr|xor)\b)/m, lookbehind: true }, 'punctuation': /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/ }; Prism.languages.nix = { 'comment': { pattern: /\/\*[\s\S]*?\*\/|#.*/, greedy: true }, 'string': { pattern: /"(?:[^"\\]|\\[\s\S])*"|''(?:(?!'')[\s\S]|''(?:'|\\|\$\{))*''/, greedy: true, inside: { 'interpolation': { // The lookbehind ensures the ${} is not preceded by \ or '' pattern: /(^|(?:^|(?!'').)[^\\])\$\{(?:[^{}]|\{[^}]*\})*\}/, lookbehind: true, inside: null // see below } } }, 'url': [ /\b(?:[a-z]{3,7}:\/\/)[\w\-+%~\/.:#=?&]+/, { pattern: /([^\/])(?:[\w\-+%~.:#=?&]*(?!\/\/)[\w\-+%~\/.:#=?&])?(?!\/\/)\/[\w\-+%~\/.:#=?&]*/, lookbehind: true } ], 'antiquotation': { pattern: /\$(?=\{)/, alias: 'important' }, 'number': /\b\d+\b/, 'keyword': /\b(?:assert|builtins|else|if|in|inherit|let|null|or|then|with)\b/, 'function': /\b(?:abort|add|all|any|attrNames|attrValues|baseNameOf|compareVersions|concatLists|currentSystem|deepSeq|derivation|dirOf|div|elem(?:At)?|fetch(?:Tarball|url)|filter(?:Source)?|fromJSON|genList|getAttr|getEnv|hasAttr|hashString|head|import|intersectAttrs|is(?:Attrs|Bool|Function|Int|List|Null|String)|length|lessThan|listToAttrs|map|mul|parseDrvName|pathExists|read(?:Dir|File)|removeAttrs|replaceStrings|seq|sort|stringLength|sub(?:string)?|tail|throw|to(?:File|JSON|Path|String|XML)|trace|typeOf)\b|\bfoldl'\B/, 'boolean': /\b(?:false|true)\b/, 'operator': /[=!<>]=?|\+\+?|\|\||&&|\/\/|->?|[?@]/, 'punctuation': /[{}()[\].,:;]/ }; Prism.languages.nix.string.inside.interpolation.inside = Prism.languages.nix; // https://ocaml.org/manual/lex.html Prism.languages.ocaml = { 'comment': { pattern: /\(\*[\s\S]*?\*\)/, greedy: true }, 'char': { pattern: /'(?:[^\\\r\n']|\\(?:.|[ox]?[0-9a-f]{1,3}))'/i, greedy: true }, 'string': [ { pattern: /"(?:\\(?:[\s\S]|\r\n)|[^\\\r\n"])*"/, greedy: true }, { pattern: /\{([a-z_]*)\|[\s\S]*?\|\1\}/, greedy: true } ], 'number': [ // binary and octal /\b(?:0b[01][01_]*|0o[0-7][0-7_]*)\b/i, // hexadecimal /\b0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]*)?(?:p[+-]?\d[\d_]*)?(?!\w)/i, // decimal /\b\d[\d_]*(?:\.[\d_]*)?(?:e[+-]?\d[\d_]*)?(?!\w)/i, ], 'directive': { pattern: /\B#\w+/, alias: 'property' }, 'label': { pattern: /\B~\w+/, alias: 'property' }, 'type-variable': { pattern: /\B'\w+/, alias: 'function' }, 'variant': { pattern: /`\w+/, alias: 'symbol' }, // For the list of keywords and operators, // see: http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#sec84 'keyword': /\b(?:as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|value|virtual|when|where|while|with)\b/, 'boolean': /\b(?:false|true)\b/, 'operator-like-punctuation': { pattern: /\[[<>|]|[>|]\]|\{<|>\}/, alias: 'punctuation' }, // Custom operators are allowed 'operator': /\.[.~]|:[=>]|[=<>@^|&+\-*\/$%!?~][!$%&*+\-.\/:<=>?@^|~]*|\b(?:and|asr|land|lor|lsl|lsr|lxor|mod|or)\b/, 'punctuation': /;;|::|[(){}\[\].,:;#]|\b_\b/ }; (function (Prism) { var brackets = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source; Prism.languages.perl = { 'comment': [ { // POD pattern: /(^\s*)=\w[\s\S]*?=cut.*/m, lookbehind: true, greedy: true }, { pattern: /(^|[^\\$])#.*/, lookbehind: true, greedy: true } ], // TODO Could be nice to handle Heredoc too. 'string': [ { pattern: RegExp( /\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + '(?:' + [ // q/.../ /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source, // q a...a // eslint-disable-next-line regexp/strict /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source, // q(...) // q{...} // q[...] // q<...> brackets, ].join('|') + ')' ), 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': [ { pattern: RegExp( /\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + '(?:' + [ // m/.../ /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source, // m a...a // eslint-disable-next-line regexp/strict /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source, // m(...) // m{...} // m[...] // m<...> brackets, ].join('|') + ')' + /[msixpodualngc]*/.source ), greedy: true }, // The lookbehinds prevent -s from breaking { pattern: RegExp( /(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + '(?:' + [ // s/.../.../ // eslint-disable-next-line regexp/strict /([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source, // s a...a...a // eslint-disable-next-line regexp/strict /([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source, // s(...)(...) // s{...}{...} // s[...][...] // s<...><...> // s(...)[...] brackets + /\s*/.source + brackets, ].join('|') + ')' + /[msixpodualngcer]*/.source ), 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,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/, greedy: true } ], // FIXME Not sure about the handling of ::, ', and # 'variable': [ // ${^POSTMATCH} /[&*$@%]\{\^[A-Z]+\}/, // $^V /[&*$@%]\^[A-Z_]/, // ${...} /[&*$@%]#?(?=\{)/, // $foo /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/, // $1 /[&*$@%]\d+/, // $_, @_, %! // The negative lookahead prevents from breaking the %= operator /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/ ], 'filehandle': { // <>, <FOO>, _ pattern: /<(?![<=])\S*?>|\b_\b/, alias: 'symbol' }, 'v-string': { // v1.2, 1.2.3 pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/, alias: 'string' }, 'function': { pattern: /(\bsub[ \t]+)\w+/, lookbehind: true }, '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(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/, 'punctuation': /[{}[\];(),:]/ }; }(Prism)); /** * Original by Aaron Harun: http://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/ * Modified by Miles Johnson: http://milesj.me * Rewritten by Tom Pavelec * * Supports PHP 5.3 - 8.0 */ (function (Prism) { var comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/; var constant = [ { pattern: /\b(?:false|true)\b/i, alias: 'boolean' }, { pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i, greedy: true, lookbehind: true, }, { pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i, greedy: true, lookbehind: true, }, /\b(?:null)\b/i, /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/, ]; var number = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i; var operator = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/; var punctuation = /[{}\[\](),:;]/; Prism.languages.php = { 'delimiter': { pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i, alias: 'important' }, 'comment': comment, 'variable': /\$+(?:\w+\b|(?=\{))/, 'package': { pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, lookbehind: true, inside: { 'punctuation': /\\/ } }, 'class-name-definition': { pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i, lookbehind: true, alias: 'class-name' }, 'function-definition': { pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i, lookbehind: true, alias: 'function' }, 'keyword': [ { pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i, alias: 'type-casting', greedy: true, lookbehind: true }, { pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i, alias: 'type-hint', greedy: true, lookbehind: true }, { pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i, alias: 'return-type', greedy: true, lookbehind: true }, { pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i, alias: 'type-declaration', greedy: true }, { pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i, alias: 'type-declaration', greedy: true, lookbehind: true }, { pattern: /\b(?:parent|self|static)(?=\s*::)/i, alias: 'static-context', greedy: true }, { // yield from pattern: /(\byield\s+)from\b/i, lookbehind: true }, // `class` is always a keyword unlike other keywords /\bclass\b/i, { // https://www.php.net/manual/en/reserved.keywords.php // // keywords cannot be preceded by "->" // the complex lookbehind means `(?<!(?:->|::)\s*)` pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i, lookbehind: true } ], 'argument-name': { pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i, lookbehind: true }, 'class-name': [ { pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i, greedy: true, lookbehind: true }, { pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i, greedy: true, lookbehind: true }, { pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i, greedy: true }, { pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i, alias: 'class-name-fully-qualified', greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } }, { pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i, alias: 'class-name-fully-qualified', greedy: true, inside: { 'punctuation': /\\/ } }, { pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, alias: 'class-name-fully-qualified', greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } }, { pattern: /\b[a-z_]\w*(?=\s*\$)/i, alias: 'type-declaration', greedy: true }, { pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i, alias: ['class-name-fully-qualified', 'type-declaration'], greedy: true, inside: { 'punctuation': /\\/ } }, { pattern: /\b[a-z_]\w*(?=\s*::)/i, alias: 'static-context', greedy: true }, { pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i, alias: ['class-name-fully-qualified', 'static-context'], greedy: true, inside: { 'punctuation': /\\/ } }, { pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i, alias: 'type-hint', greedy: true, lookbehind: true }, { pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i, alias: ['class-name-fully-qualified', 'type-hint'], greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } }, { pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i, alias: 'return-type', greedy: true, lookbehind: true }, { pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, alias: ['class-name-fully-qualified', 'return-type'], greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } } ], 'constant': constant, 'function': { pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i, lookbehind: true, inside: { 'punctuation': /\\/ } }, 'property': { pattern: /(->\s*)\w+/, lookbehind: true }, 'number': number, 'operator': operator, 'punctuation': punctuation }; var string_interpolation = { pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/, lookbehind: true, inside: Prism.languages.php }; var string = [ { pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/, alias: 'nowdoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<<'[^']+'|[a-z_]\w*;$/i, alias: 'symbol', inside: { 'punctuation': /^<<<'?|[';]$/ } } } }, { pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i, alias: 'heredoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i, alias: 'symbol', inside: { 'punctuation': /^<<<"?|[";]$/ } }, 'interpolation': string_interpolation } }, { pattern: /`(?:\\[\s\S]|[^\\`])*`/, alias: 'backtick-quoted-string', greedy: true }, { pattern: /'(?:\\[\s\S]|[^\\'])*'/, alias: 'single-quoted-string', greedy: true }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, alias: 'double-quoted-string', greedy: true, inside: { 'interpolation': string_interpolation } } ]; Prism.languages.insertBefore('php', 'variable', { 'string': string, 'attribute': { pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im, greedy: true, inside: { 'attribute-content': { pattern: /^(#\[)[\s\S]+(?=\]$)/, lookbehind: true, // inside can appear subset of php inside: { 'comment': comment, 'string': string, 'attribute-class-name': [ { pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i, alias: 'class-name', greedy: true, lookbehind: true }, { pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i, alias: [ 'class-name', 'class-name-fully-qualified' ], greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } } ], 'constant': constant, 'number': number, 'operator': operator, 'punctuation': punctuation } }, 'delimiter': { pattern: /^#\[|\]$/, alias: 'punctuation' } } }, }); Prism.hooks.add('before-tokenize', function (env) { if (!/<\?/.test(env.code)) { return; } var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g; 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.python = { 'comment': { pattern: /(^|[^\\])#.*/, lookbehind: true, greedy: true }, 'string-interpolation': { pattern: /(?:f|fr|rf)(?:("""|''')[\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]|br|rb)?("""|''')[\s\S]*?\1/i, greedy: true, alias: 'string' }, 'string': { pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\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: /(^[\t ]*)@\w+(?:\.\w+)*/m, lookbehind: true, alias: ['annotation', 'punctuation'], inside: { 'punctuation': /\./ } }, 'keyword': /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|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(?:False|None|True)\b/, 'number': /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i, 'operator': /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/, 'punctuation': /[{}[\];(),.:]/ }; Prism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python; Prism.languages.py = Prism.languages.python; (function (Prism) { var jsString = /"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*'/.source; var jsComment = /\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))*\*\//.source; var jsExpr = /(?:[^\\()[\]{}"'/]|<string>|\/(?![*/])|<comment>|\(<expr>*\)|\[<expr>*\]|\{<expr>*\}|\\[\s\S])/ .source.replace(/<string>/g, function () { return jsString; }).replace(/<comment>/g, function () { return jsComment; }); // the pattern will blow up, so only a few iterations for (var i = 0; i < 2; i++) { jsExpr = jsExpr.replace(/<expr>/g, function () { return jsExpr; }); } jsExpr = jsExpr.replace(/<expr>/g, '[^\\s\\S]'); Prism.languages.qml = { 'comment': { pattern: /\/\/.*|\/\*[\s\S]*?\*\//, greedy: true }, 'javascript-function': { pattern: RegExp(/((?:^|;)[ \t]*)function\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*\(<js>*\)\s*\{<js>*\}/.source.replace(/<js>/g, function () { return jsExpr; }), 'm'), lookbehind: true, greedy: true, alias: 'language-javascript', inside: Prism.languages.javascript }, 'class-name': { pattern: /((?:^|[:;])[ \t]*)(?!\d)\w+(?=[ \t]*\{|[ \t]+on\b)/m, lookbehind: true }, 'property': [ { pattern: /((?:^|[;{])[ \t]*)(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m, lookbehind: true }, { pattern: /((?:^|[;{])[ \t]*)property[ \t]+(?!\d)\w+(?:\.\w+)*[ \t]+(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m, lookbehind: true, inside: { 'keyword': /^property/, 'property': /\w+(?:\.\w+)*/ } } ], 'javascript-expression': { pattern: RegExp(/(:[ \t]*)(?![\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(/<js>/g, function () { return jsExpr; }), 'm'), lookbehind: true, greedy: true, alias: 'language-javascript', inside: Prism.languages.javascript }, 'string': { pattern: /"(?:\\.|[^\\"\r\n])*"/, greedy: true }, 'keyword': /\b(?:as|import|on)\b/, 'punctuation': /[{}[\]:;,]/ }; }(Prism)); Prism.languages.r = { 'comment': /#.*/, 'string': { pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/, greedy: true }, 'percent-operator': { // Includes user-defined operators // and %%, %*%, %/%, %in%, %o%, %x% pattern: /%[^%\s]*%/, alias: 'operator' }, 'boolean': /\b(?:FALSE|TRUE)\b/, 'ellipsis': /\.\.(?:\.|\d+)/, 'number': [ /\b(?:Inf|NaN)\b/, /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/ ], 'keyword': /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/, 'operator': /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/, 'punctuation': /[(){}\[\],;]/ }; (function (Prism) { var javascript = Prism.util.clone(Prism.languages.javascript); var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source; var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source; var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source; /** * @param {string} source * @param {string} [flags] */ function re(source, flags) { source = source .replace(/<S>/g, function () { return space; }) .replace(/<BRACES>/g, function () { return braces; }) .replace(/<SPREAD>/g, function () { return spread; }); return RegExp(source, flags); } spread = re(spread).source; Prism.languages.jsx = Prism.languages.extend('markup', javascript); Prism.languages.jsx.tag.pattern = re( /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source ); Prism.languages.jsx.tag.inside['tag'].pattern = /^<\/?[^\s>\/]*/; Prism.languages.jsx.tag.inside['attr-value'].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/; Prism.languages.jsx.tag.inside['tag'].inside['class-name'] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/; Prism.languages.jsx.tag.inside['comment'] = javascript['comment']; Prism.languages.insertBefore('inside', 'attr-name', { 'spread': { pattern: re(/<SPREAD>/.source), inside: Prism.languages.jsx } }, Prism.languages.jsx.tag); Prism.languages.insertBefore('inside', 'special-attr', { 'script': { // Allow for two levels of nesting pattern: re(/=<BRACES>/.source), alias: 'language-javascript', inside: { 'script-punctuation': { pattern: /^=(?=\{)/, alias: 'punctuation' }, rest: Prism.languages.jsx }, } }, 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); }); }(Prism)); (function (Prism) { var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source; for (var i = 0; i < 2; i++) { // support 4 levels of nested comments multilineComment = multilineComment.replace(/<self>/g, function () { return multilineComment; }); } multilineComment = multilineComment.replace(/<self>/g, function () { return /[^\s\S]/.source; }); Prism.languages.rust = { 'comment': [ { pattern: RegExp(/(^|[^\\])/.source + multilineComment), lookbehind: true, greedy: true }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: true, greedy: true } ], 'string': { pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/, greedy: true }, 'char': { pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/, greedy: true }, 'attribute': { pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/, greedy: true, alias: 'attr-name', inside: { 'string': null // see below } }, // Closure params should not be confused with bitwise OR | 'closure-params': { pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/, lookbehind: true, greedy: true, inside: { 'closure-punctuation': { pattern: /^\||\|$/, alias: 'punctuation' }, rest: null // see below } }, 'lifetime-annotation': { pattern: /'\w+/, alias: 'symbol' }, 'fragment-specifier': { pattern: /(\$\w+:)[a-z]+/, lookbehind: true, alias: 'punctuation' }, 'variable': /\$\w+/, 'function-definition': { pattern: /(\bfn\s+)\w+/, lookbehind: true, alias: 'function' }, 'type-definition': { pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/, lookbehind: true, alias: 'class-name' }, 'module-declaration': [ { pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/, lookbehind: true, alias: 'namespace' }, { pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/, lookbehind: true, alias: 'namespace', inside: { 'punctuation': /::/ } } ], 'keyword': [ // https://github.com/rust-lang/reference/blob/master/src/keywords.md /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, // primitives and str // https://doc.rust-lang.org/stable/rust-by-example/primitives.html /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/ ], // functions can technically start with an upper-case letter, but this will introduce a lot of false positives // and Rust's naming conventions recommend snake_case anyway. // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html 'function': /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/, 'macro': { pattern: /\b\w+!/, alias: 'property' }, 'constant': /\b[A-Z_][A-Z_\d]+\b/, 'class-name': /\b[A-Z]\w*\b/, 'namespace': { pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/, inside: { 'punctuation': /::/ } }, // 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+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/, 'boolean': /\b(?:false|true)\b/, 'punctuation': /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/, 'operator': /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/ }; Prism.languages.rust['closure-params'].inside.rest = Prism.languages.rust; Prism.languages.rust['attribute'].inside['string'] = Prism.languages.rust['string']; }(Prism)); Prism.languages.scss = Prism.languages.extend('css', { 'comment': { pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/, lookbehind: true }, 'atrule': { pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\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)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/, 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': [ /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i, { pattern: /( )(?:from|through)(?= )/, lookbehind: true } ] }); Prism.languages.insertBefore('scss', 'important', { // var and interpolated vars 'variable': /\$[-\w]+|#\{\$[-\w]+\}/ }); Prism.languages.insertBefore('scss', 'function', { 'module-modifier': { pattern: /\b(?:as|hide|show|with)\b/i, alias: 'keyword' }, 'placeholder': { pattern: /%[-\w]+/, alias: 'selector' }, 'statement': { pattern: /\B!(?:default|optional)\b/i, alias: 'keyword' }, 'boolean': /\b(?:false|true)\b/, 'null': { pattern: /\bnull\b/, alias: 'keyword' }, 'operator': { pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/, lookbehind: true } }); Prism.languages.scss['atrule'].inside.rest = Prism.languages.scss; Prism.languages.scala = Prism.languages.extend('java', { 'triple-quoted-string': { pattern: /"""[\s\S]*?"""/, greedy: true, alias: 'string' }, 'string': { pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/, greedy: true }, 'keyword': /<-|=>|\b(?:abstract|case|catch|class|def|derives|do|else|enum|extends|extension|final|finally|for|forSome|given|if|implicit|import|infix|inline|lazy|match|new|null|object|opaque|open|override|package|private|protected|return|sealed|self|super|this|throw|trait|transparent|try|type|using|val|var|while|with|yield)\b/, 'number': /\b0x(?:[\da-f]*\.)?[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e\d+)?[dfl]?/i, 'builtin': /\b(?:Any|AnyRef|AnyVal|Boolean|Byte|Char|Double|Float|Int|Long|Nothing|Short|String|Unit)\b/, 'symbol': /'[^\d\s\\]\w*/ }); Prism.languages.insertBefore('scala', 'triple-quoted-string', { 'string-interpolation': { pattern: /\b[a-z]\w*(?:"""(?:[^$]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*?"""|"(?:[^$"\r\n]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*")/i, greedy: true, inside: { 'id': { pattern: /^\w+/, greedy: true, alias: 'function' }, 'escape': { pattern: /\\\$"|\$[$"]/, greedy: true, alias: 'symbol' }, 'interpolation': { pattern: /\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/, greedy: true, inside: { 'punctuation': /^\$\{?|\}$/, 'expression': { pattern: /[\s\S]+/, inside: Prism.languages.scala } } }, 'string': /[\s\S]+/ } } }); delete Prism.languages.scala['class-name']; delete Prism.languages.scala['function']; delete Prism.languages.scala['constant']; (function (Prism) { // CAREFUL! // The following patterns are concatenated, so the group referenced by a back reference is non-obvious! var strings = [ // normal string /"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source, /'[^']*'/.source, /\$'(?:[^'\\]|\\[\s\S])*'/.source, // here doc // 2 capturing groups /<<-?\s*(["']?)(\w+)\1\s[\s\S]*?[\r\n]\2/.source ].join('|'); Prism.languages['shell-session'] = { 'command': { pattern: RegExp( // user info /^/.source + '(?:' + ( // <user> ":" ( <path> )? /[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+(?::[^\0-\x1F$#%*?"<>:;|]+)?/.source + '|' + // <path> // Since the path pattern is quite general, we will require it to start with a special character to // prevent false positives. /[/~.][^\0-\x1F$#%*?"<>@:;|]*/.source ) + ')?' + // shell symbol /[$#%](?=\s)/.source + // bash command /(?:[^\\\r\n \t'"<$]|[ \t](?:(?!#)|#.*$)|\\(?:[^\r]|\r\n?)|\$(?!')|<(?!<)|<<str>>)+/.source.replace(/<<str>>/g, function () { return strings; }), 'm' ), greedy: true, inside: { 'info': { // foo@bar:~/files$ exit // foo@bar$ exit // ~/files$ exit pattern: /^[^#$%]+/, alias: 'punctuation', inside: { 'user': /^[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+/, 'punctuation': /:/, 'path': /[\s\S]+/ } }, 'bash': { pattern: /(^[$#%]\s*)\S[\s\S]*/, lookbehind: true, alias: 'language-bash', inside: Prism.languages.bash }, 'shell-symbol': { pattern: /^[$#%]/, alias: 'important' } } }, 'output': /.(?:.*(?:[\r\n]|.$))*/ }; Prism.languages['sh-session'] = Prism.languages['shellsession'] = Prism.languages['shell-session']; }(Prism)); 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 }, 'identifier': { pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/, greedy: true, lookbehind: true, inside: { 'punctuation': /^`|`$/ } }, '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(?:COL|_INSERT)?|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|RETURN(?:ING|S)?|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(?:FALSE|NULL|TRUE)\b/i, 'number': /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i, 'operator': /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i, 'punctuation': /[;[\]()`,.]/ }; (function (Prism) { Prism.languages.typescript = Prism.languages.extend('javascript', { 'class-name': { pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/, lookbehind: true, greedy: true, inside: null // see below }, 'builtin': /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/, }); // The keywords TypeScript adds to JavaScript Prism.languages.typescript.keyword.push( /\b(?:abstract|declare|is|keyof|readonly|require)\b/, // keywords that have to be followed by an identifier /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, // This is for `import type *, {}` /\btype\b(?=\s*(?:[\{*]|$))/ ); // doesn't work with TS because TS is too complex delete Prism.languages.typescript['parameter']; delete Prism.languages.typescript['literal-property']; // a version of typescript specifically for highlighting types var typeInside = Prism.languages.extend('typescript', {}); delete typeInside['class-name']; Prism.languages.typescript['class-name'].inside = typeInside; Prism.languages.insertBefore('typescript', 'function', { 'decorator': { pattern: /@[$\w\xA0-\uFFFF]+/, inside: { 'at': { pattern: /^@/, alias: 'operator' }, 'function': /^[\s\S]+/ } }, 'generic-function': { // e.g. foo<T extends "bar" | "baz">( ... pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/, greedy: true, inside: { 'function': /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/, 'generic': { pattern: /<[\s\S]+/, // everything after the first < alias: 'class-name', inside: typeInside } } } }); Prism.languages.ts = Prism.languages.typescript; }(Prism)); (function (Prism) { // https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property // https://yaml.org/spec/1.2/spec.html#c-ns-alias-node var anchorOrAlias = /[*&][^\s[\]{},]+/; // https://yaml.org/spec/1.2/spec.html#c-ns-tag-property var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/; // https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c) var properties = '(?:' + tag.source + '(?:[ \t]+' + anchorOrAlias.source + ')?|' + anchorOrAlias.source + '(?:[ \t]+' + tag.source + ')?)'; // https://yaml.org/spec/1.2/spec.html#ns-plain(n,c) // This is a simplified version that doesn't support "#" and multiline keys // All these long scarry character classes are simplified versions of YAML's characters var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source .replace(/<PLAIN>/g, function () { return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source; }); var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source; /** * * @param {string} value * @param {string} [flags] * @returns {RegExp} */ function createValuePattern(value, flags) { flags = (flags || '').replace(/m/g, '') + 'm'; // add m flag var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source .replace(/<<prop>>/g, function () { return properties; }).replace(/<<value>>/g, function () { return value; }); return RegExp(pattern, flags); } Prism.languages.yaml = { 'scalar': { pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source .replace(/<<prop>>/g, function () { return properties; })), lookbehind: true, alias: 'string' }, 'comment': /#.*/, 'key': { pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source .replace(/<<prop>>/g, function () { return properties; }) .replace(/<<key>>/g, function () { return '(?:' + plainKey + '|' + string + ')'; })), lookbehind: true, greedy: true, alias: 'atrule' }, 'directive': { pattern: /(^[ \t]*)%.+/m, lookbehind: true, alias: 'important' }, 'datetime': { pattern: createValuePattern(/\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*)?)?/.source), lookbehind: true, alias: 'number' }, 'boolean': { pattern: createValuePattern(/false|true/.source, 'i'), lookbehind: true, alias: 'important' }, 'null': { pattern: createValuePattern(/null|~/.source, 'i'), lookbehind: true, alias: 'important' }, 'string': { pattern: createValuePattern(string), lookbehind: true, greedy: true }, 'number': { pattern: createValuePattern(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, 'i'), lookbehind: true }, 'tag': tag, 'important': anchorOrAlias, 'punctuation': /---|[:[\]{}\-,|>?]|\.\.\./ }; Prism.languages.yml = Prism.languages.yaml; }(Prism)); (function (Prism) { function literal(str) { return function () { return str; }; } var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/; var IDENTIFIER = '\\b(?!' + keyword.source + ')(?!\\d)\\w+\\b'; var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source; var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(/<ALIGN>/g, literal(ALIGN)); var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(/<ID>/g, literal(IDENTIFIER)); var TYPE = '(?!\\s)(?:!?\\s*(?:' + PREFIX_TYPE_OP + '\\s*)*' + SUFFIX_EXPR + ')+'; /* * A simplified grammar for Zig compile time type literals: * * TypeExpr = ( "!"? PREFIX_TYPE_OP* SUFFIX_EXPR )+ * * SUFFIX_EXPR = ( \b "promise" \b | ( \b "error" "." )? IDENTIFIER ( "." IDENTIFIER )* (?! \s+ IDENTIFIER ) ) * * PREFIX_TYPE_OP = "?" * | \b "promise" "->" * | ( "[" [^\[\]]* "]" | "*" | "**" ) ( ALIGN | "const" \b | "volatile" \b | "allowzero" \b )* * * ALIGN = "align" "(" ( [^()] | "(" [^()]* ")" )* ")" * * IDENTIFIER = \b (?! KEYWORD ) [a-zA-Z_] \w* \b * */ Prism.languages.zig = { 'comment': [ { pattern: /\/\/[/!].*/, alias: 'doc-comment' }, /\/{2}.*/ ], 'string': [ { // "string" and c"string" pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/, lookbehind: true, greedy: true }, { // multiline strings and c-strings pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/, lookbehind: true, greedy: true } ], 'char': { // characters 'a', '\n', '\xFF', '\u{10FFFF}' pattern: /(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/, lookbehind: true, greedy: true }, 'builtin': /\B@(?!\d)\w+(?=\s*\()/, 'label': { pattern: /(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/, lookbehind: true }, 'class-name': [ // const Foo = struct {}; /\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/, { // const x: i32 = 9; // var x: Bar; // fn foo(x: bool, y: f32) void {} pattern: RegExp(/(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))), lookbehind: true, inside: null // see below }, { // extern fn foo(x: f64) f64; (optional alignment) pattern: RegExp(/(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))), lookbehind: true, inside: null // see below } ], 'builtin-type': { pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/, alias: 'keyword' }, 'keyword': keyword, 'function': /\b(?!\d)\w+(?=\s*\()/, 'number': /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/, 'boolean': /\b(?:false|true)\b/, 'operator': /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/, 'punctuation': /[.:,;(){}[\]]/ }; Prism.languages.zig['class-name'].forEach(function (obj) { if (obj.inside === null) { obj.inside = Prism.languages.zig; } }); }(Prism));