diff --git a/assets/javascripts/vendor/prism.js b/assets/javascripts/vendor/prism.js
index d2d5f31d..1c8591ae 100644
--- a/assets/javascripts/vendor/prism.js
+++ b/assets/javascripts/vendor/prism.js
@@ -1,5 +1,5 @@
/* 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+markup-templating+matlab+nginx+nim+nix+ocaml+perl+php+python+qml+r+jsx+ruby+rust+scss+scala+shell-session+sql+typescript+yaml+zig */
+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 */
///
var _self = (typeof window !== 'undefined')
@@ -3532,6 +3532,422 @@ Prism.languages.lua = {
'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(//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]: "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__(?:(?!_)|_(?:(?!_))+_)+__\b|\*\*(?:(?!\*)|\*(?:(?!\*))+\*)+\*\*/.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_(?:(?!_)|__(?:(?!_))+__)+_\b|\*(?:(?!\*)|\*\*(?:(?!\*))+\*\*)+\*/.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(/(~~?)(?:(?!~))+\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(/!?\[(?:(?!\]))+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\]))+\])/.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 = [
+ * ```,
+ * xxxx,
+ * '\n', // exactly one new lines (\r or \n or \r\n)
+ * ...,
+ * '\n', // exactly one new lines again
+ * ```
+ * ];
+ */
+
+ 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]*?\}%/,
diff --git a/lib/docs/filters/markdown/clean_html.rb b/lib/docs/filters/markdown/clean_html.rb
index 84fcb901..cc329b92 100644
--- a/lib/docs/filters/markdown/clean_html.rb
+++ b/lib/docs/filters/markdown/clean_html.rb
@@ -7,6 +7,7 @@ module Docs
css('#ProjectSubmenu', 'hr').remove
css('pre > code').each do |node|
+ node.parent['data-language'] = 'markdown'
node.before(node.children).remove
end