23-fac2136c8f7f5d3ef632.js.map

{"version":3,"sources":["webpack:https:///../node_modules/prism-react-renderer/prism/index.js","webpack:https:///../node_modules/prism-react-renderer/themes/duotoneDark/index.js","webpack:https:///../node_modules/prism-react-renderer/dist/index.js","webpack:https:///../node_modules/@theme-ui/prism/dist/prism.esm.js"],"names":["uniqueId","_","Token","Prism","util","encode","tokens","type","content","alias","map","replace","o","Object","prototype","toString","call","match","objId","obj","defineProperty","value","clone","visited","key","hasOwnProperty","forEach","v","i","languages","extend","id","redef","lang","insertBefore","inside","before","insert","root","grammar","arguments","length","newToken","ret","token","DFS","this","callback","plugins","highlight","text","language","env","code","tokenize","stringify","matchGrammar","strarr","index","startPos","oneshot","target","patterns","j","pattern","lookbehind","greedy","lookbehindLength","global","flags","RegExp","source","pos","str","lastIndex","exec","from","to","k","p","len","delNum","slice","after","args","push","wrapped","Array","splice","apply","hooks","add","rest","matchedStr","parent","element","join","tag","classes","attributes","aliases","keys","name","markup","tagName","includedCdataInside","def","xml","html","mathml","svg","envVars","insideString","bash","variable","toBeCopied","shell","clike","punctuation","c","cpp","string","css","addInlined","selector","javascript","js","jsx","stringifyToken","walkTokens","openedTags","notTagNorBrace","pop","openedBraces","plainText","javaDocLike","javadoclike","docLanguage","definition","isArray","l","docCommentSupport","addSupport","keywords","className","java","function","getPlaceholder","toUpperCase","defineProperties","buildPlaceholders","placeholderPattern","replaceFilter","tokenStack","placeholder","indexOf","tokenizePlaceholders","t","s","substring","middle","replacement","concat","php","string_interpolation","test","parameterPrefix","jsdoc","actionscript","comment","interpolation","coffeescript","coffee","unshift","maybeClassNameTokens","flow","keyword","n4js","n4jsd","typescript","ts","templateString","templateLiteralPattern","interpolationObject","interpolationPunctuationObject","interpolationPattern","createTemplate","counter","tokenizeWithHooks","run","tokenizeInterpolationExpression","expression","tempGrammar","tokenizeEmbedded","_tokens","placeholderCounter","placeholderMap","embeddedTokens","interpolationExpression","placeholders","afterTokens","filter","Boolean","supportedLanguages","stringContent","findTemplateStrings","embedded","graphql","inner","createInline","starAlternative","tableCell","tableRow","tableLine","markdown","codeLang","codeBlock","trim","split","toLowerCase","cls","autoloader","Date","valueOf","Math","floor","random","loadLanguages","ele","document","getElementById","innerHTML","textContent","md","diff","PREFIXES","prefix","git","go","handlebars","json","less","makefile","objectivec","ocaml","python","py","reason","sass","atrule","operator","important","property","scss","sql","stylus","func","tsx","wasm","yaml","yml","plain","backgroundColor","color","styles","types","style","opacity","textDecorationLine","fontStyle","fontWeight","defaultProps","theme","_defineProperty","enumerable","configurable","writable","_extends","assign","newlineRe","normalizeEmptyLines","line","empty","appendTypes","typesSize","themeToDict","base","create","themeDict","reduce","acc","themeEntry","includes","accStyle","objectWithoutProperties","exclude","Component","Highlight","this$1","props","undefined","prevTheme","prevLanguage","ref","output","getThemeDict","display","baseStyle","typeStyles","children","getStyleForToken","__proto__","constructor","render","typeArrStack","tokenArrStack","tokenArrIndexStack","tokenArrSizeStack","stackIndex","currentLine","splitByNewlines","newlineCount","i$1","normalizeTokens","getLineProps","getTokenProps","_objectWithoutProperties","excluded","sourceKeys","_objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","_slicedToArray","arr","_arrayWithHoles","Symbol","iterator","_arr","_n","_d","_e","_s","_i","next","done","err","_iterableToArrayLimit","TypeError","_nonIterableRest","sh","_ref","outerClassName","_ref2","pre","sx"],"mappings":"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","file":"23-fac2136c8f7f5d3ef632.js","sourcesContent":["/**\r\n * Prism: Lightweight, robust, elegant syntax highlighting\r\n * MIT license https://www.opensource.org/licenses/mit-license.php/\r\n * @author Lea Verou https://lea.verou.me\r\n */\n\n/**\r\n * prism-react-renderer:\r\n * This file has been modified to remove:\r\n * - globals and window dependency\r\n * - worker support\r\n * - highlightAll and other element dependent methods\r\n * - _.hooks helpers\r\n * - UMD/node-specific hacks\r\n * It has also been run through prettier\r\n */\nvar Prism = function () {\n  var uniqueId = 0;\n  var _ = {\n    util: {\n      encode: function encode(tokens) {\n        if (tokens instanceof Token) {\n          return new Token(tokens.type, _.util.encode(tokens.content), tokens.alias);\n        } else if (_.util.type(tokens) === \"Array\") {\n          return tokens.map(_.util.encode);\n        } else {\n          return tokens.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/\\u00a0/g, \" \");\n        }\n      },\n      type: function type(o) {\n        return Object.prototype.toString.call(o).match(/\\[object (\\w+)\\]/)[1];\n      },\n      objId: function objId(obj) {\n        if (!obj[\"__id\"]) {\n          Object.defineProperty(obj, \"__id\", {\n            value: ++uniqueId\n          });\n        }\n\n        return obj[\"__id\"];\n      },\n      // Deep clone a language definition (e.g. to extend it)\n      clone: function clone(o, visited) {\n        var type = _.util.type(o);\n\n        visited = visited || {};\n\n        switch (type) {\n          case \"Object\":\n            if (visited[_.util.objId(o)]) {\n              return visited[_.util.objId(o)];\n            }\n\n            var clone = {};\n            visited[_.util.objId(o)] = clone;\n\n            for (var key in o) {\n              if (o.hasOwnProperty(key)) {\n                clone[key] = _.util.clone(o[key], visited);\n              }\n            }\n\n            return clone;\n\n          case \"Array\":\n            if (visited[_.util.objId(o)]) {\n              return visited[_.util.objId(o)];\n            }\n\n            var clone = [];\n            visited[_.util.objId(o)] = clone;\n            o.forEach(function (v, i) {\n              clone[i] = _.util.clone(v, visited);\n            });\n            return clone;\n        }\n\n        return o;\n      }\n    },\n    languages: {\n      extend: function extend(id, redef) {\n        var lang = _.util.clone(_.languages[id]);\n\n        for (var key in redef) {\n          lang[key] = redef[key];\n        }\n\n        return lang;\n      },\n\n      /**\r\n       * Insert a token before another token in a language literal\r\n       * As this needs to recreate the object (we cannot actually insert before keys in object literals),\r\n       * we cannot just provide an object, we need anobject and a key.\r\n       * @param inside The key (or language id) of the parent\r\n       * @param before The key to insert before. If not provided, the function appends instead.\r\n       * @param insert Object with the key/value pairs to insert\r\n       * @param root The object that contains `inside`. If equal to Prism.languages, it can be omitted.\r\n       */\n      insertBefore: function insertBefore(inside, before, insert, root) {\n        root = root || _.languages;\n        var grammar = root[inside];\n\n        if (arguments.length == 2) {\n          insert = arguments[1];\n\n          for (var newToken in insert) {\n            if (insert.hasOwnProperty(newToken)) {\n              grammar[newToken] = insert[newToken];\n            }\n          }\n\n          return grammar;\n        }\n\n        var ret = {};\n\n        for (var token in grammar) {\n          if (grammar.hasOwnProperty(token)) {\n            if (token == before) {\n              for (var newToken in insert) {\n                if (insert.hasOwnProperty(newToken)) {\n                  ret[newToken] = insert[newToken];\n                }\n              }\n            }\n\n            ret[token] = grammar[token];\n          }\n        } // Update references in other language definitions\n\n\n        _.languages.DFS(_.languages, function (key, value) {\n          if (value === root[inside] && key != inside) {\n            this[key] = ret;\n          }\n        });\n\n        return root[inside] = ret;\n      },\n      // Traverse a language definition with Depth First Search\n      DFS: function DFS(o, callback, type, visited) {\n        visited = visited || {};\n\n        for (var i in o) {\n          if (o.hasOwnProperty(i)) {\n            callback.call(o, i, o[i], type || i);\n\n            if (_.util.type(o[i]) === \"Object\" && !visited[_.util.objId(o[i])]) {\n              visited[_.util.objId(o[i])] = true;\n\n              _.languages.DFS(o[i], callback, null, visited);\n            } else if (_.util.type(o[i]) === \"Array\" && !visited[_.util.objId(o[i])]) {\n              visited[_.util.objId(o[i])] = true;\n\n              _.languages.DFS(o[i], callback, i, visited);\n            }\n          }\n        }\n      }\n    },\n    plugins: {},\n    highlight: function highlight(text, grammar, language) {\n      var env = {\n        code: text,\n        grammar: grammar,\n        language: language\n      };\n      env.tokens = _.tokenize(env.code, env.grammar);\n      return Token.stringify(_.util.encode(env.tokens), env.language);\n    },\n    matchGrammar: function matchGrammar(text, strarr, grammar, index, startPos, oneshot, target) {\n      var Token = _.Token;\n\n      for (var token in grammar) {\n        if (!grammar.hasOwnProperty(token) || !grammar[token]) {\n          continue;\n        }\n\n        if (token == target) {\n          return;\n        }\n\n        var patterns = grammar[token];\n        patterns = _.util.type(patterns) === \"Array\" ? patterns : [patterns];\n\n        for (var j = 0; j < patterns.length; ++j) {\n          var pattern = patterns[j],\n              inside = pattern.inside,\n              lookbehind = !!pattern.lookbehind,\n              greedy = !!pattern.greedy,\n              lookbehindLength = 0,\n              alias = pattern.alias;\n\n          if (greedy && !pattern.pattern.global) {\n            // Without the global flag, lastIndex won't work\n            var flags = pattern.pattern.toString().match(/[imuy]*$/)[0];\n            pattern.pattern = RegExp(pattern.pattern.source, flags + \"g\");\n          }\n\n          pattern = pattern.pattern || pattern; // Don’t cache length as it changes during the loop\n\n          for (var i = index, pos = startPos; i < strarr.length; pos += strarr[i].length, ++i) {\n            var str = strarr[i];\n\n            if (strarr.length > text.length) {\n              // Something went terribly wrong, ABORT, ABORT!\n              return;\n            }\n\n            if (str instanceof Token) {\n              continue;\n            }\n\n            if (greedy && i != strarr.length - 1) {\n              pattern.lastIndex = pos;\n              var match = pattern.exec(text);\n\n              if (!match) {\n                break;\n              }\n\n              var from = match.index + (lookbehind ? match[1].length : 0),\n                  to = match.index + match[0].length,\n                  k = i,\n                  p = pos;\n\n              for (var len = strarr.length; k < len && (p < to || !strarr[k].type && !strarr[k - 1].greedy); ++k) {\n                p += strarr[k].length; // Move the index i to the element in strarr that is closest to from\n\n                if (from >= p) {\n                  ++i;\n                  pos = p;\n                }\n              } // If strarr[i] is a Token, then the match starts inside another Token, which is invalid\n\n\n              if (strarr[i] instanceof Token) {\n                continue;\n              } // Number of tokens to delete and replace with the new match\n\n\n              delNum = k - i;\n              str = text.slice(pos, p);\n              match.index -= pos;\n            } else {\n              pattern.lastIndex = 0;\n              var match = pattern.exec(str),\n                  delNum = 1;\n            }\n\n            if (!match) {\n              if (oneshot) {\n                break;\n              }\n\n              continue;\n            }\n\n            if (lookbehind) {\n              lookbehindLength = match[1] ? match[1].length : 0;\n            }\n\n            var from = match.index + lookbehindLength,\n                match = match[0].slice(lookbehindLength),\n                to = from + match.length,\n                before = str.slice(0, from),\n                after = str.slice(to);\n            var args = [i, delNum];\n\n            if (before) {\n              ++i;\n              pos += before.length;\n              args.push(before);\n            }\n\n            var wrapped = new Token(token, inside ? _.tokenize(match, inside) : match, alias, match, greedy);\n            args.push(wrapped);\n\n            if (after) {\n              args.push(after);\n            }\n\n            Array.prototype.splice.apply(strarr, args);\n\n            if (delNum != 1) {\n              _.matchGrammar(text, strarr, grammar, i, pos, true, token);\n            }\n\n            if (oneshot) {\n              break;\n            }\n          }\n        }\n      }\n    },\n    hooks: {\n      add: function add() {}\n    },\n    tokenize: function tokenize(text, grammar, language) {\n      var strarr = [text];\n      var rest = grammar.rest;\n\n      if (rest) {\n        for (var token in rest) {\n          grammar[token] = rest[token];\n        }\n\n        delete grammar.rest;\n      }\n\n      _.matchGrammar(text, strarr, grammar, 0, 0, false);\n\n      return strarr;\n    }\n  };\n\n  var Token = _.Token = function (type, content, alias, matchedStr, greedy) {\n    this.type = type;\n    this.content = content;\n    this.alias = alias; // Copy of the full string this token was created from\n\n    this.length = (matchedStr || \"\").length | 0;\n    this.greedy = !!greedy;\n  };\n\n  Token.stringify = function (o, language, parent) {\n    if (typeof o == \"string\") {\n      return o;\n    }\n\n    if (_.util.type(o) === \"Array\") {\n      return o.map(function (element) {\n        return Token.stringify(element, language, o);\n      }).join(\"\");\n    }\n\n    var env = {\n      type: o.type,\n      content: Token.stringify(o.content, language, parent),\n      tag: \"span\",\n      classes: [\"token\", o.type],\n      attributes: {},\n      language: language,\n      parent: parent\n    };\n\n    if (o.alias) {\n      var aliases = _.util.type(o.alias) === \"Array\" ? o.alias : [o.alias];\n      Array.prototype.push.apply(env.classes, aliases);\n    }\n\n    var attributes = Object.keys(env.attributes).map(function (name) {\n      return name + '=\"' + (env.attributes[name] || \"\").replace(/\"/g, \"&quot;\") + '\"';\n    }).join(\" \");\n    return \"<\" + env.tag + ' class=\"' + env.classes.join(\" \") + '\"' + (attributes ? \" \" + attributes : \"\") + \">\" + env.content + \"</\" + env.tag + \">\";\n  };\n\n  return _;\n}();\n/* This content is auto-generated to include some prismjs language components: */\n\n/* \"prismjs/components/prism-markup\" */\n\n\nPrism.languages.markup = {\n  'comment': /<!--[\\s\\S]*?-->/,\n  'prolog': /<\\?[\\s\\S]+?\\?>/,\n  'doctype': /<!DOCTYPE[\\s\\S]+?>/i,\n  'cdata': /<!\\[CDATA\\[[\\s\\S]*?]]>/i,\n  'tag': {\n    pattern: /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s(?:\\s*[^\\s>\\/=]+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))|(?=[\\s/>])))+)?\\s*\\/?>/i,\n    greedy: true,\n    inside: {\n      'tag': {\n        pattern: /^<\\/?[^\\s>\\/]+/i,\n        inside: {\n          'punctuation': /^<\\/?/,\n          'namespace': /^[^\\s>\\/:]+:/\n        }\n      },\n      'attr-value': {\n        pattern: /=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+)/i,\n        inside: {\n          'punctuation': [/^=/, {\n            pattern: /^(\\s*)[\"']|[\"']$/,\n            lookbehind: true\n          }]\n        }\n      },\n      'punctuation': /\\/?>/,\n      'attr-name': {\n        pattern: /[^\\s>\\/]+/,\n        inside: {\n          'namespace': /^[^\\s>\\/:]+:/\n        }\n      }\n    }\n  },\n  'entity': /&#?[\\da-z]{1,8};/i\n};\nPrism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity']; // Plugin to make entity title show the real entity, idea by Roman Komarov\n\nPrism.hooks.add('wrap', function (env) {\n  if (env.type === 'entity') {\n    env.attributes['title'] = env.content.replace(/&amp;/, '&');\n  }\n});\nObject.defineProperty(Prism.languages.markup.tag, 'addInlined', {\n  /**\n   * Adds an inlined language to markup.\n   *\n   * An example of an inlined language is CSS with `<style>` tags.\n   *\n   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as\n   * case insensitive.\n   * @param {string} lang The language key.\n   * @example\n   * addInlined('style', 'css');\n   */\n  value: function addInlined(tagName, lang) {\n    var includedCdataInside = {};\n    includedCdataInside['language-' + lang] = {\n      pattern: /(^<!\\[CDATA\\[)[\\s\\S]+?(?=\\]\\]>$)/i,\n      lookbehind: true,\n      inside: Prism.languages[lang]\n    };\n    includedCdataInside['cdata'] = /^<!\\[CDATA\\[|\\]\\]>$/i;\n    var inside = {\n      'included-cdata': {\n        pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i,\n        inside: includedCdataInside\n      }\n    };\n    inside['language-' + lang] = {\n      pattern: /[\\s\\S]+/,\n      inside: Prism.languages[lang]\n    };\n    var def = {};\n    def[tagName] = {\n      pattern: RegExp(/(<__[\\s\\S]*?>)(?:<!\\[CDATA\\[[\\s\\S]*?\\]\\]>\\s*|[\\s\\S])*?(?=<\\/__>)/.source.replace(/__/g, tagName), 'i'),\n      lookbehind: true,\n      greedy: true,\n      inside: inside\n    };\n    Prism.languages.insertBefore('markup', 'cdata', def);\n  }\n});\nPrism.languages.xml = Prism.languages.extend('markup', {});\nPrism.languages.html = Prism.languages.markup;\nPrism.languages.mathml = Prism.languages.markup;\nPrism.languages.svg = Prism.languages.markup;\n/* \"prismjs/components/prism-bash\" */\n\n(function (Prism) {\n  // $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\\n' '|'\n  // + LC_ALL, RANDOM, REPLY, SECONDS.\n  // + make sure PS1..4 are here as they are not always set,\n  // - some useless things.\n  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';\n  var insideString = {\n    'environment': {\n      pattern: RegExp(\"\\\\$\" + envVars),\n      alias: 'constant'\n    },\n    'variable': [// [0]: Arithmetic Environment\n    {\n      pattern: /\\$?\\(\\([\\s\\S]+?\\)\\)/,\n      greedy: true,\n      inside: {\n        // If there is a $ sign at the beginning highlight $(( and )) as variable\n        'variable': [{\n          pattern: /(^\\$\\(\\([\\s\\S]+)\\)\\)/,\n          lookbehind: true\n        }, /^\\$\\(\\(/],\n        'number': /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+\\.?\\d*|\\B\\.\\d+)(?:[Ee]-?\\d+)?/,\n        // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic\n        'operator': /--?|-=|\\+\\+?|\\+=|!=?|~|\\*\\*?|\\*=|\\/=?|%=?|<<=?|>>=?|<=?|>=?|==?|&&?|&=|\\^=?|\\|\\|?|\\|=|\\?|:/,\n        // If there is no $ sign at the beginning highlight (( and )) as punctuation\n        'punctuation': /\\(\\(?|\\)\\)?|,|;/\n      }\n    }, // [1]: Command Substitution\n    {\n      pattern: /\\$\\((?:\\([^)]+\\)|[^()])+\\)|`[^`]+`/,\n      greedy: true,\n      inside: {\n        'variable': /^\\$\\(|^`|\\)$|`$/\n      }\n    }, // [2]: Brace expansion\n    {\n      pattern: /\\$\\{[^}]+\\}/,\n      greedy: true,\n      inside: {\n        'operator': /:[-=?+]?|[!\\/]|##?|%%?|\\^\\^?|,,?/,\n        'punctuation': /[\\[\\]]/,\n        'environment': {\n          pattern: RegExp(\"(\\\\{)\" + envVars),\n          lookbehind: true,\n          alias: 'constant'\n        }\n      }\n    }, /\\$(?:\\w+|[#?*!@$])/],\n    // Escape sequences from echo and printf's manuals, and escaped quotes.\n    'entity': /\\\\(?:[abceEfnrtv\\\\\"]|O?[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})/\n  };\n  Prism.languages.bash = {\n    'shebang': {\n      pattern: /^#!\\s*\\/.*/,\n      alias: 'important'\n    },\n    'comment': {\n      pattern: /(^|[^\"{\\\\$])#.*/,\n      lookbehind: true\n    },\n    'function-name': [// a) function foo {\n    // b) foo() {\n    // c) function foo() {\n    // but not “foo {”\n    {\n      // a) and c)\n      pattern: /(\\bfunction\\s+)\\w+(?=(?:\\s*\\(?:\\s*\\))?\\s*\\{)/,\n      lookbehind: true,\n      alias: 'function'\n    }, {\n      // b)\n      pattern: /\\b\\w+(?=\\s*\\(\\s*\\)\\s*\\{)/,\n      alias: 'function'\n    }],\n    // Highlight variable names as variables in for and select beginnings.\n    'for-or-select': {\n      pattern: /(\\b(?:for|select)\\s+)\\w+(?=\\s+in\\s)/,\n      alias: 'variable',\n      lookbehind: true\n    },\n    // Highlight variable names as variables in the left-hand part\n    // of assignments (“=” and “+=”).\n    'assign-left': {\n      pattern: /(^|[\\s;|&]|[<>]\\()\\w+(?=\\+?=)/,\n      inside: {\n        'environment': {\n          pattern: RegExp(\"(^|[\\\\s;|&]|[<>]\\\\()\" + envVars),\n          lookbehind: true,\n          alias: 'constant'\n        }\n      },\n      alias: 'variable',\n      lookbehind: true\n    },\n    'string': [// Support for Here-documents https://en.wikipedia.org/wiki/Here_document\n    {\n      pattern: /((?:^|[^<])<<-?\\s*)(\\w+?)\\s*(?:\\r?\\n|\\r)(?:[\\s\\S])*?(?:\\r?\\n|\\r)\\2/,\n      lookbehind: true,\n      greedy: true,\n      inside: insideString\n    }, // Here-document with quotes around the tag\n    // → No expansion (so no “inside”).\n    {\n      pattern: /((?:^|[^<])<<-?\\s*)([\"'])(\\w+)\\2\\s*(?:\\r?\\n|\\r)(?:[\\s\\S])*?(?:\\r?\\n|\\r)\\3/,\n      lookbehind: true,\n      greedy: true\n    }, // “Normal” string\n    {\n      pattern: /([\"'])(?:\\\\[\\s\\S]|\\$\\([^)]+\\)|`[^`]+`|(?!\\1)[^\\\\])*\\1/,\n      greedy: true,\n      inside: insideString\n    }],\n    'environment': {\n      pattern: RegExp(\"\\\\$?\" + envVars),\n      alias: 'constant'\n    },\n    'variable': insideString.variable,\n    'function': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:add|apropos|apt|aptitude|apt-cache|apt-get|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|popd|pr|printcap|printenv|ps|pushd|pv|quota|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|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\\s;|&])/,\n      lookbehind: true\n    },\n    'keyword': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:if|then|else|elif|fi|for|while|in|case|esac|function|select|do|done|until)(?=$|[)\\s;|&])/,\n      lookbehind: true\n    },\n    // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html\n    'builtin': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:\\.|:|break|cd|continue|eval|exec|exit|export|getopts|hash|pwd|readonly|return|shift|test|times|trap|umask|unset|alias|bind|builtin|caller|command|declare|echo|enable|help|let|local|logout|mapfile|printf|read|readarray|source|type|typeset|ulimit|unalias|set|shopt)(?=$|[)\\s;|&])/,\n      lookbehind: true,\n      // Alias added to make those easier to distinguish from strings.\n      alias: 'class-name'\n    },\n    'boolean': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:true|false)(?=$|[)\\s;|&])/,\n      lookbehind: true\n    },\n    'file-descriptor': {\n      pattern: /\\B&\\d\\b/,\n      alias: 'important'\n    },\n    'operator': {\n      // Lots of redirections here, but not just that.\n      pattern: /\\d?<>|>\\||\\+=|==?|!=?|=~|<<[<-]?|[&\\d]?>>|\\d?[<>]&?|&[>&]?|\\|[&|]?|<=?|>=?/,\n      inside: {\n        'file-descriptor': {\n          pattern: /^\\d/,\n          alias: 'important'\n        }\n      }\n    },\n    'punctuation': /\\$?\\(\\(?|\\)\\)?|\\.\\.|[{}[\\];\\\\]/,\n    'number': {\n      pattern: /(^|\\s)(?:[1-9]\\d*|0)(?:[.,]\\d+)?\\b/,\n      lookbehind: true\n    }\n  };\n  /* Patterns in command substitution. */\n\n  var toBeCopied = ['comment', 'function-name', 'for-or-select', 'assign-left', 'string', 'environment', 'function', 'keyword', 'builtin', 'boolean', 'file-descriptor', 'operator', 'punctuation', 'number'];\n  var inside = insideString.variable[1].inside;\n\n  for (var i = 0; i < toBeCopied.length; i++) {\n    inside[toBeCopied[i]] = Prism.languages.bash[toBeCopied[i]];\n  }\n\n  Prism.languages.shell = Prism.languages.bash;\n})(Prism);\n/* \"prismjs/components/prism-clike\" */\n\n\nPrism.languages.clike = {\n  'comment': [{\n    pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^\\\\:])\\/\\/.*/,\n    lookbehind: true,\n    greedy: true\n  }],\n  'string': {\n    pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    greedy: true\n  },\n  'class-name': {\n    pattern: /((?:\\b(?:class|interface|extends|implements|trait|instanceof|new)\\s+)|(?:catch\\s+\\())[\\w.\\\\]+/i,\n    lookbehind: true,\n    inside: {\n      punctuation: /[.\\\\]/\n    }\n  },\n  'keyword': /\\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\\b/,\n  'boolean': /\\b(?:true|false)\\b/,\n  'function': /\\w+(?=\\()/,\n  'number': /\\b0x[\\da-f]+\\b|(?:\\b\\d+\\.?\\d*|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n  'operator': /--?|\\+\\+?|!=?=?|<=?|>=?|==?=?|&&?|\\|\\|?|\\?|\\*|\\/|~|\\^|%/,\n  'punctuation': /[{}[\\];(),.:]/\n};\n/* \"prismjs/components/prism-c\" */\n\nPrism.languages.c = Prism.languages.extend('clike', {\n  'class-name': {\n    pattern: /(\\b(?:enum|struct)\\s+)\\w+/,\n    lookbehind: true\n  },\n  'keyword': /\\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\\b/,\n  'operator': />>=?|<<=?|->|([-+&|:])\\1|[?:~]|[-+*/%&|^!=<>]=?/,\n  'number': /(?:\\b0x(?:[\\da-f]+\\.?[\\da-f]*|\\.[\\da-f]+)(?:p[+-]?\\d+)?|(?:\\b\\d+\\.?\\d*|\\B\\.\\d+)(?:e[+-]?\\d+)?)[ful]*/i\n});\nPrism.languages.insertBefore('c', 'string', {\n  'macro': {\n    // allow for multiline macro definitions\n    // spaces after the # character compile fine with gcc\n    pattern: /(^\\s*)#\\s*[a-z]+(?:[^\\r\\n\\\\]|\\\\(?:\\r\\n|[\\s\\S]))*/im,\n    lookbehind: true,\n    alias: 'property',\n    inside: {\n      // highlight the path of the include statement as a string\n      'string': {\n        pattern: /(#\\s*include\\s*)(?:<.+?>|(\"|')(?:\\\\?.)+?\\2)/,\n        lookbehind: true\n      },\n      // highlight macro directives as keywords\n      'directive': {\n        pattern: /(#\\s*)\\b(?:define|defined|elif|else|endif|error|ifdef|ifndef|if|import|include|line|pragma|undef|using)\\b/,\n        lookbehind: true,\n        alias: 'keyword'\n      }\n    }\n  },\n  // highlight predefined macros as constants\n  'constant': /\\b(?:__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|stdin|stdout|stderr)\\b/\n});\ndelete Prism.languages.c['boolean'];\n/* \"prismjs/components/prism-cpp\" */\n\nPrism.languages.cpp = Prism.languages.extend('c', {\n  'class-name': {\n    pattern: /(\\b(?:class|enum|struct)\\s+)\\w+/,\n    lookbehind: true\n  },\n  'keyword': /\\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\\b/,\n  'number': {\n    pattern: /(?:\\b0b[01']+|\\b0x(?:[\\da-f']+\\.?[\\da-f']*|\\.[\\da-f']+)(?:p[+-]?[\\d']+)?|(?:\\b[\\d']+\\.?[\\d']*|\\B\\.[\\d']+)(?:e[+-]?[\\d']+)?)[ful]*/i,\n    greedy: true\n  },\n  'operator': />>=?|<<=?|->|([-+&|:])\\1|[?:~]|[-+*/%&|^!=<>]=?|\\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\\b/,\n  'boolean': /\\b(?:true|false)\\b/\n});\nPrism.languages.insertBefore('cpp', 'string', {\n  'raw-string': {\n    pattern: /R\"([^()\\\\ ]{0,16})\\([\\s\\S]*?\\)\\1\"/,\n    alias: 'string',\n    greedy: true\n  }\n});\n/* \"prismjs/components/prism-css\" */\n\n(function (Prism) {\n  var string = /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/;\n  Prism.languages.css = {\n    'comment': /\\/\\*[\\s\\S]*?\\*\\//,\n    'atrule': {\n      pattern: /@[\\w-]+[\\s\\S]*?(?:;|(?=\\s*\\{))/,\n      inside: {\n        'rule': /@[\\w-]+/ // See rest below\n\n      }\n    },\n    'url': {\n      pattern: RegExp('url\\\\((?:' + string.source + '|[^\\n\\r()]*)\\\\)', 'i'),\n      inside: {\n        'function': /^url/i,\n        'punctuation': /^\\(|\\)$/\n      }\n    },\n    'selector': RegExp('[^{}\\\\s](?:[^{};\"\\']|' + string.source + ')*?(?=\\\\s*\\\\{)'),\n    'string': {\n      pattern: string,\n      greedy: true\n    },\n    'property': /[-_a-z\\xA0-\\uFFFF][-\\w\\xA0-\\uFFFF]*(?=\\s*:)/i,\n    'important': /!important\\b/i,\n    'function': /[-a-z0-9]+(?=\\()/i,\n    'punctuation': /[(){};:,]/\n  };\n  Prism.languages.css['atrule'].inside.rest = Prism.languages.css;\n  var markup = Prism.languages.markup;\n\n  if (markup) {\n    markup.tag.addInlined('style', 'css');\n    Prism.languages.insertBefore('inside', 'attr-value', {\n      'style-attr': {\n        pattern: /\\s*style=(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/i,\n        inside: {\n          'attr-name': {\n            pattern: /^\\s*style/i,\n            inside: markup.tag.inside\n          },\n          'punctuation': /^\\s*=\\s*['\"]|['\"]\\s*$/,\n          'attr-value': {\n            pattern: /.+/i,\n            inside: Prism.languages.css\n          }\n        },\n        alias: 'language-css'\n      }\n    }, markup.tag);\n  }\n})(Prism);\n/* \"prismjs/components/prism-css-extras\" */\n\n\nPrism.languages.css.selector = {\n  pattern: Prism.languages.css.selector,\n  inside: {\n    'pseudo-element': /:(?:after|before|first-letter|first-line|selection)|::[-\\w]+/,\n    'pseudo-class': /:[-\\w]+/,\n    'class': /\\.[-:.\\w]+/,\n    'id': /#[-:.\\w]+/,\n    'attribute': {\n      pattern: /\\[(?:[^[\\]\"']|(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1)*\\]/,\n      greedy: true,\n      inside: {\n        'punctuation': /^\\[|\\]$/,\n        'case-sensitivity': {\n          pattern: /(\\s)[si]$/i,\n          lookbehind: true,\n          alias: 'keyword'\n        },\n        'namespace': {\n          pattern: /^(\\s*)[-*\\w\\xA0-\\uFFFF]*\\|(?!=)/,\n          lookbehind: true,\n          inside: {\n            'punctuation': /\\|$/\n          }\n        },\n        'attribute': {\n          pattern: /^(\\s*)[-\\w\\xA0-\\uFFFF]+/,\n          lookbehind: true\n        },\n        'value': [/(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/, {\n          pattern: /(=\\s*)[-\\w\\xA0-\\uFFFF]+(?=\\s*$)/,\n          lookbehind: true\n        }],\n        'operator': /[|~*^$]?=/\n      }\n    },\n    'n-th': [{\n      pattern: /(\\(\\s*)[+-]?\\d*[\\dn](?:\\s*[+-]\\s*\\d+)?(?=\\s*\\))/,\n      lookbehind: true,\n      inside: {\n        'number': /[\\dn]+/,\n        'operator': /[+-]/\n      }\n    }, {\n      pattern: /(\\(\\s*)(?:even|odd)(?=\\s*\\))/i,\n      lookbehind: true\n    }],\n    'punctuation': /[()]/\n  }\n};\nPrism.languages.insertBefore('css', 'property', {\n  'variable': {\n    pattern: /(^|[^-\\w\\xA0-\\uFFFF])--[-_a-z\\xA0-\\uFFFF][-\\w\\xA0-\\uFFFF]*/i,\n    lookbehind: true\n  }\n});\nPrism.languages.insertBefore('css', 'function', {\n  'operator': {\n    pattern: /(\\s)[+\\-*\\/](?=\\s)/,\n    lookbehind: true\n  },\n  'hexcode': /#[\\da-f]{3,8}/i,\n  'entity': /\\\\[\\da-f]{1,8}/i,\n  'unit': {\n    pattern: /(\\d)(?:%|[a-z]+)/,\n    lookbehind: true\n  },\n  'number': /-?[\\d.]+/\n});\n/* \"prismjs/components/prism-javascript\" */\n\nPrism.languages.javascript = Prism.languages.extend('clike', {\n  'class-name': [Prism.languages.clike['class-name'], {\n    pattern: /(^|[^$\\w\\xA0-\\uFFFF])[_$A-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\.(?:prototype|constructor))/,\n    lookbehind: true\n  }],\n  'keyword': [{\n    pattern: /((?:^|})\\s*)(?:catch|finally)\\b/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^.])\\b(?:as|async(?=\\s*(?:function\\b|\\(|[$\\w\\xA0-\\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\\b/,\n    lookbehind: true\n  }],\n  'number': /\\b(?:(?:0[xX](?:[\\dA-Fa-f](?:_[\\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\\d(?:_\\d)?)+n|NaN|Infinity)\\b|(?:\\b(?:\\d(?:_\\d)?)+\\.?(?:\\d(?:_\\d)?)*|\\B\\.(?:\\d(?:_\\d)?)+)(?:[Ee][+-]?(?:\\d(?:_\\d)?)+)?/,\n  // Allow for all non-ASCII characters (See https://stackoverflow.com/a/2008444)\n  'function': /#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*(?:\\.\\s*(?:apply|bind|call)\\s*)?\\()/,\n  'operator': /-[-=]?|\\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\\|[|=]?|\\*\\*?=?|\\/=?|~|\\^=?|%=?|\\?|\\.{3}/\n});\nPrism.languages.javascript['class-name'][0].pattern = /(\\b(?:class|interface|extends|implements|instanceof|new)\\s+)[\\w.\\\\]+/;\nPrism.languages.insertBefore('javascript', 'keyword', {\n  'regex': {\n    pattern: /((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s])\\s*)\\/(\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[gimyus]{0,6}(?=\\s*($|[\\r\\n,.;})\\]]))/,\n    lookbehind: true,\n    greedy: true\n  },\n  // This must be declared before keyword because we use \"function\" inside the look-forward\n  'function-variable': {\n    pattern: /#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*[=:]\\s*(?:async\\s*)?(?:\\bfunction\\b|(?:\\((?:[^()]|\\([^()]*\\))*\\)|[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*)\\s*=>))/,\n    alias: 'function'\n  },\n  'parameter': [{\n    pattern: /(function(?:\\s+[_$A-Za-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*)?\\s*\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\))/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /[_$a-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*=>)/i,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /(\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\)\\s*=>)/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /((?:\\b|\\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\\w\\xA0-\\uFFFF]))(?:[_$A-Za-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*\\s*)\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\)\\s*\\{)/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }],\n  'constant': /\\b[A-Z](?:[A-Z_]|\\dx?)*\\b/\n});\nPrism.languages.insertBefore('javascript', 'string', {\n  'template-string': {\n    pattern: /`(?:\\\\[\\s\\S]|\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\\${)[^\\\\`])*`/,\n    greedy: true,\n    inside: {\n      'template-punctuation': {\n        pattern: /^`|`$/,\n        alias: 'string'\n      },\n      'interpolation': {\n        pattern: /((?:^|[^\\\\])(?:\\\\{2})*)\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,\n        lookbehind: true,\n        inside: {\n          'interpolation-punctuation': {\n            pattern: /^\\${|}$/,\n            alias: 'punctuation'\n          },\n          rest: Prism.languages.javascript\n        }\n      },\n      'string': /[\\s\\S]+/\n    }\n  }\n});\n\nif (Prism.languages.markup) {\n  Prism.languages.markup.tag.addInlined('script', 'javascript');\n}\n\nPrism.languages.js = Prism.languages.javascript;\n/* \"prismjs/components/prism-jsx\" */\n\n(function (Prism) {\n  var javascript = Prism.util.clone(Prism.languages.javascript);\n  Prism.languages.jsx = Prism.languages.extend('markup', javascript);\n  Prism.languages.jsx.tag.pattern = /<\\/?(?:[\\w.:-]+\\s*(?:\\s+(?:[\\w.:-]+(?:=(?:(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|[^\\s{'\">=]+|\\{(?:\\{(?:\\{[^}]*\\}|[^{}])*\\}|[^{}])+\\}))?|\\{\\.{3}[a-z_$][\\w$]*(?:\\.[a-z_$][\\w$]*)*\\}))*\\s*\\/?)?>/i;\n  Prism.languages.jsx.tag.inside['tag'].pattern = /^<\\/?[^\\s>\\/]*/i;\n  Prism.languages.jsx.tag.inside['attr-value'].pattern = /=(?!\\{)(?:(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|[^\\s'\">]+)/i;\n  Prism.languages.jsx.tag.inside['tag'].inside['class-name'] = /^[A-Z]\\w*(?:\\.[A-Z]\\w*)*$/;\n  Prism.languages.insertBefore('inside', 'attr-name', {\n    'spread': {\n      pattern: /\\{\\.{3}[a-z_$][\\w$]*(?:\\.[a-z_$][\\w$]*)*\\}/,\n      inside: {\n        'punctuation': /\\.{3}|[{}.]/,\n        'attr-value': /\\w+/\n      }\n    }\n  }, Prism.languages.jsx.tag);\n  Prism.languages.insertBefore('inside', 'attr-value', {\n    'script': {\n      // Allow for two levels of nesting\n      pattern: /=(\\{(?:\\{(?:\\{[^}]*\\}|[^}])*\\}|[^}])+\\})/i,\n      inside: {\n        'script-punctuation': {\n          pattern: /^=(?={)/,\n          alias: 'punctuation'\n        },\n        rest: Prism.languages.jsx\n      },\n      'alias': 'language-javascript'\n    }\n  }, Prism.languages.jsx.tag); // The following will handle plain text inside tags\n\n  var stringifyToken = function stringifyToken(token) {\n    if (!token) {\n      return '';\n    }\n\n    if (typeof token === 'string') {\n      return token;\n    }\n\n    if (typeof token.content === 'string') {\n      return token.content;\n    }\n\n    return token.content.map(stringifyToken).join('');\n  };\n\n  var walkTokens = function walkTokens(tokens) {\n    var openedTags = [];\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n      var notTagNorBrace = false;\n\n      if (typeof token !== 'string') {\n        if (token.type === 'tag' && token.content[0] && token.content[0].type === 'tag') {\n          // We found a tag, now find its kind\n          if (token.content[0].content[0].content === '</') {\n            // Closing tag\n            if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {\n              // Pop matching opening tag\n              openedTags.pop();\n            }\n          } else {\n            if (token.content[token.content.length - 1].content === '/>') ;else {\n              // Opening tag\n              openedTags.push({\n                tagName: stringifyToken(token.content[0].content[1]),\n                openedBraces: 0\n              });\n            }\n          }\n        } else if (openedTags.length > 0 && token.type === 'punctuation' && token.content === '{') {\n          // Here we might have entered a JSX context inside a tag\n          openedTags[openedTags.length - 1].openedBraces++;\n        } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === 'punctuation' && token.content === '}') {\n          // Here we might have left a JSX context inside a tag\n          openedTags[openedTags.length - 1].openedBraces--;\n        } else {\n          notTagNorBrace = true;\n        }\n      }\n\n      if (notTagNorBrace || typeof token === 'string') {\n        if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {\n          // Here we are inside a tag, and not inside a JSX context.\n          // That's plain text: drop any tokens matched.\n          var plainText = stringifyToken(token); // And merge text with adjacent text\n\n          if (i < tokens.length - 1 && (typeof tokens[i + 1] === 'string' || tokens[i + 1].type === 'plain-text')) {\n            plainText += stringifyToken(tokens[i + 1]);\n            tokens.splice(i + 1, 1);\n          }\n\n          if (i > 0 && (typeof tokens[i - 1] === 'string' || tokens[i - 1].type === 'plain-text')) {\n            plainText = stringifyToken(tokens[i - 1]) + plainText;\n            tokens.splice(i - 1, 1);\n            i--;\n          }\n\n          tokens[i] = new Prism.Token('plain-text', plainText, null, plainText);\n        }\n      }\n\n      if (token.content && typeof token.content !== 'string') {\n        walkTokens(token.content);\n      }\n    }\n  };\n\n  Prism.hooks.add('after-tokenize', function (env) {\n    if (env.language !== 'jsx' && env.language !== 'tsx') {\n      return;\n    }\n\n    walkTokens(env.tokens);\n  });\n})(Prism);\n/* \"prismjs/components/prism-javadoclike\" */\n\n\n(function (Prism) {\n  var javaDocLike = Prism.languages.javadoclike = {\n    'parameter': {\n      pattern: /(^\\s*(?:\\/{3}|\\*|\\/\\*\\*)\\s*@(?:param|arg|arguments)\\s+)\\w+/m,\n      lookbehind: true\n    },\n    'keyword': {\n      // keywords are the first word in a line preceded be an `@` or surrounded by curly braces.\n      // @word, {@word}\n      pattern: /(^\\s*(?:\\/{3}|\\*|\\/\\*\\*)\\s*|\\{)@[a-z][a-zA-Z-]+\\b/m,\n      lookbehind: true\n    },\n    'punctuation': /[{}]/\n  };\n  /**\n   * Adds doc comment support to the given language and calls a given callback on each doc comment pattern.\n   *\n   * @param {string} lang the language add doc comment support to.\n   * @param {(pattern: {inside: {rest: undefined}}) => void} callback the function called with each doc comment pattern as argument.\n   */\n\n  function docCommentSupport(lang, callback) {\n    var tokenName = 'doc-comment';\n    var grammar = Prism.languages[lang];\n\n    if (!grammar) {\n      return;\n    }\n\n    var token = grammar[tokenName];\n\n    if (!token) {\n      // add doc comment: /** */\n      var definition = {};\n      definition[tokenName] = {\n        pattern: /(^|[^\\\\])\\/\\*\\*[^/][\\s\\S]*?(?:\\*\\/|$)/,\n        alias: 'comment'\n      };\n      grammar = Prism.languages.insertBefore(lang, 'comment', definition);\n      token = grammar[tokenName];\n    }\n\n    if (token instanceof RegExp) {\n      // convert regex to object\n      token = grammar[tokenName] = {\n        pattern: token\n      };\n    }\n\n    if (Array.isArray(token)) {\n      for (var i = 0, l = token.length; i < l; i++) {\n        if (token[i] instanceof RegExp) {\n          token[i] = {\n            pattern: token[i]\n          };\n        }\n\n        callback(token[i]);\n      }\n    } else {\n      callback(token);\n    }\n  }\n  /**\n   * Adds doc-comment support to the given languages for the given documentation language.\n   *\n   * @param {string[]|string} languages\n   * @param {Object} docLanguage\n   */\n\n\n  function addSupport(languages, docLanguage) {\n    if (typeof languages === 'string') {\n      languages = [languages];\n    }\n\n    languages.forEach(function (lang) {\n      docCommentSupport(lang, function (pattern) {\n        if (!pattern.inside) {\n          pattern.inside = {};\n        }\n\n        pattern.inside.rest = docLanguage;\n      });\n    });\n  }\n\n  Object.defineProperty(javaDocLike, 'addSupport', {\n    value: addSupport\n  });\n  javaDocLike.addSupport(['java', 'javascript', 'php'], javaDocLike);\n})(Prism);\n/* \"prismjs/components/prism-java\" */\n\n\n(function (Prism) {\n  var keywords = /\\b(?:abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while|var|null|exports|module|open|opens|provides|requires|to|transitive|uses|with)\\b/; // based on the java naming conventions\n\n  var className = /\\b[A-Z](?:\\w*[a-z]\\w*)?\\b/;\n  Prism.languages.java = Prism.languages.extend('clike', {\n    'class-name': [className, // variables and parameters\n    // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)\n    /\\b[A-Z]\\w*(?=\\s+\\w+\\s*[;,=())])/],\n    'keyword': keywords,\n    'function': [Prism.languages.clike.function, {\n      pattern: /(\\:\\:)[a-z_]\\w*/,\n      lookbehind: true\n    }],\n    'number': /\\b0b[01][01_]*L?\\b|\\b0x[\\da-f_]*\\.?[\\da-f_p+-]+\\b|(?:\\b\\d[\\d_]*\\.?[\\d_]*|\\B\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[dfl]?/i,\n    'operator': {\n      pattern: /(^|[^.])(?:<<=?|>>>?=?|->|([-+&|])\\2|[?:~]|[-+*/%&|^!=<>]=?)/m,\n      lookbehind: true\n    }\n  });\n  Prism.languages.insertBefore('java', 'class-name', {\n    'annotation': {\n      alias: 'punctuation',\n      pattern: /(^|[^.])@\\w+/,\n      lookbehind: true\n    },\n    'namespace': {\n      pattern: /(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)[a-z]\\w*(\\.[a-z]\\w*)+/,\n      lookbehind: true,\n      inside: {\n        'punctuation': /\\./\n      }\n    },\n    'generics': {\n      pattern: /<(?:[\\w\\s,.&?]|<(?:[\\w\\s,.&?]|<(?:[\\w\\s,.&?]|<[\\w\\s,.&?]*>)*>)*>)*>/,\n      inside: {\n        'class-name': className,\n        'keyword': keywords,\n        'punctuation': /[<>(),.:]/,\n        'operator': /[?&|]/\n      }\n    }\n  });\n})(Prism);\n/* \"prismjs/components/prism-markup-templating\" */\n\n\n(function (Prism) {\n  /**\n   * Returns the placeholder for the given language id and index.\n   *\n   * @param {string} language\n   * @param {string|number} index\n   * @returns {string}\n   */\n  function getPlaceholder(language, index) {\n    return '___' + language.toUpperCase() + index + '___';\n  }\n\n  Object.defineProperties(Prism.languages['markup-templating'] = {}, {\n    buildPlaceholders: {\n      /**\n       * Tokenize all inline templating expressions matching `placeholderPattern`.\n       *\n       * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns\n       * `true` will be replaced.\n       *\n       * @param {object} env The environment of the `before-tokenize` hook.\n       * @param {string} language The language id.\n       * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.\n       * @param {(match: string) => boolean} [replaceFilter]\n       */\n      value: function value(env, language, placeholderPattern, replaceFilter) {\n        if (env.language !== language) {\n          return;\n        }\n\n        var tokenStack = env.tokenStack = [];\n        env.code = env.code.replace(placeholderPattern, function (match) {\n          if (typeof replaceFilter === 'function' && !replaceFilter(match)) {\n            return match;\n          }\n\n          var i = tokenStack.length;\n          var placeholder; // Check for existing strings\n\n          while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {\n            ++i;\n          } // Create a sparse array\n\n\n          tokenStack[i] = match;\n          return placeholder;\n        }); // Switch the grammar to markup\n\n        env.grammar = Prism.languages.markup;\n      }\n    },\n    tokenizePlaceholders: {\n      /**\n       * Replace placeholders with proper tokens after tokenizing.\n       *\n       * @param {object} env The environment of the `after-tokenize` hook.\n       * @param {string} language The language id.\n       */\n      value: function value(env, language) {\n        if (env.language !== language || !env.tokenStack) {\n          return;\n        } // Switch the grammar back\n\n\n        env.grammar = Prism.languages[language];\n        var j = 0;\n        var keys = Object.keys(env.tokenStack);\n\n        function walkTokens(tokens) {\n          for (var i = 0; i < tokens.length; i++) {\n            // all placeholders are replaced already\n            if (j >= keys.length) {\n              break;\n            }\n\n            var token = tokens[i];\n\n            if (typeof token === 'string' || token.content && typeof token.content === 'string') {\n              var k = keys[j];\n              var t = env.tokenStack[k];\n              var s = typeof token === 'string' ? token : token.content;\n              var placeholder = getPlaceholder(language, k);\n              var index = s.indexOf(placeholder);\n\n              if (index > -1) {\n                ++j;\n                var before = s.substring(0, index);\n                var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);\n                var after = s.substring(index + placeholder.length);\n                var replacement = [];\n\n                if (before) {\n                  replacement.push.apply(replacement, walkTokens([before]));\n                }\n\n                replacement.push(middle);\n\n                if (after) {\n                  replacement.push.apply(replacement, walkTokens([after]));\n                }\n\n                if (typeof token === 'string') {\n                  tokens.splice.apply(tokens, [i, 1].concat(replacement));\n                } else {\n                  token.content = replacement;\n                }\n              }\n            } else if (token.content\n            /* && typeof token.content !== 'string' */\n            ) {\n                walkTokens(token.content);\n              }\n          }\n\n          return tokens;\n        }\n\n        walkTokens(env.tokens);\n      }\n    }\n  });\n})(Prism);\n/* \"prismjs/components/prism-php\" */\n\n/**\n * Original by Aaron Harun: https://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/\n * Modified by Miles Johnson: https://milesj.me\n *\n * Supports the following:\n * \t\t- Extends clike syntax\n * \t\t- Support for PHP 5.3+ (namespaces, traits, generators, etc)\n * \t\t- Smarter constant and function matching\n *\n * Adds the following new token classes:\n * \t\tconstant, delimiter, variable, function, package\n */\n\n\n(function (Prism) {\n  Prism.languages.php = Prism.languages.extend('clike', {\n    'keyword': /\\b(?:__halt_compiler|abstract|and|array|as|break|callable|case|catch|class|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|eval|exit|extends|final|finally|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|namespace|new|or|parent|print|private|protected|public|require|require_once|return|static|switch|throw|trait|try|unset|use|var|while|xor|yield)\\b/i,\n    'boolean': {\n      pattern: /\\b(?:false|true)\\b/i,\n      alias: 'constant'\n    },\n    'constant': [/\\b[A-Z_][A-Z0-9_]*\\b/, /\\b(?:null)\\b/i],\n    'comment': {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true\n    }\n  });\n  Prism.languages.insertBefore('php', 'string', {\n    'shell-comment': {\n      pattern: /(^|[^\\\\])#.*/,\n      lookbehind: true,\n      alias: 'comment'\n    }\n  });\n  Prism.languages.insertBefore('php', 'comment', {\n    'delimiter': {\n      pattern: /\\?>$|^<\\?(?:php(?=\\s)|=)?/i,\n      alias: 'important'\n    }\n  });\n  Prism.languages.insertBefore('php', 'keyword', {\n    'variable': /\\$+(?:\\w+\\b|(?={))/i,\n    'package': {\n      pattern: /(\\\\|namespace\\s+|use\\s+)[\\w\\\\]+/,\n      lookbehind: true,\n      inside: {\n        punctuation: /\\\\/\n      }\n    }\n  }); // Must be defined after the function pattern\n\n  Prism.languages.insertBefore('php', 'operator', {\n    'property': {\n      pattern: /(->)[\\w]+/,\n      lookbehind: true\n    }\n  });\n  var string_interpolation = {\n    pattern: /{\\$(?:{(?:{[^{}]+}|[^{}]+)}|[^{}])+}|(^|[^\\\\{])\\$+(?:\\w+(?:\\[.+?]|->\\w+)*)/,\n    lookbehind: true,\n    inside: {\n      rest: Prism.languages.php\n    }\n  };\n  Prism.languages.insertBefore('php', 'string', {\n    'nowdoc-string': {\n      pattern: /<<<'([^']+)'(?:\\r\\n?|\\n)(?:.*(?:\\r\\n?|\\n))*?\\1;/,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        'delimiter': {\n          pattern: /^<<<'[^']+'|[a-z_]\\w*;$/i,\n          alias: 'symbol',\n          inside: {\n            'punctuation': /^<<<'?|[';]$/\n          }\n        }\n      }\n    },\n    'heredoc-string': {\n      pattern: /<<<(?:\"([^\"]+)\"(?:\\r\\n?|\\n)(?:.*(?:\\r\\n?|\\n))*?\\1;|([a-z_]\\w*)(?:\\r\\n?|\\n)(?:.*(?:\\r\\n?|\\n))*?\\2;)/i,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        'delimiter': {\n          pattern: /^<<<(?:\"[^\"]+\"|[a-z_]\\w*)|[a-z_]\\w*;$/i,\n          alias: 'symbol',\n          inside: {\n            'punctuation': /^<<<\"?|[\";]$/\n          }\n        },\n        'interpolation': string_interpolation // See below\n\n      }\n    },\n    'single-quoted-string': {\n      pattern: /'(?:\\\\[\\s\\S]|[^\\\\'])*'/,\n      greedy: true,\n      alias: 'string'\n    },\n    'double-quoted-string': {\n      pattern: /\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"/,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        'interpolation': string_interpolation // See below\n\n      }\n    }\n  }); // The different types of PHP strings \"replace\" the C-like standard string\n\n  delete Prism.languages.php['string'];\n  Prism.hooks.add('before-tokenize', function (env) {\n    if (!/<\\?/.test(env.code)) {\n      return;\n    }\n\n    var phpPattern = /<\\?(?:[^\"'/#]|\\/(?![*/])|(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|(?:\\/\\/|#)(?:[^?\\n\\r]|\\?(?!>))*|\\/\\*[\\s\\S]*?(?:\\*\\/|$))*?(?:\\?>|$)/ig;\n    Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern);\n  });\n  Prism.hooks.add('after-tokenize', function (env) {\n    Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php');\n  });\n})(Prism);\n/* \"prismjs/components/prism-jsdoc\" */\n\n\n(function (Prism) {\n  var javascript = Prism.languages.javascript;\n  var type = /{(?:[^{}]|{(?:[^{}]|{[^{}]*})*})+}/.source;\n  var parameterPrefix = '(@(?:param|arg|argument|property)\\\\s+(?:' + type + '\\\\s+)?)';\n  Prism.languages.jsdoc = Prism.languages.extend('javadoclike', {\n    'parameter': {\n      // @param {string} foo - foo bar\n      pattern: RegExp(parameterPrefix + /[$\\w\\xA0-\\uFFFF.]+(?=\\s|$)/.source),\n      lookbehind: true,\n      inside: {\n        'punctuation': /\\./\n      }\n    }\n  });\n  Prism.languages.insertBefore('jsdoc', 'keyword', {\n    'optional-parameter': {\n      // @param {string} [baz.foo=\"bar\"] foo bar\n      pattern: RegExp(parameterPrefix + /\\[[$\\w\\xA0-\\uFFFF.]+(?:=[^[\\]]+)?\\](?=\\s|$)/.source),\n      lookbehind: true,\n      inside: {\n        'parameter': {\n          pattern: /(^\\[)[$\\w\\xA0-\\uFFFF\\.]+/,\n          lookbehind: true,\n          inside: {\n            'punctuation': /\\./\n          }\n        },\n        'code': {\n          pattern: /(=)[\\s\\S]*(?=\\]$)/,\n          lookbehind: true,\n          inside: javascript,\n          alias: 'language-javascript'\n        },\n        'punctuation': /[=[\\]]/\n      }\n    },\n    'class-name': [{\n      pattern: RegExp('(@[a-z]+\\\\s+)' + type),\n      lookbehind: true,\n      inside: {\n        'punctuation': /[.,:?=<>|{}()[\\]]/\n      }\n    }, {\n      pattern: /(@(?:augments|extends|class|interface|memberof!?|this)\\s+)[A-Z]\\w*(?:\\.[A-Z]\\w*)*/,\n      lookbehind: true,\n      inside: {\n        'punctuation': /\\./\n      }\n    }],\n    'example': {\n      pattern: /(@example\\s+)[^@]+?(?=\\s*(?:\\*\\s*)?(?:@\\w|\\*\\/))/,\n      lookbehind: true,\n      inside: {\n        'code': {\n          pattern: /^(\\s*(?:\\*\\s*)?).+$/m,\n          lookbehind: true,\n          inside: javascript,\n          alias: 'language-javascript'\n        }\n      }\n    }\n  });\n  Prism.languages.javadoclike.addSupport('javascript', Prism.languages.jsdoc);\n})(Prism);\n/* \"prismjs/components/prism-actionscript\" */\n\n\nPrism.languages.actionscript = Prism.languages.extend('javascript', {\n  'keyword': /\\b(?:as|break|case|catch|class|const|default|delete|do|else|extends|finally|for|function|if|implements|import|in|instanceof|interface|internal|is|native|new|null|package|private|protected|public|return|super|switch|this|throw|try|typeof|use|var|void|while|with|dynamic|each|final|get|include|namespace|native|override|set|static)\\b/,\n  'operator': /\\+\\+|--|(?:[+\\-*\\/%^]|&&?|\\|\\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/\n});\nPrism.languages.actionscript['class-name'].alias = 'function';\n\nif (Prism.languages.markup) {\n  Prism.languages.insertBefore('actionscript', 'string', {\n    'xml': {\n      pattern: /(^|[^.])<\\/?\\w+(?:\\s+[^\\s>\\/=]+=(\"|')(?:\\\\[\\s\\S]|(?!\\2)[^\\\\])*\\2)*\\s*\\/?>/,\n      lookbehind: true,\n      inside: {\n        rest: Prism.languages.markup\n      }\n    }\n  });\n}\n/* \"prismjs/components/prism-coffeescript\" */\n\n\n(function (Prism) {\n  // Ignore comments starting with { to privilege string interpolation highlighting\n  var comment = /#(?!\\{).+/,\n      interpolation = {\n    pattern: /#\\{[^}]+\\}/,\n    alias: 'variable'\n  };\n  Prism.languages.coffeescript = Prism.languages.extend('javascript', {\n    'comment': comment,\n    'string': [// Strings are multiline\n    {\n      pattern: /'(?:\\\\[\\s\\S]|[^\\\\'])*'/,\n      greedy: true\n    }, {\n      // Strings are multiline\n      pattern: /\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"/,\n      greedy: true,\n      inside: {\n        'interpolation': interpolation\n      }\n    }],\n    '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/,\n    'class-member': {\n      pattern: /@(?!\\d)\\w+/,\n      alias: 'variable'\n    }\n  });\n  Prism.languages.insertBefore('coffeescript', 'comment', {\n    'multiline-comment': {\n      pattern: /###[\\s\\S]+?###/,\n      alias: 'comment'\n    },\n    // Block regexp can contain comments and interpolation\n    'block-regex': {\n      pattern: /\\/{3}[\\s\\S]*?\\/{3}/,\n      alias: 'regex',\n      inside: {\n        'comment': comment,\n        'interpolation': interpolation\n      }\n    }\n  });\n  Prism.languages.insertBefore('coffeescript', 'string', {\n    'inline-javascript': {\n      pattern: /`(?:\\\\[\\s\\S]|[^\\\\`])*`/,\n      inside: {\n        'delimiter': {\n          pattern: /^`|`$/,\n          alias: 'punctuation'\n        },\n        rest: Prism.languages.javascript\n      }\n    },\n    // Block strings\n    'multiline-string': [{\n      pattern: /'''[\\s\\S]*?'''/,\n      greedy: true,\n      alias: 'string'\n    }, {\n      pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        interpolation: interpolation\n      }\n    }]\n  });\n  Prism.languages.insertBefore('coffeescript', 'keyword', {\n    // Object property\n    'property': /(?!\\d)\\w+(?=\\s*:(?!:))/\n  });\n  delete Prism.languages.coffeescript['template-string'];\n  Prism.languages.coffee = Prism.languages.coffeescript;\n})(Prism);\n/* \"prismjs/components/prism-js-extras\" */\n\n\n(function (Prism) {\n  Prism.languages.insertBefore('javascript', 'function-variable', {\n    'method-variable': {\n      pattern: RegExp('(\\\\.\\\\s*)' + Prism.languages.javascript['function-variable'].pattern.source),\n      lookbehind: true,\n      alias: ['function-variable', 'method', 'function', 'property-access']\n    }\n  });\n  Prism.languages.insertBefore('javascript', 'function', {\n    'method': {\n      pattern: RegExp('(\\\\.\\\\s*)' + Prism.languages.javascript['function'].source),\n      lookbehind: true,\n      alias: ['function', 'property-access']\n    }\n  });\n  Prism.languages.insertBefore('javascript', 'constant', {\n    'known-class-name': [{\n      // standard built-ins\n      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects\n      pattern: /\\b(?:(?:(?:Uint|Int)(?:8|16|32)|Uint8Clamped|Float(?:32|64))?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|(?:Weak)?(?:Set|Map)|WebAssembly)\\b/,\n      alias: 'class-name'\n    }, {\n      // errors\n      pattern: /\\b(?:[A-Z]\\w*)Error\\b/,\n      alias: 'class-name'\n    }]\n  });\n  Prism.languages.javascript['keyword'].unshift({\n    pattern: /\\b(?:as|default|export|from|import)\\b/,\n    alias: 'module'\n  }, {\n    pattern: /\\bnull\\b/,\n    alias: ['null', 'nil']\n  }, {\n    pattern: /\\bundefined\\b/,\n    alias: 'nil'\n  });\n  Prism.languages.insertBefore('javascript', 'operator', {\n    'spread': {\n      pattern: /\\.{3}/,\n      alias: 'operator'\n    },\n    'arrow': {\n      pattern: /=>/,\n      alias: 'operator'\n    }\n  });\n  Prism.languages.insertBefore('javascript', 'punctuation', {\n    'property-access': {\n      pattern: /(\\.\\s*)#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*/,\n      lookbehind: true\n    },\n    'maybe-class-name': {\n      pattern: /(^|[^$\\w\\xA0-\\uFFFF])[A-Z][$\\w\\xA0-\\uFFFF]+/,\n      lookbehind: true\n    },\n    'dom': {\n      // this contains only a few commonly used DOM variables\n      pattern: /\\b(?:document|location|navigator|performance|(?:local|session)Storage|window)\\b/,\n      alias: 'variable'\n    },\n    'console': {\n      pattern: /\\bconsole(?=\\s*\\.)/,\n      alias: 'class-name'\n    }\n  }); // add 'maybe-class-name' to tokens which might be a class name\n\n  var maybeClassNameTokens = ['function', 'function-variable', 'method', 'method-variable', 'property-access'];\n\n  for (var i = 0; i < maybeClassNameTokens.length; i++) {\n    var token = maybeClassNameTokens[i];\n    var value = Prism.languages.javascript[token]; // convert regex to object\n\n    if (Prism.util.type(value) === 'RegExp') {\n      value = Prism.languages.javascript[token] = {\n        pattern: value\n      };\n    } // keep in mind that we don't support arrays\n\n\n    var inside = value.inside || {};\n    value.inside = inside;\n    inside['maybe-class-name'] = /^[A-Z][\\s\\S]*/;\n  }\n})(Prism);\n/* \"prismjs/components/prism-flow\" */\n\n\n(function (Prism) {\n  Prism.languages.flow = Prism.languages.extend('javascript', {});\n  Prism.languages.insertBefore('flow', 'keyword', {\n    'type': [{\n      pattern: /\\b(?:[Nn]umber|[Ss]tring|[Bb]oolean|Function|any|mixed|null|void)\\b/,\n      alias: 'tag'\n    }]\n  });\n  Prism.languages.flow['function-variable'].pattern = /[_$a-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*=\\s*(?:function\\b|(?:\\([^()]*\\)(?:\\s*:\\s*\\w+)?|[_$a-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*)\\s*=>))/i;\n  delete Prism.languages.flow['parameter'];\n  Prism.languages.insertBefore('flow', 'operator', {\n    'flow-punctuation': {\n      pattern: /\\{\\||\\|\\}/,\n      alias: 'punctuation'\n    }\n  });\n\n  if (!Array.isArray(Prism.languages.flow.keyword)) {\n    Prism.languages.flow.keyword = [Prism.languages.flow.keyword];\n  }\n\n  Prism.languages.flow.keyword.unshift({\n    pattern: /(^|[^$]\\b)(?:type|opaque|declare|Class)\\b(?!\\$)/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^$]\\B)\\$(?:await|Diff|Exact|Keys|ObjMap|PropertyType|Shape|Record|Supertype|Subtype|Enum)\\b(?!\\$)/,\n    lookbehind: true\n  });\n})(Prism);\n/* \"prismjs/components/prism-n4js\" */\n\n\nPrism.languages.n4js = Prism.languages.extend('javascript', {\n  // Keywords from N4JS language spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html\n  'keyword': /\\b(?:any|Array|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\\b/\n});\nPrism.languages.insertBefore('n4js', 'constant', {\n  // Annotations in N4JS spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html#_annotations\n  'annotation': {\n    pattern: /@+\\w+/,\n    alias: 'operator'\n  }\n});\nPrism.languages.n4jsd = Prism.languages.n4js;\n/* \"prismjs/components/prism-typescript\" */\n\nPrism.languages.typescript = Prism.languages.extend('javascript', {\n  // From JavaScript Prism keyword list and TypeScript language spec: https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#221-reserved-words\n  'keyword': /\\b(?:abstract|as|async|await|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|var|void|while|with|yield)\\b/,\n  'builtin': /\\b(?:string|Function|any|number|boolean|Array|symbol|console|Promise|unknown|never)\\b/\n});\nPrism.languages.ts = Prism.languages.typescript;\n/* \"prismjs/components/prism-js-templates\" */\n\n(function (Prism) {\n  var templateString = Prism.languages.javascript['template-string']; // see the pattern in prism-javascript.js\n\n  var templateLiteralPattern = templateString.pattern.source;\n  var interpolationObject = templateString.inside['interpolation'];\n  var interpolationPunctuationObject = interpolationObject.inside['interpolation-punctuation'];\n  var interpolationPattern = interpolationObject.pattern.source;\n  /**\n   * Creates a new pattern to match a template string with a special tag.\n   *\n   * This will return `undefined` if there is no grammar with the given language id.\n   *\n   * @param {string} language The language id of the embedded language. E.g. `markdown`.\n   * @param {string} tag The regex pattern to match the tag.\n   * @returns {object | undefined}\n   * @example\n   * createTemplate('css', /\\bcss/.source);\n   */\n\n  function createTemplate(language, tag) {\n    if (!Prism.languages[language]) {\n      return undefined;\n    }\n\n    return {\n      pattern: RegExp('((?:' + tag + ')\\\\s*)' + templateLiteralPattern),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'template-punctuation': {\n          pattern: /^`|`$/,\n          alias: 'string'\n        },\n        'embedded-code': {\n          pattern: /[\\s\\S]+/,\n          alias: language\n        }\n      }\n    };\n  }\n\n  Prism.languages.javascript['template-string'] = [// styled-jsx:\n  //   css`a { color: #25F; }`\n  // styled-components:\n  //   styled.h1`color: red;`\n  createTemplate('css', /\\b(?:styled(?:\\([^)]*\\))?(?:\\s*\\.\\s*\\w+(?:\\([^)]*\\))*)*|css(?:\\s*\\.\\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source), // html`<p></p>`\n  // div.innerHTML = `<p></p>`\n  createTemplate('html', /\\bhtml|\\.\\s*(?:inner|outer)HTML\\s*\\+?=/.source), // svg`<path fill=\"#fff\" d=\"M55.37 ...\"/>`\n  createTemplate('svg', /\\bsvg/.source), // md`# h1`, markdown`## h2`\n  createTemplate('markdown', /\\b(?:md|markdown)/.source), // gql`...`, graphql`...`, graphql.experimental`...`\n  createTemplate('graphql', /\\b(?:gql|graphql(?:\\s*\\.\\s*experimental)?)/.source), // vanilla template string\n  templateString].filter(Boolean);\n  /**\n   * Returns a specific placeholder literal for the given language.\n   *\n   * @param {number} counter\n   * @param {string} language\n   * @returns {string}\n   */\n\n  function getPlaceholder(counter, language) {\n    return '___' + language.toUpperCase() + '_' + counter + '___';\n  }\n  /**\n   * Returns the tokens of `Prism.tokenize` but also runs the `before-tokenize` and `after-tokenize` hooks.\n   *\n   * @param {string} code\n   * @param {any} grammar\n   * @param {string} language\n   * @returns {(string|Token)[]}\n   */\n\n\n  function tokenizeWithHooks(code, grammar, language) {\n    var env = {\n      code: code,\n      grammar: grammar,\n      language: language\n    };\n    Prism.hooks.run('before-tokenize', env);\n    env.tokens = Prism.tokenize(env.code, env.grammar);\n    Prism.hooks.run('after-tokenize', env);\n    return env.tokens;\n  }\n  /**\n   * Returns the token of the given JavaScript interpolation expression.\n   *\n   * @param {string} expression The code of the expression. E.g. `\"${42}\"`\n   * @returns {Token}\n   */\n\n\n  function tokenizeInterpolationExpression(expression) {\n    var tempGrammar = {};\n    tempGrammar['interpolation-punctuation'] = interpolationPunctuationObject;\n    /** @type {Array} */\n\n    var tokens = Prism.tokenize(expression, tempGrammar);\n\n    if (tokens.length === 3) {\n      /**\n       * The token array will look like this\n       * [\n       *     [\"interpolation-punctuation\", \"${\"]\n       *     \"...\" // JavaScript expression of the interpolation\n       *     [\"interpolation-punctuation\", \"}\"]\n       * ]\n       */\n      var args = [1, 1];\n      args.push.apply(args, tokenizeWithHooks(tokens[1], Prism.languages.javascript, 'javascript'));\n      tokens.splice.apply(tokens, args);\n    }\n\n    return new Prism.Token('interpolation', tokens, interpolationObject.alias, expression);\n  }\n  /**\n   * Tokenizes the given code with support for JavaScript interpolation expressions mixed in.\n   *\n   * This function has 3 phases:\n   *\n   * 1. Replace all JavaScript interpolation expression with a placeholder.\n   *    The placeholder will have the syntax of a identify of the target language.\n   * 2. Tokenize the code with placeholders.\n   * 3. Tokenize the interpolation expressions and re-insert them into the tokenize code.\n   *    The insertion only works if a placeholder hasn't been \"ripped apart\" meaning that the placeholder has been\n   *    tokenized as two tokens by the grammar of the embedded language.\n   *\n   * @param {string} code\n   * @param {object} grammar\n   * @param {string} language\n   * @returns {Token}\n   */\n\n\n  function tokenizeEmbedded(code, grammar, language) {\n    // 1. First filter out all interpolations\n    // because they might be escaped, we need a lookbehind, so we use Prism\n\n    /** @type {(Token|string)[]} */\n    var _tokens = Prism.tokenize(code, {\n      'interpolation': {\n        pattern: RegExp(interpolationPattern),\n        lookbehind: true\n      }\n    }); // replace all interpolations with a placeholder which is not in the code already\n\n\n    var placeholderCounter = 0;\n    /** @type {Object<string, string>} */\n\n    var placeholderMap = {};\n\n    var embeddedCode = _tokens.map(function (token) {\n      if (typeof token === 'string') {\n        return token;\n      } else {\n        var interpolationExpression = token.content;\n        var placeholder;\n\n        while (code.indexOf(placeholder = getPlaceholder(placeholderCounter++, language)) !== -1) {}\n\n        placeholderMap[placeholder] = interpolationExpression;\n        return placeholder;\n      }\n    }).join(''); // 2. Tokenize the embedded code\n\n\n    var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language); // 3. Re-insert the interpolation\n\n    var placeholders = Object.keys(placeholderMap);\n    placeholderCounter = 0;\n    /**\n     *\n     * @param {(Token|string)[]} tokens\n     * @returns {void}\n     */\n\n    function walkTokens(tokens) {\n      for (var i = 0; i < tokens.length; i++) {\n        if (placeholderCounter >= placeholders.length) {\n          return;\n        }\n\n        var token = tokens[i];\n\n        if (typeof token === 'string' || typeof token.content === 'string') {\n          var placeholder = placeholders[placeholderCounter];\n          var s = typeof token === 'string' ? token :\n          /** @type {string} */\n          token.content;\n          var index = s.indexOf(placeholder);\n\n          if (index !== -1) {\n            ++placeholderCounter;\n            var before = s.substring(0, index);\n            var middle = tokenizeInterpolationExpression(placeholderMap[placeholder]);\n            var after = s.substring(index + placeholder.length);\n            var replacement = [];\n\n            if (before) {\n              replacement.push(before);\n            }\n\n            replacement.push(middle);\n\n            if (after) {\n              var afterTokens = [after];\n              walkTokens(afterTokens);\n              replacement.push.apply(replacement, afterTokens);\n            }\n\n            if (typeof token === 'string') {\n              tokens.splice.apply(tokens, [i, 1].concat(replacement));\n              i += replacement.length - 1;\n            } else {\n              token.content = replacement;\n            }\n          }\n        } else {\n          var content = token.content;\n\n          if (Array.isArray(content)) {\n            walkTokens(content);\n          } else {\n            walkTokens([content]);\n          }\n        }\n      }\n    }\n\n    walkTokens(embeddedTokens);\n    return new Prism.Token(language, embeddedTokens, 'language-' + language, code);\n  }\n  /**\n   * The languages for which JS templating will handle tagged template literals.\n   *\n   * JS templating isn't active for only JavaScript but also related languages like TypeScript, JSX, and TSX.\n   */\n\n\n  var supportedLanguages = {\n    'javascript': true,\n    'js': true,\n    'typescript': true,\n    'ts': true,\n    'jsx': true,\n    'tsx': true\n  };\n  Prism.hooks.add('after-tokenize', function (env) {\n    if (!(env.language in supportedLanguages)) {\n      return;\n    }\n    /**\n     * Finds and tokenizes all template strings with an embedded languages.\n     *\n     * @param {(Token | string)[]} tokens\n     * @returns {void}\n     */\n\n\n    function findTemplateStrings(tokens) {\n      for (var i = 0, l = tokens.length; i < l; i++) {\n        var token = tokens[i];\n\n        if (typeof token === 'string') {\n          continue;\n        }\n\n        var content = token.content;\n\n        if (!Array.isArray(content)) {\n          if (typeof content !== 'string') {\n            findTemplateStrings([content]);\n          }\n\n          continue;\n        }\n\n        if (token.type === 'template-string') {\n          /**\n           * A JavaScript template-string token will look like this:\n           *\n           * [\"template-string\", [\n           *     [\"template-punctuation\", \"`\"],\n           *     (\n           *         An array of \"string\" and \"interpolation\" tokens. This is the simple string case.\n           *         or\n           *         [\"embedded-code\", \"...\"] This is the token containing the embedded code.\n           *                                  It also has an alias which is the language of the embedded code.\n           *     ),\n           *     [\"template-punctuation\", \"`\"]\n           * ]]\n           */\n          var embedded = content[1];\n\n          if (content.length === 3 && typeof embedded !== 'string' && embedded.type === 'embedded-code') {\n            // get string content\n            var code = stringContent(embedded);\n            var alias = embedded.alias;\n            var language = Array.isArray(alias) ? alias[0] : alias;\n            var grammar = Prism.languages[language];\n\n            if (!grammar) {\n              // the embedded language isn't registered.\n              continue;\n            }\n\n            content[1] = tokenizeEmbedded(code, grammar, language);\n          }\n        } else {\n          findTemplateStrings(content);\n        }\n      }\n    }\n\n    findTemplateStrings(env.tokens);\n  });\n  /**\n   * Returns the string content of a token or token stream.\n   *\n   * @param {string | Token | (string | Token)[]} value\n   * @returns {string}\n   */\n\n  function stringContent(value) {\n    if (typeof value === 'string') {\n      return value;\n    } else if (Array.isArray(value)) {\n      return value.map(stringContent).join('');\n    } else {\n      return stringContent(value.content);\n    }\n  }\n})(Prism);\n/* \"prismjs/components/prism-graphql\" */\n\n\nPrism.languages.graphql = {\n  'comment': /#.*/,\n  'string': {\n    pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n    greedy: true\n  },\n  'number': /(?:\\B-|\\b)\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n  'boolean': /\\b(?:true|false)\\b/,\n  'variable': /\\$[a-z_]\\w*/i,\n  'directive': {\n    pattern: /@[a-z_]\\w*/i,\n    alias: 'function'\n  },\n  'attr-name': {\n    pattern: /[a-z_]\\w*(?=\\s*(?:\\((?:[^()\"]|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")*\\))?:)/i,\n    greedy: true\n  },\n  'class-name': {\n    pattern: /(\\b(?:enum|implements|interface|on|scalar|type|union)\\s+)[a-zA-Z_]\\w*/,\n    lookbehind: true\n  },\n  'fragment': {\n    pattern: /(\\bfragment\\s+|\\.{3}\\s*(?!on\\b))[a-zA-Z_]\\w*/,\n    lookbehind: true,\n    alias: 'function'\n  },\n  'keyword': /\\b(?:enum|fragment|implements|input|interface|mutation|on|query|scalar|schema|type|union)\\b/,\n  'operator': /[!=|]|\\.{3}/,\n  'punctuation': /[!(){}\\[\\]:=,]/,\n  'constant': /\\b(?!ID\\b)[A-Z][A-Z_\\d]*\\b/\n};\n/* \"prismjs/components/prism-markdown\" */\n\n(function (Prism) {\n  // Allow only one line break\n  var inner = /(?:\\\\.|[^\\\\\\n\\r]|(?:\\r?\\n|\\r)(?!\\r?\\n|\\r))/.source;\n  /**\n   * This function is intended for the creation of the bold or italic pattern.\n   *\n   * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.\n   *\n   * _Note:_ Keep in mind that this adds a capturing group.\n   *\n   * @param {string} pattern\n   * @param {boolean} starAlternative Whether to also add an alternative where all `_`s are replaced with `*`s.\n   * @returns {RegExp}\n   */\n\n  function createInline(pattern, starAlternative) {\n    pattern = pattern.replace(/<inner>/g, inner);\n\n    if (starAlternative) {\n      pattern = pattern + '|' + pattern.replace(/_/g, '\\\\*');\n    }\n\n    return RegExp(/((?:^|[^\\\\])(?:\\\\{2})*)/.source + '(?:' + pattern + ')');\n  }\n\n  var tableCell = /(?:\\\\.|``.+?``|`[^`\\r\\n]+`|[^\\\\|\\r\\n`])+/.source;\n  var tableRow = /\\|?__(?:\\|__)+\\|?(?:(?:\\r?\\n|\\r)|$)/.source.replace(/__/g, tableCell);\n  var tableLine = /\\|?[ \\t]*:?-{3,}:?[ \\t]*(?:\\|[ \\t]*:?-{3,}:?[ \\t]*)+\\|?(?:\\r?\\n|\\r)/.source;\n  Prism.languages.markdown = Prism.languages.extend('markup', {});\n  Prism.languages.insertBefore('markdown', 'prolog', {\n    'blockquote': {\n      // > ...\n      pattern: /^>(?:[\\t ]*>)*/m,\n      alias: 'punctuation'\n    },\n    'table': {\n      pattern: RegExp('^' + tableRow + tableLine + '(?:' + tableRow + ')*', 'm'),\n      inside: {\n        'table-data-rows': {\n          pattern: RegExp('^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$'),\n          lookbehind: true,\n          inside: {\n            'table-data': {\n              pattern: RegExp(tableCell),\n              inside: Prism.languages.markdown\n            },\n            'punctuation': /\\|/\n          }\n        },\n        'table-line': {\n          pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'),\n          lookbehind: true,\n          inside: {\n            'punctuation': /\\||:?-{3,}:?/\n          }\n        },\n        'table-header-row': {\n          pattern: RegExp('^' + tableRow + '$'),\n          inside: {\n            'table-header': {\n              pattern: RegExp(tableCell),\n              alias: 'important',\n              inside: Prism.languages.markdown\n            },\n            'punctuation': /\\|/\n          }\n        }\n      }\n    },\n    'code': [{\n      // Prefixed by 4 spaces or 1 tab and preceded by an empty line\n      pattern: /(^[ \\t]*(?:\\r?\\n|\\r))(?: {4}|\\t).+(?:(?:\\r?\\n|\\r)(?: {4}|\\t).+)*/m,\n      lookbehind: true,\n      alias: 'keyword'\n    }, {\n      // `code`\n      // ``code``\n      pattern: /``.+?``|`[^`\\r\\n]+`/,\n      alias: 'keyword'\n    }, {\n      // ```optional language\n      // code block\n      // ```\n      pattern: /^```[\\s\\S]*?^```$/m,\n      greedy: true,\n      inside: {\n        'code-block': {\n          pattern: /^(```.*(?:\\r?\\n|\\r))[\\s\\S]+?(?=(?:\\r?\\n|\\r)^```$)/m,\n          lookbehind: true\n        },\n        'code-language': {\n          pattern: /^(```).+/,\n          lookbehind: true\n        },\n        'punctuation': /```/\n      }\n    }],\n    'title': [{\n      // title 1\n      // =======\n      // title 2\n      // -------\n      pattern: /\\S.*(?:\\r?\\n|\\r)(?:==+|--+)(?=[ \\t]*$)/m,\n      alias: 'important',\n      inside: {\n        punctuation: /==+$|--+$/\n      }\n    }, {\n      // # title 1\n      // ###### title 6\n      pattern: /(^\\s*)#+.+/m,\n      lookbehind: true,\n      alias: 'important',\n      inside: {\n        punctuation: /^#+|#+$/\n      }\n    }],\n    'hr': {\n      // ***\n      // ---\n      // * * *\n      // -----------\n      pattern: /(^\\s*)([*-])(?:[\\t ]*\\2){2,}(?=\\s*$)/m,\n      lookbehind: true,\n      alias: 'punctuation'\n    },\n    'list': {\n      // * item\n      // + item\n      // - item\n      // 1. item\n      pattern: /(^\\s*)(?:[*+-]|\\d+\\.)(?=[\\t ].)/m,\n      lookbehind: true,\n      alias: 'punctuation'\n    },\n    'url-reference': {\n      // [id]: https://example.com \"Optional title\"\n      // [id]: https://example.com 'Optional title'\n      // [id]: https://example.com (Optional title)\n      // [id]: <https://example.com> \"Optional title\"\n      pattern: /!?\\[[^\\]]+\\]:[\\t ]+(?:\\S+|<(?:\\\\.|[^>\\\\])+>)(?:[\\t ]+(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\)))?/,\n      inside: {\n        'variable': {\n          pattern: /^(!?\\[)[^\\]]+/,\n          lookbehind: true\n        },\n        'string': /(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\))$/,\n        'punctuation': /^[\\[\\]!:]|[<>]/\n      },\n      alias: 'url'\n    },\n    'bold': {\n      // **strong**\n      // __strong__\n      // allow one nested instance of italic text using the same delimiter\n      pattern: createInline(/__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__/.source, true),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'content': {\n          pattern: /(^..)[\\s\\S]+(?=..$)/,\n          lookbehind: true,\n          inside: {} // see below\n\n        },\n        'punctuation': /\\*\\*|__/\n      }\n    },\n    'italic': {\n      // *em*\n      // _em_\n      // allow one nested instance of bold text using the same delimiter\n      pattern: createInline(/_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_/.source, true),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'content': {\n          pattern: /(^.)[\\s\\S]+(?=.$)/,\n          lookbehind: true,\n          inside: {} // see below\n\n        },\n        'punctuation': /[*_]/\n      }\n    },\n    'strike': {\n      // ~~strike through~~\n      // ~strike~\n      pattern: createInline(/(~~?)(?:(?!~)<inner>)+?\\2/.source, false),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'content': {\n          pattern: /(^~~?)[\\s\\S]+(?=\\1$)/,\n          lookbehind: true,\n          inside: {} // see below\n\n        },\n        'punctuation': /~~?/\n      }\n    },\n    'url': {\n      // [example](https://example.com \"Optional title\")\n      // [example][id]\n      // [example] [id]\n      pattern: createInline(/!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\\t ]+\"(?:\\\\.|[^\"\\\\])*\")?\\)| ?\\[(?:(?!\\])<inner>)+\\])/.source, false),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'variable': {\n          pattern: /(\\[)[^\\]]+(?=\\]$)/,\n          lookbehind: true\n        },\n        'content': {\n          pattern: /(^!?\\[)[^\\]]+(?=\\])/,\n          lookbehind: true,\n          inside: {} // see below\n\n        },\n        'string': {\n          pattern: /\"(?:\\\\.|[^\"\\\\])*\"(?=\\)$)/\n        }\n      }\n    }\n  });\n  ['url', 'bold', 'italic', 'strike'].forEach(function (token) {\n    ['url', 'bold', 'italic', 'strike'].forEach(function (inside) {\n      if (token !== inside) {\n        Prism.languages.markdown[token].inside.content.inside[inside] = Prism.languages.markdown[inside];\n      }\n    });\n  });\n  Prism.hooks.add('after-tokenize', function (env) {\n    if (env.language !== 'markdown' && env.language !== 'md') {\n      return;\n    }\n\n    function walkTokens(tokens) {\n      if (!tokens || typeof tokens === 'string') {\n        return;\n      }\n\n      for (var i = 0, l = tokens.length; i < l; i++) {\n        var token = tokens[i];\n\n        if (token.type !== 'code') {\n          walkTokens(token.content);\n          continue;\n        }\n        /*\n         * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token\n         * is optional. But the grammar is defined so that there is only one case we have to handle:\n         *\n         * token.content = [\n         *     <span class=\"punctuation\">```</span>,\n         *     <span class=\"code-language\">xxxx</span>,\n         *     '\\n', // exactly one new lines (\\r or \\n or \\r\\n)\n         *     <span class=\"code-block\">...</span>,\n         *     '\\n', // exactly one new lines again\n         *     <span class=\"punctuation\">```</span>\n         * ];\n         */\n\n\n        var codeLang = token.content[1];\n        var codeBlock = token.content[3];\n\n        if (codeLang && codeBlock && codeLang.type === 'code-language' && codeBlock.type === 'code-block' && typeof codeLang.content === 'string') {\n          // this might be a language that Prism does not support\n          var alias = 'language-' + codeLang.content.trim().split(/\\s+/)[0].toLowerCase(); // add alias\n\n          if (!codeBlock.alias) {\n            codeBlock.alias = [alias];\n          } else if (typeof codeBlock.alias === 'string') {\n            codeBlock.alias = [codeBlock.alias, alias];\n          } else {\n            codeBlock.alias.push(alias);\n          }\n        }\n      }\n    }\n\n    walkTokens(env.tokens);\n  });\n  Prism.hooks.add('wrap', function (env) {\n    if (env.type !== 'code-block') {\n      return;\n    }\n\n    var codeLang = '';\n\n    for (var i = 0, l = env.classes.length; i < l; i++) {\n      var cls = env.classes[i];\n      var match = /language-(.+)/.exec(cls);\n\n      if (match) {\n        codeLang = match[1];\n        break;\n      }\n    }\n\n    var grammar = Prism.languages[codeLang];\n\n    if (!grammar) {\n      if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) {\n        var id = 'md-' + new Date().valueOf() + '-' + Math.floor(Math.random() * 1e16);\n        env.attributes['id'] = id;\n        Prism.plugins.autoloader.loadLanguages(codeLang, function () {\n          var ele = document.getElementById(id);\n\n          if (ele) {\n            ele.innerHTML = Prism.highlight(ele.textContent, Prism.languages[codeLang], codeLang);\n          }\n        });\n      }\n    } else {\n      // reverse Prism.util.encode\n      var code = env.content.replace(/&lt;/g, '<').replace(/&amp;/g, '&');\n      env.content = Prism.highlight(code, grammar, codeLang);\n    }\n  });\n  Prism.languages.md = Prism.languages.markdown;\n})(Prism);\n/* \"prismjs/components/prism-diff\" */\n\n\n(function (Prism) {\n  Prism.languages.diff = {\n    'coord': [// Match all kinds of coord lines (prefixed by \"+++\", \"---\" or \"***\").\n    /^(?:\\*{3}|-{3}|\\+{3}).*$/m, // Match \"@@ ... @@\" coord lines in unified diff.\n    /^@@.*@@$/m, // Match coord lines in normal diff (starts with a number).\n    /^\\d+.*$/m] // deleted, inserted, unchanged, diff\n\n  };\n  /**\n   * A map from the name of a block to its line prefix.\n   *\n   * @type {Object<string, string>}\n   */\n\n  var PREFIXES = {\n    'deleted-sign': '-',\n    'deleted-arrow': '<',\n    'inserted-sign': '+',\n    'inserted-arrow': '>',\n    'unchanged': ' ',\n    'diff': '!'\n  }; // add a token for each prefix\n\n  Object.keys(PREFIXES).forEach(function (name) {\n    var prefix = PREFIXES[name];\n    var alias = [];\n\n    if (!/^\\w+$/.test(name)) {\n      // \"deleted-sign\" -> \"deleted\"\n      alias.push(/\\w+/.exec(name)[0]);\n    }\n\n    if (name === \"diff\") {\n      alias.push(\"bold\");\n    }\n\n    Prism.languages.diff[name] = {\n      // pattern: /^(?:[_].*(?:\\r\\n?|\\n|(?![\\s\\S])))+/m\n      pattern: RegExp('^(?:[' + prefix + '].*(?:\\r\\n?|\\n|(?![\\\\s\\\\S])))+', 'm'),\n      alias: alias\n    };\n  }); // make prefixes available to Diff plugin\n\n  Object.defineProperty(Prism.languages.diff, 'PREFIXES', {\n    value: PREFIXES\n  });\n})(Prism);\n/* \"prismjs/components/prism-git\" */\n\n\nPrism.languages.git = {\n  /*\n   * A simple one line comment like in a git status command\n   * For instance:\n   * $ git status\n   * # On branch infinite-scroll\n   * # Your branch and 'origin/sharedBranches/frontendTeam/infinite-scroll' have diverged,\n   * # and have 1 and 2 different commits each, respectively.\n   * nothing to commit (working directory clean)\n   */\n  'comment': /^#.*/m,\n\n  /*\n   * Regexp to match the changed lines in a git diff output. Check the example below.\n   */\n  'deleted': /^[-–].*/m,\n  'inserted': /^\\+.*/m,\n\n  /*\n   * a string (double and simple quote)\n   */\n  'string': /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/m,\n\n  /*\n   * a git command. It starts with a random prompt finishing by a $, then \"git\" then some other parameters\n   * For instance:\n   * $ git add file.txt\n   */\n  'command': {\n    pattern: /^.*\\$ git .*$/m,\n    inside: {\n      /*\n       * A git command can contain a parameter starting by a single or a double dash followed by a string\n       * For instance:\n       * $ git diff --cached\n       * $ git log -p\n       */\n      'parameter': /\\s--?\\w+/m\n    }\n  },\n\n  /*\n   * Coordinates displayed in a git diff command\n   * For instance:\n   * $ git diff\n   * diff --git file.txt file.txt\n   * index 6214953..1d54a52 100644\n   * --- file.txt\n   * +++ file.txt\n   * @@ -1 +1,2 @@\n   * -Here's my tetx file\n   * +Here's my text file\n   * +And this is the second line\n   */\n  'coord': /^@@.*@@$/m,\n\n  /*\n   * Match a \"commit [SHA1]\" line in a git log output.\n   * For instance:\n   * $ git log\n   * commit a11a14ef7e26f2ca62d4b35eac455ce636d0dc09\n   * Author: lgiraudel\n   * Date:   Mon Feb 17 11:18:34 2014 +0100\n   *\n   *     Add of a new line\n   */\n  'commit_sha1': /^commit \\w{40}$/m\n};\n/* \"prismjs/components/prism-go\" */\n\nPrism.languages.go = Prism.languages.extend('clike', {\n  '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/,\n  'builtin': /\\b(?:bool|byte|complex(?:64|128)|error|float(?:32|64)|rune|string|u?int(?:8|16|32|64)?|uintptr|append|cap|close|complex|copy|delete|imag|len|make|new|panic|print(?:ln)?|real|recover)\\b/,\n  'boolean': /\\b(?:_|iota|nil|true|false)\\b/,\n  'operator': /[*\\/%^!=]=?|\\+[=+]?|-[=-]?|\\|[=|]?|&(?:=|&|\\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\\.\\.\\./,\n  'number': /(?:\\b0x[a-f\\d]+|(?:\\b\\d+\\.?\\d*|\\B\\.\\d+)(?:e[-+]?\\d+)?)i?/i,\n  'string': {\n    pattern: /([\"'`])(\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n    greedy: true\n  }\n});\ndelete Prism.languages.go['class-name'];\n/* \"prismjs/components/prism-handlebars\" */\n\n(function (Prism) {\n  Prism.languages.handlebars = {\n    'comment': /\\{\\{![\\s\\S]*?\\}\\}/,\n    'delimiter': {\n      pattern: /^\\{\\{\\{?|\\}\\}\\}?$/i,\n      alias: 'punctuation'\n    },\n    'string': /([\"'])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    'number': /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+\\.?\\d*|\\B\\.\\d+)(?:[Ee][+-]?\\d+)?/,\n    'boolean': /\\b(?:true|false)\\b/,\n    'block': {\n      pattern: /^(\\s*~?\\s*)[#\\/]\\S+?(?=\\s*~?\\s*$|\\s)/i,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    'brackets': {\n      pattern: /\\[[^\\]]+\\]/,\n      inside: {\n        punctuation: /\\[|\\]/,\n        variable: /[\\s\\S]+/\n      }\n    },\n    'punctuation': /[!\"#%&'()*+,.\\/;<=>@\\[\\\\\\]^`{|}~]/,\n    'variable': /[^!\"#%&'()*+,.\\/;<=>@\\[\\\\\\]^`{|}~\\s]+/\n  };\n  Prism.hooks.add('before-tokenize', function (env) {\n    var handlebarsPattern = /\\{\\{\\{[\\s\\S]+?\\}\\}\\}|\\{\\{[\\s\\S]+?\\}\\}/g;\n    Prism.languages['markup-templating'].buildPlaceholders(env, 'handlebars', handlebarsPattern);\n  });\n  Prism.hooks.add('after-tokenize', function (env) {\n    Prism.languages['markup-templating'].tokenizePlaceholders(env, 'handlebars');\n  });\n})(Prism);\n/* \"prismjs/components/prism-json\" */\n\n\nPrism.languages.json = {\n  'property': {\n    pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"(?=\\s*:)/,\n    greedy: true\n  },\n  'string': {\n    pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"(?!\\s*:)/,\n    greedy: true\n  },\n  'comment': /\\/\\/.*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n  'number': /-?\\d+\\.?\\d*(e[+-]?\\d+)?/i,\n  'punctuation': /[{}[\\],]/,\n  'operator': /:/,\n  'boolean': /\\b(?:true|false)\\b/,\n  'null': {\n    pattern: /\\bnull\\b/,\n    alias: 'keyword'\n  }\n};\n/* \"prismjs/components/prism-less\" */\n\n/* FIXME :\n :extend() is not handled specifically : its highlighting is buggy.\n Mixin usage must be inside a ruleset to be highlighted.\n At-rules (e.g. import) containing interpolations are buggy.\n Detached rulesets are highlighted as at-rules.\n A comment before a mixin usage prevents the latter to be properly highlighted.\n */\n\nPrism.languages.less = Prism.languages.extend('css', {\n  'comment': [/\\/\\*[\\s\\S]*?\\*\\//, {\n    pattern: /(^|[^\\\\])\\/\\/.*/,\n    lookbehind: true\n  }],\n  'atrule': {\n    pattern: /@[\\w-]+?(?:\\([^{}]+\\)|[^(){};])*?(?=\\s*\\{)/i,\n    inside: {\n      'punctuation': /[:()]/\n    }\n  },\n  // selectors and mixins are considered the same\n  'selector': {\n    pattern: /(?:@\\{[\\w-]+\\}|[^{};\\s@])(?:@\\{[\\w-]+\\}|\\([^{}]*\\)|[^{};@])*?(?=\\s*\\{)/,\n    inside: {\n      // mixin parameters\n      'variable': /@+[\\w-]+/\n    }\n  },\n  'property': /(?:@\\{[\\w-]+\\}|[\\w-])+(?:\\+_?)?(?=\\s*:)/i,\n  'operator': /[+\\-*\\/]/\n});\nPrism.languages.insertBefore('less', 'property', {\n  'variable': [// Variable declaration (the colon must be consumed!)\n  {\n    pattern: /@[\\w-]+\\s*:/,\n    inside: {\n      \"punctuation\": /:/\n    }\n  }, // Variable usage\n  /@@?[\\w-]+/],\n  'mixin-usage': {\n    pattern: /([{;]\\s*)[.#](?!\\d)[\\w-]+.*?(?=[(;])/,\n    lookbehind: true,\n    alias: 'function'\n  }\n});\n/* \"prismjs/components/prism-makefile\" */\n\nPrism.languages.makefile = {\n  'comment': {\n    pattern: /(^|[^\\\\])#(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n])*/,\n    lookbehind: true\n  },\n  'string': {\n    pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    greedy: true\n  },\n  // Built-in target names\n  'builtin': /\\.[A-Z][^:#=\\s]+(?=\\s*:(?!=))/,\n  // Targets\n  'symbol': {\n    pattern: /^[^:=\\r\\n]+(?=\\s*:(?!=))/m,\n    inside: {\n      'variable': /\\$+(?:[^(){}:#=\\s]+|(?=[({]))/\n    }\n  },\n  'variable': /\\$+(?:[^(){}:#=\\s]+|\\([@*%<^+?][DF]\\)|(?=[({]))/,\n  'keyword': [// Directives\n  /-include\\b|\\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\\b/, // Functions\n  {\n    pattern: /(\\()(?:addsuffix|abspath|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:s|list)?)(?=[ \\t])/,\n    lookbehind: true\n  }],\n  'operator': /(?:::|[?:+!])?=|[|@]/,\n  'punctuation': /[:;(){}]/\n};\n/* \"prismjs/components/prism-objectivec\" */\n\nPrism.languages.objectivec = Prism.languages.extend('c', {\n  'keyword': /\\b(?:asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while|in|self|super)\\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\\b/,\n  'string': /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1|@\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"/,\n  'operator': /-[->]?|\\+\\+?|!=?|<<?=?|>>?=?|==?|&&?|\\|\\|?|[~^%?*\\/@]/\n});\ndelete Prism.languages.objectivec['class-name'];\n/* \"prismjs/components/prism-ocaml\" */\n\nPrism.languages.ocaml = {\n  'comment': /\\(\\*[\\s\\S]*?\\*\\)/,\n  'string': [{\n    pattern: /\"(?:\\\\.|[^\\\\\\r\\n\"])*\"/,\n    greedy: true\n  }, {\n    pattern: /(['`])(?:\\\\(?:\\d+|x[\\da-f]+|.)|(?!\\1)[^\\\\\\r\\n])\\1/i,\n    greedy: true\n  }],\n  'number': /\\b(?:0x[\\da-f][\\da-f_]+|(?:0[bo])?\\d[\\d_]*\\.?[\\d_]*(?:e[+-]?[\\d_]+)?)/i,\n  'type': {\n    pattern: /\\B['`]\\w*/,\n    alias: 'variable'\n  },\n  'directive': {\n    pattern: /\\B#\\w+/,\n    alias: 'function'\n  },\n  '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|object|of|open|prefix|private|rec|then|sig|struct|to|try|type|val|value|virtual|where|while|with)\\b/,\n  'boolean': /\\b(?:false|true)\\b/,\n  // Custom operators are allowed\n  'operator': /:=|[=<>@^|&+\\-*\\/$%!?~][!$%&*+\\-.\\/:<=>?@^|~]*|\\b(?:and|asr|land|lor|lxor|lsl|lsr|mod|nor|or)\\b/,\n  'punctuation': /[(){}\\[\\]|_.,:;]/\n};\n/* \"prismjs/components/prism-python\" */\n\nPrism.languages.python = {\n  'comment': {\n    pattern: /(^|[^\\\\])#.*/,\n    lookbehind: true\n  },\n  'string-interpolation': {\n    pattern: /(?:f|rf|fr)(?:(\"\"\"|''')[\\s\\S]+?\\1|(\"|')(?:\\\\.|(?!\\2)[^\\\\\\r\\n])*\\2)/i,\n    greedy: true,\n    inside: {\n      'interpolation': {\n        // \"{\" <expression> <optional \"!s\", \"!r\", or \"!a\"> <optional \":\" format specifier> \"}\"\n        pattern: /((?:^|[^{])(?:{{)*){(?!{)(?:[^{}]|{(?!{)(?:[^{}]|{(?!{)(?:[^{}])+})+})+}/,\n        lookbehind: true,\n        inside: {\n          'format-spec': {\n            pattern: /(:)[^:(){}]+(?=}$)/,\n            lookbehind: true\n          },\n          'conversion-option': {\n            pattern: /![sra](?=[:}]$)/,\n            alias: 'punctuation'\n          },\n          rest: null\n        }\n      },\n      'string': /[\\s\\S]+/\n    }\n  },\n  'triple-quoted-string': {\n    pattern: /(?:[rub]|rb|br)?(\"\"\"|''')[\\s\\S]+?\\1/i,\n    greedy: true,\n    alias: 'string'\n  },\n  'string': {\n    pattern: /(?:[rub]|rb|br)?(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/i,\n    greedy: true\n  },\n  'function': {\n    pattern: /((?:^|\\s)def[ \\t]+)[a-zA-Z_]\\w*(?=\\s*\\()/g,\n    lookbehind: true\n  },\n  'class-name': {\n    pattern: /(\\bclass\\s+)\\w+/i,\n    lookbehind: true\n  },\n  'decorator': {\n    pattern: /(^\\s*)@\\w+(?:\\.\\w+)*/i,\n    lookbehind: true,\n    alias: ['annotation', 'punctuation'],\n    inside: {\n      'punctuation': /\\./\n    }\n  },\n  'keyword': /\\b(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\\b/,\n  '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/,\n  'boolean': /\\b(?:True|False|None)\\b/,\n  'number': /(?:\\b(?=\\d)|\\B(?=\\.))(?:0[bo])?(?:(?:\\d|0x[\\da-f])[\\da-f]*\\.?\\d*|\\.\\d+)(?:e[+-]?\\d+)?j?\\b/i,\n  'operator': /[-+%=]=?|!=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,\n  'punctuation': /[{}[\\];(),.:]/\n};\nPrism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python;\nPrism.languages.py = Prism.languages.python;\n/* \"prismjs/components/prism-reason\" */\n\nPrism.languages.reason = Prism.languages.extend('clike', {\n  'comment': {\n    pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n    lookbehind: true\n  },\n  'string': {\n    pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n\"])*\"/,\n    greedy: true\n  },\n  // 'class-name' must be matched *after* 'constructor' defined below\n  'class-name': /\\b[A-Z]\\w*/,\n  'keyword': /\\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\\b/,\n  'operator': /\\.{3}|:[:=]|\\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\\-*\\/]\\.?|\\b(?:mod|land|lor|lxor|lsl|lsr|asr)\\b/\n});\nPrism.languages.insertBefore('reason', 'class-name', {\n  'character': {\n    pattern: /'(?:\\\\x[\\da-f]{2}|\\\\o[0-3][0-7][0-7]|\\\\\\d{3}|\\\\.|[^'\\\\\\r\\n])'/,\n    alias: 'string'\n  },\n  'constructor': {\n    // Negative look-ahead prevents from matching things like String.capitalize\n    pattern: /\\b[A-Z]\\w*\\b(?!\\s*\\.)/,\n    alias: 'variable'\n  },\n  'label': {\n    pattern: /\\b[a-z]\\w*(?=::)/,\n    alias: 'symbol'\n  }\n}); // We can't match functions property, so let's not even try.\n\ndelete Prism.languages.reason.function;\n/* \"prismjs/components/prism-sass\" */\n\n(function (Prism) {\n  Prism.languages.sass = Prism.languages.extend('css', {\n    // Sass comments don't need to be closed, only indented\n    'comment': {\n      pattern: /^([ \\t]*)\\/[\\/*].*(?:(?:\\r?\\n|\\r)\\1[ \\t]+.+)*/m,\n      lookbehind: true\n    }\n  });\n  Prism.languages.insertBefore('sass', 'atrule', {\n    // We want to consume the whole line\n    'atrule-line': {\n      // Includes support for = and + shortcuts\n      pattern: /^(?:[ \\t]*)[@+=].+/m,\n      inside: {\n        'atrule': /(?:@[\\w-]+|[+=])/m\n      }\n    }\n  });\n  delete Prism.languages.sass.atrule;\n  var variable = /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/;\n  var operator = [/[+*\\/%]|[=!]=|<=?|>=?|\\b(?:and|or|not)\\b/, {\n    pattern: /(\\s+)-(?=\\s)/,\n    lookbehind: true\n  }];\n  Prism.languages.insertBefore('sass', 'property', {\n    // We want to consume the whole line\n    'variable-line': {\n      pattern: /^[ \\t]*\\$.+/m,\n      inside: {\n        'punctuation': /:/,\n        'variable': variable,\n        'operator': operator\n      }\n    },\n    // We want to consume the whole line\n    'property-line': {\n      pattern: /^[ \\t]*(?:[^:\\s]+ *:.*|:[^:\\s]+.*)/m,\n      inside: {\n        'property': [/[^:\\s]+(?=\\s*:)/, {\n          pattern: /(:)[^:\\s]+/,\n          lookbehind: true\n        }],\n        'punctuation': /:/,\n        'variable': variable,\n        'operator': operator,\n        'important': Prism.languages.sass.important\n      }\n    }\n  });\n  delete Prism.languages.sass.property;\n  delete Prism.languages.sass.important; // Now that whole lines for other patterns are consumed,\n  // what's left should be selectors\n\n  Prism.languages.insertBefore('sass', 'punctuation', {\n    'selector': {\n      pattern: /([ \\t]*)\\S(?:,?[^,\\r\\n]+)*(?:,(?:\\r?\\n|\\r)\\1[ \\t]+\\S(?:,?[^,\\r\\n]+)*)*/,\n      lookbehind: true\n    }\n  });\n})(Prism);\n/* \"prismjs/components/prism-scss\" */\n\n\nPrism.languages.scss = Prism.languages.extend('css', {\n  'comment': {\n    pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n    lookbehind: true\n  },\n  'atrule': {\n    pattern: /@[\\w-]+(?:\\([^()]+\\)|[^(])*?(?=\\s+[{;])/,\n    inside: {\n      'rule': /@[\\w-]+/ // See rest below\n\n    }\n  },\n  // url, compassified\n  'url': /(?:[-a-z]+-)?url(?=\\()/i,\n  // CSS selector regex is not appropriate for Sass\n  // since there can be lot more things (var, @ directive, nesting..)\n  // a selector must start at the end of a property or after a brace (end of other rules or nesting)\n  // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable\n  // 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\n  // can \"pass\" as a selector- e.g: proper#{$erty})\n  // this one was hard to do, so please be careful if you edit this one :)\n  'selector': {\n    // Initial look-ahead is used to prevent matching of blank selectors\n    pattern: /(?=\\S)[^@;{}()]?(?:[^@;{}()]|#\\{\\$[-\\w]+\\})+(?=\\s*\\{(?:\\}|\\s|[^}]+[:{][^}]+))/m,\n    inside: {\n      'parent': {\n        pattern: /&/,\n        alias: 'important'\n      },\n      'placeholder': /%[-\\w]+/,\n      'variable': /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n    }\n  },\n  'property': {\n    pattern: /(?:[\\w-]|\\$[-\\w]+|#\\{\\$[-\\w]+\\})+(?=\\s*:)/,\n    inside: {\n      'variable': /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n    }\n  }\n});\nPrism.languages.insertBefore('scss', 'atrule', {\n  'keyword': [/@(?:if|else(?: if)?|for|each|while|import|extend|debug|warn|mixin|include|function|return|content)/i, {\n    pattern: /( +)(?:from|through)(?= )/,\n    lookbehind: true\n  }]\n});\nPrism.languages.insertBefore('scss', 'important', {\n  // var and interpolated vars\n  'variable': /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n});\nPrism.languages.insertBefore('scss', 'function', {\n  'placeholder': {\n    pattern: /%[-\\w]+/,\n    alias: 'selector'\n  },\n  'statement': {\n    pattern: /\\B!(?:default|optional)\\b/i,\n    alias: 'keyword'\n  },\n  'boolean': /\\b(?:true|false)\\b/,\n  'null': {\n    pattern: /\\bnull\\b/,\n    alias: 'keyword'\n  },\n  'operator': {\n    pattern: /(\\s)(?:[-+*\\/%]|[=!]=|<=?|>=?|and|or|not)(?=\\s)/,\n    lookbehind: true\n  }\n});\nPrism.languages.scss['atrule'].inside.rest = Prism.languages.scss;\n/* \"prismjs/components/prism-sql\" */\n\nPrism.languages.sql = {\n  'comment': {\n    pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:--|\\/\\/|#).*)/,\n    lookbehind: true\n  },\n  'variable': [{\n    pattern: /@([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1/,\n    greedy: true\n  }, /@[\\w.$]+/],\n  'string': {\n    pattern: /(^|[^@\\\\])(\"|')(?:\\\\[\\s\\S]|(?!\\2)[^\\\\]|\\2\\2)*\\2/,\n    greedy: true,\n    lookbehind: true\n  },\n  'function': /\\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\\s*\\()/i,\n  // Should we highlight user defined functions too?\n  'keyword': /\\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:_INSERT|COL)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURNS?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\\b/i,\n  'boolean': /\\b(?:TRUE|FALSE|NULL)\\b/i,\n  'number': /\\b0x[\\da-f]+\\b|\\b\\d+\\.?\\d*|\\B\\.\\d+\\b/i,\n  'operator': /[-+*\\/=%^~]|&&?|\\|\\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\\b(?:AND|BETWEEN|IN|LIKE|NOT|OR|IS|DIV|REGEXP|RLIKE|SOUNDS LIKE|XOR)\\b/i,\n  'punctuation': /[;[\\]()`,.]/\n};\n/* \"prismjs/components/prism-stylus\" */\n\n(function (Prism) {\n  var inside = {\n    'url': /url\\(([\"']?).*?\\1\\)/i,\n    'string': {\n      pattern: /(\"|')(?:(?!\\1)[^\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\\1/,\n      greedy: true\n    },\n    'interpolation': null,\n    // See below\n    'func': null,\n    // See below\n    'important': /\\B!(?:important|optional)\\b/i,\n    'keyword': {\n      pattern: /(^|\\s+)(?:(?:if|else|for|return|unless)(?=\\s+|$)|@[\\w-]+)/,\n      lookbehind: true\n    },\n    'hexcode': /#[\\da-f]{3,6}/i,\n    'number': /\\b\\d+(?:\\.\\d+)?%?/,\n    'boolean': /\\b(?:true|false)\\b/,\n    'operator': [// We want non-word chars around \"-\" because it is\n    // accepted in property names.\n    /~|[+!\\/%<>?=]=?|[-:]=|\\*[*=]?|\\.+|&&|\\|\\||\\B-\\B|\\b(?:and|in|is(?: a| defined| not|nt)?|not|or)\\b/],\n    'punctuation': /[{}()\\[\\];:,]/\n  };\n  inside['interpolation'] = {\n    pattern: /\\{[^\\r\\n}:]+\\}/,\n    alias: 'variable',\n    inside: {\n      'delimiter': {\n        pattern: /^{|}$/,\n        alias: 'punctuation'\n      },\n      rest: inside\n    }\n  };\n  inside['func'] = {\n    pattern: /[\\w-]+\\([^)]*\\).*/,\n    inside: {\n      'function': /^[^(]+/,\n      rest: inside\n    }\n  };\n  Prism.languages.stylus = {\n    'comment': {\n      pattern: /(^|[^\\\\])(\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true\n    },\n    'atrule-declaration': {\n      pattern: /(^\\s*)@.+/m,\n      lookbehind: true,\n      inside: {\n        'atrule': /^@[\\w-]+/,\n        rest: inside\n      }\n    },\n    'variable-declaration': {\n      pattern: /(^[ \\t]*)[\\w$-]+\\s*.?=[ \\t]*(?:(?:\\{[^}]*\\}|.+)|$)/m,\n      lookbehind: true,\n      inside: {\n        'variable': /^\\S+/,\n        rest: inside\n      }\n    },\n    'statement': {\n      pattern: /(^[ \\t]*)(?:if|else|for|return|unless)[ \\t]+.+/m,\n      lookbehind: true,\n      inside: {\n        keyword: /^\\S+/,\n        rest: inside\n      }\n    },\n    // A property/value pair cannot end with a comma or a brace\n    // It cannot have indented content unless it ended with a semicolon\n    'property-declaration': {\n      pattern: /((?:^|\\{)([ \\t]*))(?:[\\w-]|\\{[^}\\r\\n]+\\})+(?:\\s*:\\s*|[ \\t]+)[^{\\r\\n]*(?:;|[^{\\r\\n,](?=$)(?!(\\r?\\n|\\r)(?:\\{|\\2[ \\t]+)))/m,\n      lookbehind: true,\n      inside: {\n        'property': {\n          pattern: /^[^\\s:]+/,\n          inside: {\n            'interpolation': inside.interpolation\n          }\n        },\n        rest: inside\n      }\n    },\n    // A selector can contain parentheses only as part of a pseudo-element\n    // It can span multiple lines.\n    // It must end with a comma or an accolade or have indented content.\n    'selector': {\n      pattern: /(^[ \\t]*)(?:(?=\\S)(?:[^{}\\r\\n:()]|::?[\\w-]+(?:\\([^)\\r\\n]*\\))?|\\{[^}\\r\\n]+\\})+)(?:(?:\\r?\\n|\\r)(?:\\1(?:(?=\\S)(?:[^{}\\r\\n:()]|::?[\\w-]+(?:\\([^)\\r\\n]*\\))?|\\{[^}\\r\\n]+\\})+)))*(?:,$|\\{|(?=(?:\\r?\\n|\\r)(?:\\{|\\1[ \\t]+)))/m,\n      lookbehind: true,\n      inside: {\n        'interpolation': inside.interpolation,\n        'punctuation': /[{},]/\n      }\n    },\n    'func': inside.func,\n    'string': inside.string,\n    'interpolation': inside.interpolation,\n    'punctuation': /[{}()\\[\\];:.]/\n  };\n})(Prism);\n/* \"prismjs/components/prism-tsx\" */\n\n\nvar typescript = Prism.util.clone(Prism.languages.typescript);\nPrism.languages.tsx = Prism.languages.extend('jsx', typescript);\n/* \"prismjs/components/prism-wasm\" */\n\nPrism.languages.wasm = {\n  'comment': [/\\(;[\\s\\S]*?;\\)/, {\n    pattern: /;;.*/,\n    greedy: true\n  }],\n  'string': {\n    pattern: /\"(?:\\\\[\\s\\S]|[^\"\\\\])*\"/,\n    greedy: true\n  },\n  'keyword': [{\n    pattern: /\\b(?:align|offset)=/,\n    inside: {\n      'operator': /=/\n    }\n  }, {\n    pattern: /\\b(?:(?:f32|f64|i32|i64)(?:\\.(?:abs|add|and|ceil|clz|const|convert_[su]\\/i(?:32|64)|copysign|ctz|demote\\/f64|div(?:_[su])?|eqz?|extend_[su]\\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|nearest|neg?|or|popcnt|promote\\/f32|reinterpret\\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|store(?:8|16|32)?|sqrt|sub|trunc(?:_[su]\\/f(?:32|64))?|wrap\\/i64|xor))?|memory\\.(?:grow|size))\\b/,\n    inside: {\n      'punctuation': /\\./\n    }\n  }, /\\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\\b/],\n  'variable': /\\$[\\w!#$%&'*+\\-./:<=>?@\\\\^_`|~]+/i,\n  'number': /[+-]?\\b(?:\\d(?:_?\\d)*(?:\\.\\d(?:_?\\d)*)?(?:[eE][+-]?\\d(?:_?\\d)*)?|0x[\\da-fA-F](?:_?[\\da-fA-F])*(?:\\.[\\da-fA-F](?:_?[\\da-fA-D])*)?(?:[pP][+-]?\\d(?:_?\\d)*)?)\\b|\\binf\\b|\\bnan(?::0x[\\da-fA-F](?:_?[\\da-fA-D])*)?\\b/,\n  'punctuation': /[()]/\n};\n/* \"prismjs/components/prism-yaml\" */\n\nPrism.languages.yaml = {\n  'scalar': {\n    pattern: /([\\-:]\\s*(?:![^\\s]+)?[ \\t]*[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)[^\\r\\n]+(?:\\2[^\\r\\n]+)*)/,\n    lookbehind: true,\n    alias: 'string'\n  },\n  'comment': /#.*/,\n  'key': {\n    pattern: /(\\s*(?:^|[:\\-,[{\\r\\n?])[ \\t]*(?:![^\\s]+)?[ \\t]*)[^\\r\\n{[\\]},#\\s]+?(?=\\s*:\\s)/,\n    lookbehind: true,\n    alias: 'atrule'\n  },\n  'directive': {\n    pattern: /(^[ \\t]*)%.+/m,\n    lookbehind: true,\n    alias: 'important'\n  },\n  'datetime': {\n    pattern: /([:\\-,[{]\\s*(?:![^\\s]+)?[ \\t]*)(?:\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?[ \\t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?)?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?)(?=[ \\t]*(?:$|,|]|}))/m,\n    lookbehind: true,\n    alias: 'number'\n  },\n  'boolean': {\n    pattern: /([:\\-,[{]\\s*(?:![^\\s]+)?[ \\t]*)(?:true|false)[ \\t]*(?=$|,|]|})/im,\n    lookbehind: true,\n    alias: 'important'\n  },\n  'null': {\n    pattern: /([:\\-,[{]\\s*(?:![^\\s]+)?[ \\t]*)(?:null|~)[ \\t]*(?=$|,|]|})/im,\n    lookbehind: true,\n    alias: 'important'\n  },\n  'string': {\n    pattern: /([:\\-,[{]\\s*(?:![^\\s]+)?[ \\t]*)(\"|')(?:(?!\\2)[^\\\\\\r\\n]|\\\\.)*\\2(?=[ \\t]*(?:$|,|]|}|\\s*#))/m,\n    lookbehind: true,\n    greedy: true\n  },\n  'number': {\n    pattern: /([:\\-,[{]\\s*(?:![^\\s]+)?[ \\t]*)[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+\\.?\\d*|\\.?\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)[ \\t]*(?=$|,|]|})/im,\n    lookbehind: true\n  },\n  'tag': /![^\\s]+/,\n  'important': /[&*][\\w]+/,\n  'punctuation': /---|[:[\\]{}\\-,|>?]|\\.\\.\\./\n};\nPrism.languages.yml = Prism.languages.yaml;\nexport default Prism;","// Duotone Dark\n// Author: Simurai, adapted from DuoTone themes for Atom (https://simurai.com/projects/2016/01/01/duotone-themes)\n// Conversion: Bram de Haan (https://atelierbram.github.io/Base2Tone-prism/output/prism/prism-base2tone-evening-dark.css)\n// Generated with Base16 Builder (https://github.com/base16-builder/base16-builder)\nvar theme = {\n  plain: {\n    backgroundColor: \"#2a2734\",\n    color: \"#9a86fd\"\n  },\n  styles: [{\n    types: [\"comment\", \"prolog\", \"doctype\", \"cdata\", \"punctuation\"],\n    style: {\n      color: \"#6c6783\"\n    }\n  }, {\n    types: [\"namespace\"],\n    style: {\n      opacity: 0.7\n    }\n  }, {\n    types: [\"tag\", \"operator\", \"number\"],\n    style: {\n      color: \"#e09142\"\n    }\n  }, {\n    types: [\"property\", \"function\"],\n    style: {\n      color: \"#9a86fd\"\n    }\n  }, {\n    types: [\"tag-id\", \"selector\", \"atrule-id\"],\n    style: {\n      color: \"#eeebff\"\n    }\n  }, {\n    types: [\"attr-name\"],\n    style: {\n      color: \"#c4b9fe\"\n    }\n  }, {\n    types: [\"boolean\", \"string\", \"entity\", \"url\", \"attr-value\", \"keyword\", \"control\", \"directive\", \"unit\", \"statement\", \"regex\", \"at-rule\", \"placeholder\", \"variable\"],\n    style: {\n      color: \"#ffcc99\"\n    }\n  }, {\n    types: [\"deleted\"],\n    style: {\n      textDecorationLine: \"line-through\"\n    }\n  }, {\n    types: [\"inserted\"],\n    style: {\n      textDecorationLine: \"underline\"\n    }\n  }, {\n    types: [\"italic\"],\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"important\", \"bold\"],\n    style: {\n      fontWeight: \"bold\"\n    }\n  }, {\n    types: [\"important\"],\n    style: {\n      color: \"#c4b9fe\"\n    }\n  }]\n};\nexport default theme;","import \"core-js/modules/es.array.reduce\";\nimport Prism from '../prism/index.js';\nexport { default as Prism } from '../prism/index.js';\nimport theme from '../themes/duotoneDark';\nimport { Component } from 'react';\nvar defaultProps = {\n  // $FlowFixMe\n  Prism: Prism,\n  theme: theme\n};\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nvar newlineRe = /\\r\\n|\\r|\\n/; // Empty lines need to contain a single empty token, denoted with { empty: true }\n\nvar normalizeEmptyLines = function normalizeEmptyLines(line) {\n  if (line.length === 0) {\n    line.push({\n      types: [\"plain\"],\n      content: \"\",\n      empty: true\n    });\n  } else if (line.length === 1 && line[0].content === \"\") {\n    line[0].empty = true;\n  }\n};\n\nvar appendTypes = function appendTypes(types, add) {\n  var typesSize = types.length;\n\n  if (typesSize > 0 && types[typesSize - 1] === add) {\n    return types;\n  }\n\n  return types.concat(add);\n}; // Takes an array of Prism's tokens and groups them by line, turning plain\n// strings into tokens as well. Tokens can become recursive in some cases,\n// which means that their types are concatenated. Plain-string tokens however\n// are always of type \"plain\".\n// This is not recursive to avoid exceeding the call-stack limit, since it's unclear\n// how nested Prism's tokens can become\n\n\nvar normalizeTokens = function normalizeTokens(tokens) {\n  var typeArrStack = [[]];\n  var tokenArrStack = [tokens];\n  var tokenArrIndexStack = [0];\n  var tokenArrSizeStack = [tokens.length];\n  var i = 0;\n  var stackIndex = 0;\n  var currentLine = [];\n  var acc = [currentLine];\n\n  while (stackIndex > -1) {\n    while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {\n      var content = void 0;\n      var types = typeArrStack[stackIndex];\n      var tokenArr = tokenArrStack[stackIndex];\n      var token = tokenArr[i]; // Determine content and append type to types if necessary\n\n      if (typeof token === \"string\") {\n        types = stackIndex > 0 ? types : [\"plain\"];\n        content = token;\n      } else {\n        types = appendTypes(types, token.type);\n\n        if (token.alias) {\n          types = appendTypes(types, token.alias);\n        }\n\n        content = token.content;\n      } // If token.content is an array, increase the stack depth and repeat this while-loop\n\n\n      if (typeof content !== \"string\") {\n        stackIndex++;\n        typeArrStack.push(types);\n        tokenArrStack.push(content);\n        tokenArrIndexStack.push(0);\n        tokenArrSizeStack.push(content.length);\n        continue;\n      } // Split by newlines\n\n\n      var splitByNewlines = content.split(newlineRe);\n      var newlineCount = splitByNewlines.length;\n      currentLine.push({\n        types: types,\n        content: splitByNewlines[0]\n      }); // Create a new line for each string on a new line\n\n      for (var i$1 = 1; i$1 < newlineCount; i$1++) {\n        normalizeEmptyLines(currentLine);\n        acc.push(currentLine = []);\n        currentLine.push({\n          types: types,\n          content: splitByNewlines[i$1]\n        });\n      }\n    } // Decreate the stack depth\n\n\n    stackIndex--;\n    typeArrStack.pop();\n    tokenArrStack.pop();\n    tokenArrIndexStack.pop();\n    tokenArrSizeStack.pop();\n  }\n\n  normalizeEmptyLines(currentLine);\n  return acc;\n};\n\nvar themeToDict = function themeToDict(theme, language) {\n  var plain = theme.plain; // $FlowFixMe\n\n  var base = Object.create(null);\n  var themeDict = theme.styles.reduce(function (acc, themeEntry) {\n    var languages = themeEntry.languages;\n    var style = themeEntry.style;\n\n    if (languages && !languages.includes(language)) {\n      return acc;\n    }\n\n    themeEntry.types.forEach(function (type) {\n      // $FlowFixMe\n      var accStyle = _extends({}, acc[type], style);\n\n      acc[type] = accStyle;\n    });\n    return acc;\n  }, base); // $FlowFixMe\n\n  themeDict.root = plain; // $FlowFixMe\n\n  themeDict.plain = _extends({}, plain, {\n    backgroundColor: null\n  });\n  return themeDict;\n};\n\nfunction objectWithoutProperties(obj, exclude) {\n  var target = {};\n\n  for (var k in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) target[k] = obj[k];\n  }\n\n  return target;\n}\n\nvar Highlight = /*@__PURE__*/function (Component) {\n  function Highlight() {\n    var this$1 = this;\n    var args = [],\n        len = arguments.length;\n\n    while (len--) {\n      args[len] = arguments[len];\n    }\n\n    Component.apply(this, args);\n\n    _defineProperty(this, \"getThemeDict\", function (props) {\n      if (this$1.themeDict !== undefined && props.theme === this$1.prevTheme && props.language === this$1.prevLanguage) {\n        return this$1.themeDict;\n      }\n\n      this$1.prevTheme = props.theme;\n      this$1.prevLanguage = props.language;\n      var themeDict = props.theme ? themeToDict(props.theme, props.language) : undefined;\n      return this$1.themeDict = themeDict;\n    });\n\n    _defineProperty(this, \"getLineProps\", function (ref) {\n      var key = ref.key;\n      var className = ref.className;\n      var style = ref.style;\n      var rest$1 = objectWithoutProperties(ref, [\"key\", \"className\", \"style\", \"line\"]);\n      var rest = rest$1;\n\n      var output = _extends({}, rest, {\n        className: \"token-line\",\n        style: undefined,\n        key: undefined\n      });\n\n      var themeDict = this$1.getThemeDict(this$1.props);\n\n      if (themeDict !== undefined) {\n        output.style = themeDict.plain;\n      }\n\n      if (style !== undefined) {\n        output.style = output.style !== undefined ? _extends({}, output.style, style) : style;\n      }\n\n      if (key !== undefined) {\n        output.key = key;\n      }\n\n      if (className) {\n        output.className += \" \" + className;\n      }\n\n      return output;\n    });\n\n    _defineProperty(this, \"getStyleForToken\", function (ref) {\n      var types = ref.types;\n      var empty = ref.empty;\n      var typesSize = types.length;\n      var themeDict = this$1.getThemeDict(this$1.props);\n\n      if (themeDict === undefined) {\n        return undefined;\n      } else if (typesSize === 1 && types[0] === \"plain\") {\n        return empty ? {\n          display: \"inline-block\"\n        } : undefined;\n      } else if (typesSize === 1 && !empty) {\n        return themeDict[types[0]];\n      }\n\n      var baseStyle = empty ? {\n        display: \"inline-block\"\n      } : {}; // $FlowFixMe\n\n      var typeStyles = types.map(function (type) {\n        return themeDict[type];\n      });\n      return Object.assign.apply(Object, [baseStyle].concat(typeStyles));\n    });\n\n    _defineProperty(this, \"getTokenProps\", function (ref) {\n      var key = ref.key;\n      var className = ref.className;\n      var style = ref.style;\n      var token = ref.token;\n      var rest$1 = objectWithoutProperties(ref, [\"key\", \"className\", \"style\", \"token\"]);\n      var rest = rest$1;\n\n      var output = _extends({}, rest, {\n        className: \"token \" + token.types.join(\" \"),\n        children: token.content,\n        style: this$1.getStyleForToken(token),\n        key: undefined\n      });\n\n      if (style !== undefined) {\n        output.style = output.style !== undefined ? _extends({}, output.style, style) : style;\n      }\n\n      if (key !== undefined) {\n        output.key = key;\n      }\n\n      if (className) {\n        output.className += \" \" + className;\n      }\n\n      return output;\n    });\n  }\n\n  if (Component) Highlight.__proto__ = Component;\n  Highlight.prototype = Object.create(Component && Component.prototype);\n  Highlight.prototype.constructor = Highlight;\n\n  Highlight.prototype.render = function render() {\n    var ref = this.props;\n    var Prism = ref.Prism;\n    var language = ref.language;\n    var code = ref.code;\n    var children = ref.children;\n    var themeDict = this.getThemeDict(this.props);\n    var grammar = Prism.languages[language];\n    var mixedTokens = grammar !== undefined ? Prism.tokenize(code, grammar, language) : [code];\n    var tokens = normalizeTokens(mixedTokens);\n    return children({\n      tokens: tokens,\n      className: \"prism-code language-\" + language,\n      style: themeDict !== undefined ? themeDict.root : {},\n      getLineProps: this.getLineProps,\n      getTokenProps: this.getTokenProps\n    });\n  };\n\n  return Highlight;\n}(Component);\n\nexport default Highlight;\nexport { defaultProps };","import Highlight, { defaultProps } from 'prism-react-renderer';\nimport { jsx, Styled } from 'theme-ui';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\nfunction _slicedToArray(arr, i) {\n  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n}\n\nfunction _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === \"[object Arguments]\")) {\n    return;\n  }\n\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nfunction _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n}\n\nvar aliases = {\n  js: 'javascript',\n  sh: 'bash'\n};\n\nvar index = function index(_ref) {\n  var children = _ref.children,\n      outerClassName = _ref.className,\n      props = _objectWithoutProperties(_ref, [\"children\", \"className\", \"title\"]);\n\n  var _outerClassName$repla = outerClassName.replace(/language-/, '').split(' '),\n      _outerClassName$repla2 = _slicedToArray(_outerClassName$repla, 1),\n      language = _outerClassName$repla2[0];\n\n  var lang = aliases[language] || language;\n  return jsx(Highlight, _extends({}, defaultProps, props, {\n    code: children.trim(),\n    language: lang,\n    theme: undefined\n  }), function (_ref2) {\n    var className = _ref2.className,\n        style = _ref2.style,\n        tokens = _ref2.tokens,\n        getLineProps = _ref2.getLineProps,\n        getTokenProps = _ref2.getTokenProps;\n    return jsx(Styled.pre, {\n      className: \"\".concat(outerClassName, \" \").concat(className),\n      style: style\n    }, tokens.map(function (line, i) {\n      return jsx(\"div\", getLineProps({\n        line: line,\n        key: i\n      }), line.map(function (token, key) {\n        return jsx(\"span\", _extends({}, getTokenProps({\n          token: token,\n          key: key\n        }), {\n          sx: {\n            display: 'inline-block'\n          }\n        }));\n      }));\n    }));\n  });\n};\n\nexport default index;"],"sourceRoot":""}