{"version":3,"sources":["../node_modules/prism-react-renderer/themes/dracula.js","../node_modules/prism-react-renderer/es/vendor/prism/index.js","../node_modules/prism-react-renderer/es/defaultProps.js","../node_modules/prism-react-renderer/es/utils/normalizeTokens.js","../node_modules/prism-react-renderer/es/utils/themeToDict.js","../node_modules/prism-react-renderer/es/components/Highlight.js","../node_modules/prism-react-renderer/es/index.js","../node_modules/react-bootstrap/es/Col.js","../node_modules/react-bootstrap/es/Row.js","../node_modules/prism-react-renderer/es/vendor/prism/prism-core.js","../node_modules/prism-react-renderer/themes/duotoneDark.js"],"names":["module","exports","plain","color","backgroundColor","styles","types","style","fontStyle","Prism","prism_core_default","a","languages","markup","comment","prolog","doctype","cdata","tag","pattern","greedy","inside","punctuation","namespace","attr-value","lookbehind","attr-name","entity","hooks","add","env","type","attributes","content","replace","Object","defineProperty","value","tagName","lang","includedCdataInside","included-cdata","def","RegExp","source","insertBefore","xml","extend","html","mathml","svg","insideString","variable","number","operator","bash","shebang","alias","string","function","keyword","boolean","shell","clike","class-name","c","macro","directive","constant","cpp","raw-string","css","atrule","rule","url","selector","property","important","rest","addInlined","style-attr","pseudo-element","pseudo-class","class","id","attribute","case-sensitivity","n-th","hexcode","unit","javascript","regex","function-variable","parameter","template-string","interpolation","interpolation-punctuation","js","util","clone","jsx","spread","script","script-punctuation","stringifyToken","token","map","join","language","walkTokens","tokens","openedTags","i","length","notTagNorBrace","pop","push","openedBraces","plainText","splice","Token","javaDocLike","javadoclike","docLanguage","forEach","callback","grammar","definition","doc-comment","Array","isArray","l","docCommentSupport","addSupport","keywords","className","java","annotation","generics","getPlaceholder","index","toUpperCase","defineProperties","buildPlaceholders","placeholderPattern","replaceFilter","tokenStack","code","match","placeholder","indexOf","tokenizePlaceholders","j","keys","k","t","s","before","substring","middle","tokenize","after","replacement","apply","concat","php","shell-comment","delimiter","package","string_interpolation","nowdoc-string","heredoc-string","single-quoted-string","double-quoted-string","test","parameterPrefix","jsdoc","optional-parameter","example","actionscript","coffeescript","class-member","multiline-comment","block-regex","inline-javascript","multiline-string","coffee","method-variable","method","known-class-name","unshift","arrow","property-access","maybe-class-name","dom","console","maybeClassNameTokens","flow","flow-punctuation","n4js","n4jsd","typescript","builtin","ts","diff","coord","deleted","inserted","git","command","commit_sha1","go","graphql","fragment","handlebars","block","brackets","json","null","less","mixin-usage","makefile","symbol","markdown","blockquote","code-block","code-language","title","hr","list","url-reference","bold","italic","strike","codeLang","codeBlock","trim","split","toLowerCase","classes","cls","exec","highlight","md","objectivec","ocaml","python","string-interpolation","format-spec","conversion-option","triple-quoted-string","decorator","py","reason","character","constructor","label","sass","atrule-line","variable-line","property-line","scss","parent","statement","sql","func","stylus","atrule-declaration","variable-declaration","property-declaration","wasm","yaml","scalar","key","datetime","yml","prism","es_defaultProps","theme","newlineRe","normalizeEmptyLines","line","empty","appendTypes","typesSize","utils_normalizeTokens","typeArrStack","tokenArrStack","tokenArrIndexStack","tokenArrSizeStack","stackIndex","currentLine","acc","splitByNewlines","newlineCount","_i","_extends","assign","target","arguments","prototype","hasOwnProperty","call","this","utils_themeToDict","base","create","themeDict","reduce","themeEntry","includes","accStyle","root","Highlight_extends","_objectWithoutPropertiesLoose","excluded","sourceKeys","components_Highlight","_Component","subClass","superClass","Highlight","_this","_len","args","_key","prevTheme","prevLanguage","getThemeDict","props","undefined","getLineProps","_ref","output","getStyleForToken","_ref2","display","baseStyle","typeStyles","getTokenProps","_ref3","children","__proto__","render","_this$props","mixedTokens","react","__webpack_require__","d","__webpack_exports__","_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__","_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_1__","classnames__WEBPACK_IMPORTED_MODULE_2__","classnames__WEBPACK_IMPORTED_MODULE_2___default","n","react__WEBPACK_IMPORTED_MODULE_3__","react__WEBPACK_IMPORTED_MODULE_3___default","_ThemeProvider__WEBPACK_IMPORTED_MODULE_4__","DEVICE_SIZES","Col","forwardRef","ref","bsPrefix","_ref$as","as","Component","prefix","spans","brkPoint","span","offset","order","propValue","_propValue$span","infix","createElement","displayName","_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_2__","classnames__WEBPACK_IMPORTED_MODULE_3__","classnames__WEBPACK_IMPORTED_MODULE_3___default","react__WEBPACK_IMPORTED_MODULE_4__","react__WEBPACK_IMPORTED_MODULE_4___default","_ThemeProvider__WEBPACK_IMPORTED_MODULE_5__","Row","_React$Component","noGutters","_this$props$as","defaultProps","uniqueId","_","encode","o","toString","objId","obj","visited","v","redef","insert","newToken","ret","DFS","plugins","text","stringify","matchGrammar","strarr","startPos","oneshot","patterns","lookbehindLength","global","flags","pos","str","lastIndex","from","to","p","len","delNum","slice","wrapped","matchedStr","element","aliases","name","default","opacity","textDecorationLine","fontWeight"],"mappings":"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","file":"static/js/9.ff96b845.chunk.js","sourcesContent":["// @flow\n// Original: https://github.com/dracula/visual-studio-code\n// Converted automatically using ./tools/themeFromVsCode\n\n/*:: import type { PrismTheme } from '../src/types' */\nvar theme\n/*: PrismTheme */\n= {\n  plain: {\n    color: \"#F8F8F2\",\n    backgroundColor: \"#282A36\"\n  },\n  styles: [{\n    types: [\"prolog\", \"constant\", \"builtin\"],\n    style: {\n      color: \"rgb(189, 147, 249)\"\n    }\n  }, {\n    types: [\"inserted\", \"function\"],\n    style: {\n      color: \"rgb(80, 250, 123)\"\n    }\n  }, {\n    types: [\"deleted\"],\n    style: {\n      color: \"rgb(255, 85, 85)\"\n    }\n  }, {\n    types: [\"changed\"],\n    style: {\n      color: \"rgb(255, 184, 108)\"\n    }\n  }, {\n    types: [\"punctuation\", \"symbol\"],\n    style: {\n      color: \"rgb(248, 248, 242)\"\n    }\n  }, {\n    types: [\"string\", \"char\", \"tag\", \"selector\"],\n    style: {\n      color: \"rgb(255, 121, 198)\"\n    }\n  }, {\n    types: [\"keyword\", \"variable\"],\n    style: {\n      color: \"rgb(189, 147, 249)\",\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"comment\"],\n    style: {\n      color: \"rgb(98, 114, 164)\"\n    }\n  }, {\n    types: [\"attr-name\"],\n    style: {\n      color: \"rgb(241, 250, 140)\"\n    }\n  }]\n};\nmodule.exports = theme;","import Prism from './prism-core';\n/* This content is auto-generated to include some prismjs language components: */\n\n/* \"prismjs/components/prism-markup\" */\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  var insideString = {\n    variable: [// Arithmetic Environment\n    {\n      pattern: /\\$?\\(\\([\\s\\S]+?\\)\\)/,\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    }, // Command Substitution\n    {\n      pattern: /\\$\\([^)]+\\)|`[^`]+`/,\n      greedy: true,\n      inside: {\n        variable: /^\\$\\(|^`|\\)$|`$/\n      }\n    }, /\\$(?:[\\w#?*!@]+|\\{[^}]+\\})/i]\n  };\n  Prism.languages.bash = {\n    'shebang': {\n      pattern: /^#!\\s*\\/bin\\/bash|^#!\\s*\\/bin\\/sh/,\n      alias: 'important'\n    },\n    'comment': {\n      pattern: /(^|[^\"{\\\\])#.*/,\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(?:[\\s\\S])*?\\r?\\n\\2/,\n      lookbehind: true,\n      greedy: true,\n      inside: insideString\n    }, {\n      pattern: /([\"'])(?:\\\\[\\s\\S]|\\$\\([^)]+\\)|`[^`]+`|(?!\\1)[^\\\\])*\\1/,\n      greedy: true,\n      inside: insideString\n    }],\n    'variable': insideString.variable,\n    // Originally based on http://ss64.com/bash/\n    'function': {\n      pattern: /(^|[\\s;|&])(?:add|alias|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|builtin|bzip2|cal|cat|cd|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|comm|command|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|du|egrep|eject|enable|env|ethtool|eval|exec|expand|expect|export|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|getopts|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|hash|head|help|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logout|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|printf|ps|pushd|pv|pwd|quota|quotacheck|quotactl|ram|rar|rcp|read|readarray|readonly|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|shift|shopt|shutdown|sleep|slocate|sort|source|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tail|tar|tee|test|time|timeout|times|top|touch|tr|traceroute|trap|tsort|tty|type|ulimit|umask|umount|unalias|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zip|zypper)(?=$|[\\s;|&])/,\n      lookbehind: true\n    },\n    'keyword': {\n      pattern: /(^|[\\s;|&])(?:let|:|\\.|if|then|else|elif|fi|for|break|continue|while|in|case|function|select|do|done|until|echo|exit|return|set|declare)(?=$|[\\s;|&])/,\n      lookbehind: true\n    },\n    'boolean': {\n      pattern: /(^|[\\s;|&])(?:true|false)(?=$|[\\s;|&])/,\n      lookbehind: true\n    },\n    'operator': /&&?|\\|\\|?|==?|!=?|<<<?|>>|<=?|>=?|=~/,\n    'punctuation': /\\$?\\(\\(?|\\)\\)?|\\.\\.|[{}[\\];]/\n  };\n  var inside = insideString.variable[1].inside;\n  inside.string = Prism.languages.bash.string;\n  inside['function'] = Prism.languages.bash['function'];\n  inside.keyword = Prism.languages.bash.keyword;\n  inside['boolean'] = Prism.languages.bash['boolean'];\n  inside.operator = Prism.languages.bash.operator;\n  inside.punctuation = Prism.languages.bash.punctuation;\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  'boolean': /\\b(?:true|false)\\b/,\n  'operator': />>=?|<<=?|->|([-+&|:])\\1|[?:~]|[-+*/%&|^!=<>]=?|\\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\\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*\\{))/i,\n      inside: {\n        'rule': /@[\\w-]+/ // See rest below\n\n      }\n    },\n    'url': RegExp('url\\\\((?:' + string.source + '|.*?)\\\\)', 'i'),\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    '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]+|0[bB][01]+|0[oO][0-7]+)n?|\\d+n|NaN|Infinity)\\b|(?:\\b\\d+\\.?\\d*|\\B\\.\\d+)(?:[Ee][+-]?\\d+)?/,\n  // Allow for all non-ASCII characters (See http://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])+\\/[gimyu]{0,5}(?=\\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      'interpolation': {\n        pattern: /\\${[^}]+}/,\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: http://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/\n * Modified by Miles Johnson: http://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-diff\" */\n\nPrism.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],\n  // Match inserted and deleted lines. Support both +/- and >/< styles.\n  'deleted': /^[-<].*$/m,\n  'inserted': /^[+>].*$/m,\n  // Match \"different\" lines (prefixed with \"!\") in context diff.\n  'diff': {\n    'pattern': /^!(?!!).+$/m,\n    'alias': 'important'\n  }\n};\n/* \"prismjs/components/prism-git\" */\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-graphql\" */\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-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  'comment': /\\/\\/.*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n  'property': {\n    pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"(?=\\s*:)/,\n    greedy: true\n  },\n  'string': {\n    pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"(?!\\s*:)/,\n    greedy: true\n  },\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-markdown\" */\n\nPrism.languages.markdown = Prism.languages.extend('markup', {});\nPrism.languages.insertBefore('markdown', 'prolog', {\n  'blockquote': {\n    // > ...\n    pattern: /^>(?:[\\t ]*>)*/m,\n    alias: 'punctuation'\n  },\n  'code': [{\n    // Prefixed by 4 spaces or 1 tab\n    pattern: /^(?: {4}|\\t).+/m,\n    alias: 'keyword'\n  }, {\n    // `code`\n    // ``code``\n    pattern: /``.+?``|`[^`\\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)(?:==+|--+)/,\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]: http://example.com \"Optional title\"\n    // [id]: http://example.com 'Optional title'\n    // [id]: http://example.com (Optional title)\n    // [id]: <http://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 only one line break\n    pattern: /(^|[^\\\\])(\\*\\*|__)(?:(?:\\r?\\n|\\r)(?!\\r?\\n|\\r)|.)+?\\2/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      'punctuation': /^\\*\\*|^__|\\*\\*$|__$/\n    }\n  },\n  'italic': {\n    // *em*\n    // _em_\n    // Allow only one line break\n    pattern: /(^|[^\\\\])([*_])(?:(?:\\r?\\n|\\r)(?!\\r?\\n|\\r)|.)+?\\2/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      'punctuation': /^[*_]|[*_]$/\n    }\n  },\n  'strike': {\n    // ~~strike through~~\n    // ~strike~\n    // Allow only one line break\n    pattern: /(^|[^\\\\])(~~?)(?:(?:\\r?\\n|\\r)(?!\\r?\\n|\\r)|.)+?\\2/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      'punctuation': /^~~?|~~?$/\n    }\n  },\n  'url': {\n    // [example](http://example.com \"Optional title\")\n    // [example] [id]\n    pattern: /!?\\[[^\\]]+\\](?:\\([^\\s)]+(?:[\\t ]+\"(?:\\\\.|[^\"\\\\])*\")?\\)| ?\\[[^\\]\\n]*\\])/,\n    inside: {\n      'variable': {\n        pattern: /(!?\\[)[^\\]]+(?=\\]$)/,\n        lookbehind: true\n      },\n      'string': {\n        pattern: /\"(?:\\\\.|[^\"\\\\])*\"(?=\\)$)/\n      }\n    }\n  }\n});\n['bold', 'italic', 'strike'].forEach(function (token) {\n  ['url', 'bold', 'italic', 'strike'].forEach(function (inside) {\n    if (token !== inside) {\n      Prism.languages.markdown[token].inside[inside] = Prism.languages.markdown[inside];\n    }\n  });\n});\nPrism.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      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});\nPrism.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    return;\n  } // reverse Prism.util.encode\n\n\n  var code = env.content.replace(/&lt;/g, '<').replace(/&amp;/g, '&');\n  env.content = Prism.highlight(code, grammar, codeLang);\n});\nPrism.languages.md = Prism.languages.markdown;\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-wasm\" */\n\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;","import Prism from './vendor/prism';\nimport theme from '../themes/duotoneDark';\nvar defaultProps = {\n  // $FlowFixMe\n  Prism: Prism,\n  theme: theme\n};\nexport default defaultProps;","var 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; _i < newlineCount; _i++) {\n        normalizeEmptyLines(currentLine);\n        acc.push(currentLine = []);\n        currentLine.push({\n          types: types,\n          content: splitByNewlines[_i]\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\nexport default normalizeTokens;","function _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 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 types = themeEntry.types,\n        languages = themeEntry.languages,\n        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\nexport default themeToDict;","function _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 _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nimport React, { Component } from \"react\";\nimport normalizeTokens from \"../utils/normalizeTokens\";\nimport themeToDict from \"../utils/themeToDict\";\n\nvar Highlight =\n/*#__PURE__*/\nfunction (_Component) {\n  _inheritsLoose(Highlight, _Component);\n\n  function Highlight() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _Component.call.apply(_Component, [this].concat(args)) || this;\n    _this.prevTheme = void 0;\n    _this.prevLanguage = void 0;\n    _this.themeDict = void 0;\n\n    _this.getThemeDict = function (props) {\n      if (_this.themeDict !== undefined && props.theme === _this.prevTheme && props.language === _this.prevLanguage) {\n        return _this.themeDict;\n      }\n\n      _this.prevTheme = props.theme;\n      _this.prevLanguage = props.language;\n      var themeDict = props.theme ? themeToDict(props.theme, props.language) : undefined;\n      return _this.themeDict = themeDict;\n    };\n\n    _this.getLineProps = function (_ref) {\n      var key = _ref.key,\n          className = _ref.className,\n          style = _ref.style,\n          line = _ref.line,\n          rest = _objectWithoutPropertiesLoose(_ref, [\"key\", \"className\", \"style\", \"line\"]);\n\n      var output = _extends({}, rest, {\n        className: \"token-line\",\n        style: undefined,\n        key: undefined\n      });\n\n      var themeDict = _this.getThemeDict(_this.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) output.key = key;\n      if (className) output.className += \" \" + className;\n      return output;\n    };\n\n    _this.getStyleForToken = function (_ref2) {\n      var types = _ref2.types,\n          empty = _ref2.empty;\n      var typesSize = types.length;\n\n      var themeDict = _this.getThemeDict(_this.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    _this.getTokenProps = function (_ref3) {\n      var key = _ref3.key,\n          className = _ref3.className,\n          style = _ref3.style,\n          token = _ref3.token,\n          rest = _objectWithoutPropertiesLoose(_ref3, [\"key\", \"className\", \"style\", \"token\"]);\n\n      var output = _extends({}, rest, {\n        className: \"token \" + token.types.join(\" \"),\n        children: token.content,\n        style: _this.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) output.key = key;\n      if (className) output.className += \" \" + className;\n      return output;\n    };\n\n    return _this;\n  }\n\n  var _proto = Highlight.prototype;\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        Prism = _this$props.Prism,\n        language = _this$props.language,\n        code = _this$props.code,\n        children = _this$props.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;","import Prism from './vendor/prism';\nimport defaultProps from './defaultProps';\nimport Highlight from './components/Highlight';\nexport { Prism, defaultProps };\nexport default Highlight;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nvar DEVICE_SIZES = ['xl', 'lg', 'md', 'sm', 'xs'];\nvar Col = React.forwardRef( // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\nfunction (_ref, ref) {\n  var bsPrefix = _ref.bsPrefix,\n      className = _ref.className,\n      _ref$as = _ref.as,\n      Component = _ref$as === void 0 ? 'div' : _ref$as,\n      props = _objectWithoutPropertiesLoose(_ref, [\"bsPrefix\", \"className\", \"as\"]);\n\n  var prefix = useBootstrapPrefix(bsPrefix, 'col');\n  var spans = [];\n  var classes = [];\n  DEVICE_SIZES.forEach(function (brkPoint) {\n    var propValue = props[brkPoint];\n    delete props[brkPoint];\n    var span, offset, order;\n\n    if (propValue != null && typeof propValue === 'object') {\n      var _propValue$span = propValue.span;\n      span = _propValue$span === void 0 ? true : _propValue$span;\n      offset = propValue.offset;\n      order = propValue.order;\n    } else {\n      span = propValue;\n    }\n\n    var infix = brkPoint !== 'xs' ? \"-\" + brkPoint : '';\n    if (span != null) spans.push(span === true ? \"\" + prefix + infix : \"\" + prefix + infix + \"-\" + span);\n    if (order != null) classes.push(\"order\" + infix + \"-\" + order);\n    if (offset != null) classes.push(\"offset\" + infix + \"-\" + offset);\n  });\n\n  if (!spans.length) {\n    spans.push(prefix); // plain 'col'\n  }\n\n  return React.createElement(Component, _extends({}, props, {\n    ref: ref,\n    className: classNames.apply(void 0, [className].concat(spans, classes))\n  }));\n});\nCol.displayName = 'Col';\nexport default Col;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { createBootstrapComponent } from './ThemeProvider';\n\nvar Row =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Row, _React$Component);\n\n  function Row() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Row.prototype;\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        bsPrefix = _this$props.bsPrefix,\n        noGutters = _this$props.noGutters,\n        _this$props$as = _this$props.as,\n        Component = _this$props$as === void 0 ? 'div' : _this$props$as,\n        className = _this$props.className,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"bsPrefix\", \"noGutters\", \"as\", \"className\"]);\n\n    return React.createElement(Component, _extends({}, props, {\n      className: classNames(className, bsPrefix, noGutters && 'no-gutters')\n    }));\n  };\n\n  return Row;\n}(React.Component);\n\nRow.defaultProps = {\n  noGutters: false\n};\nexport default createBootstrapComponent(Row, 'row');","/**\r\n * Prism: Lightweight, robust, elegant syntax highlighting\r\n * MIT license http://www.opensource.org/licenses/mit-license.php/\r\n * @author Lea Verou http://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  // Private helper vars\n  var lang = /\\blang(?:uage)?-([\\w-]+)\\b/i;\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            if (delNum != 1) _.matchGrammar(text, strarr, grammar, i, pos, true, token);\n            if (oneshot) break;\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\nmodule.exports = Prism;\nPrism.default = Prism;","// @flow\n// Duotone Dark\n// Author: Simurai, adapted from DuoTone themes for Atom (http://simurai.com/projects/2016/01/01/duotone-themes)\n// Conversion: Bram de Haan (http://atelierbram.github.io/Base2Tone-prism/output/prism/prism-base2tone-evening-dark.css)\n// Generated with Base16 Builder (https://github.com/base16-builder/base16-builder)\n\n/*:: import type { PrismTheme } from '../src/types' */\nvar theme\n/*: PrismTheme */\n= {\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};\nmodule.exports = theme;"],"sourceRoot":""}