,
                        /([a-zA-Z0-9])(?:(?!\\3)[^\\\\]|\\\\[\\s\\S])*\\3(?:(?!\\3)[^\\\\]|\\\\[\\s\\S])*\\3/
                          .source,
                        t + /\\s*/.source + t
                      ].join('|') +
                      ')' +
                      /[msixpodualngcer]*/.source
                  ),
                  lookbehind: !0,
                  greedy: !0
                },
                {
                  pattern:
                    /\\/(?:[^\\/\\\\\\r\\n]|\\\\.)*\\/[msixpodualngc]*(?=\\s*(?:$|[\\r\\n,.;})&|\\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\\b))/,
                  greedy: !0
                }
              ],
              variable: [
                /[&*$@%]\\{\\^[A-Z]+\\}/,
                /[&*$@%]\\^[A-Z_]/,
                /[&*$@%]#?(?=\\{)/,
                /[&*$@%]#?(?:(?:::)*'?(?!\\d)[\\w$]+(?![\\w$]))+(?:::)*/,
                /[&*$@%]\\d+/,
                /(?!%=)[$@%][!"#$%&'()*+,\\-.\\/:;<=>?@[\\\\\\]^_\`{|}~]/
              ],
              filehandle: { pattern: /<(?![<=])\\S*?>|\\b_\\b/, alias: 'symbol' },
              'v-string': {
                pattern: /v\\d+(?:\\.\\d+)*|\\d+(?:\\.\\d+){2,}/,
                alias: 'string'
              },
              function: { pattern: /(\\bsub[ \\t]+)\\w+/, lookbehind: !0 },
              keyword:
                /\\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\\b/,
              number:
                /\\b(?:0x[\\dA-Fa-f](?:_?[\\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\\d(?:_?\\d)*)?\\.)?\\d(?:_?\\d)*(?:[Ee][+-]?\\d+)?)\\b/,
              operator:
                /-[rwxoRWXOezsfdlpSbctugkTBMAC]\\b|\\+[+=]?|-[-=>]?|\\*\\*?=?|\\/\\/?=?|=[=~>]?|~[~=]?|\\|\\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\\.(?:=|\\.\\.?)?|[\\\\?]|\\bx(?:=|\\b)|\\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\\b/,
              punctuation: /[{}[\\];(),:]/
            };
          })(Prism);
        },
        9945: function () {
          !(function (e) {
            var t = /\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*|#(?!\\[).*/,
              n = [
                { pattern: /\\b(?:false|true)\\b/i, alias: 'boolean' },
                {
                  pattern: /(::\\s*)\\b[a-z_]\\w*\\b(?!\\s*\\()/i,
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern: /(\\b(?:case|const)\\s+)\\b[a-z_]\\w*(?=\\s*[;=])/i,
                  greedy: !0,
                  lookbehind: !0
                },
                /\\b(?:null)\\b/i,
                /\\b[A-Z_][A-Z0-9_]*\\b(?!\\s*\\()/
              ],
              r =
                /\\b0b[01]+(?:_[01]+)*\\b|\\b0o[0-7]+(?:_[0-7]+)*\\b|\\b0x[\\da-f]+(?:_[\\da-f]+)*\\b|(?:\\b\\d+(?:_\\d+)*\\.?(?:\\d+(?:_\\d+)*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,
              o =
                /<?=>|\\?\\?=?|\\.{3}|\\??->|[!=]=?=?|::|\\*\\*=?|--|\\+\\+|&&|\\|\\||<<|>>|[?~]|[/^|%*&<>.+-]=?/,
              i = /[{}\\[\\](),:;]/;
            e.languages.php = {
              delimiter: {
                pattern: /\\?>$|^<\\?(?:php(?=\\s)|=)?/i,
                alias: 'important'
              },
              comment: t,
              variable: /\\$+(?:\\w+\\b|(?=\\{))/,
              package: {
                pattern:
                  /(namespace\\s+|use\\s+(?:function\\s+)?)(?:\\\\?\\b[a-z_]\\w*)+\\b(?!\\\\)/i,
                lookbehind: !0,
                inside: { punctuation: /\\\\/ }
              },
              'class-name-definition': {
                pattern:
                  /(\\b(?:class|enum|interface|trait)\\s+)\\b[a-z_]\\w*(?!\\\\)\\b/i,
                lookbehind: !0,
                alias: 'class-name'
              },
              'function-definition': {
                pattern: /(\\bfunction\\s+)[a-z_]\\w*(?=\\s*\\()/i,
                lookbehind: !0,
                alias: 'function'
              },
              keyword: [
                {
                  pattern:
                    /(\\(\\s*)\\b(?:array|bool|boolean|float|int|integer|object|string)\\b(?=\\s*\\))/i,
                  alias: 'type-casting',
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern:
                    /([(,?]\\s*)\\b(?:array(?!\\s*\\()|bool|callable|(?:false|null)(?=\\s*\\|)|float|int|iterable|mixed|object|self|static|string)\\b(?=\\s*\\$)/i,
                  alias: 'type-hint',
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern:
                    /(\\)\\s*:\\s*(?:\\?\\s*)?)\\b(?:array(?!\\s*\\()|bool|callable|(?:false|null)(?=\\s*\\|)|float|int|iterable|mixed|object|self|static|string|void)\\b/i,
                  alias: 'return-type',
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern:
                    /\\b(?:array(?!\\s*\\()|bool|float|int|iterable|mixed|object|string|void)\\b/i,
                  alias: 'type-declaration',
                  greedy: !0
                },
                {
                  pattern: /(\\|\\s*)(?:false|null)\\b|\\b(?:false|null)(?=\\s*\\|)/i,
                  alias: 'type-declaration',
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern: /\\b(?:parent|self|static)(?=\\s*::)/i,
                  alias: 'static-context',
                  greedy: !0
                },
                { pattern: /(\\byield\\s+)from\\b/i, lookbehind: !0 },
                /\\bclass\\b/i,
                {
                  pattern:
                    /((?:^|[^\\s>:]|(?:^|[^-])>|(?:^|[^:]):)\\s*)\\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|new|or|parent|print|private|protected|public|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\\b/i,
                  lookbehind: !0
                }
              ],
              'argument-name': {
                pattern: /([(,]\\s+)\\b[a-z_]\\w*(?=\\s*:(?!:))/i,
                lookbehind: !0
              },
              'class-name': [
                {
                  pattern:
                    /(\\b(?:extends|implements|instanceof|new(?!\\s+self|\\s+static))\\s+|\\bcatch\\s*\\()\\b[a-z_]\\w*(?!\\\\)\\b/i,
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern: /(\\|\\s*)\\b[a-z_]\\w*(?!\\\\)\\b/i,
                  greedy: !0,
                  lookbehind: !0
                },
                { pattern: /\\b[a-z_]\\w*(?!\\\\)\\b(?=\\s*\\|)/i, greedy: !0 },
                {
                  pattern: /(\\|\\s*)(?:\\\\?\\b[a-z_]\\w*)+\\b/i,
                  alias: 'class-name-fully-qualified',
                  greedy: !0,
                  lookbehind: !0,
                  inside: { punctuation: /\\\\/ }
                },
                {
                  pattern: /(?:\\\\?\\b[a-z_]\\w*)+\\b(?=\\s*\\|)/i,
                  alias: 'class-name-fully-qualified',
                  greedy: !0,
                  inside: { punctuation: /\\\\/ }
                },
                {
                  pattern:
                    /(\\b(?:extends|implements|instanceof|new(?!\\s+self\\b|\\s+static\\b))\\s+|\\bcatch\\s*\\()(?:\\\\?\\b[a-z_]\\w*)+\\b(?!\\\\)/i,
                  alias: 'class-name-fully-qualified',
                  greedy: !0,
                  lookbehind: !0,
                  inside: { punctuation: /\\\\/ }
                },
                {
                  pattern: /\\b[a-z_]\\w*(?=\\s*\\$)/i,
                  alias: 'type-declaration',
                  greedy: !0
                },
                {
                  pattern: /(?:\\\\?\\b[a-z_]\\w*)+(?=\\s*\\$)/i,
                  alias: ['class-name-fully-qualified', 'type-declaration'],
                  greedy: !0,
                  inside: { punctuation: /\\\\/ }
                },
                {
                  pattern: /\\b[a-z_]\\w*(?=\\s*::)/i,
                  alias: 'static-context',
                  greedy: !0
                },
                {
                  pattern: /(?:\\\\?\\b[a-z_]\\w*)+(?=\\s*::)/i,
                  alias: ['class-name-fully-qualified', 'static-context'],
                  greedy: !0,
                  inside: { punctuation: /\\\\/ }
                },
                {
                  pattern: /([(,?]\\s*)[a-z_]\\w*(?=\\s*\\$)/i,
                  alias: 'type-hint',
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern: /([(,?]\\s*)(?:\\\\?\\b[a-z_]\\w*)+(?=\\s*\\$)/i,
                  alias: ['class-name-fully-qualified', 'type-hint'],
                  greedy: !0,
                  lookbehind: !0,
                  inside: { punctuation: /\\\\/ }
                },
                {
                  pattern: /(\\)\\s*:\\s*(?:\\?\\s*)?)\\b[a-z_]\\w*(?!\\\\)\\b/i,
                  alias: 'return-type',
                  greedy: !0,
                  lookbehind: !0
                },
                {
                  pattern: /(\\)\\s*:\\s*(?:\\?\\s*)?)(?:\\\\?\\b[a-z_]\\w*)+\\b(?!\\\\)/i,
                  alias: ['class-name-fully-qualified', 'return-type'],
                  greedy: !0,
                  lookbehind: !0,
                  inside: { punctuation: /\\\\/ }
                }
              ],
              constant: n,
              function: {
                pattern: /(^|[^\\\\\\w])\\\\?[a-z_](?:[\\w\\\\]*\\w)?(?=\\s*\\()/i,
                lookbehind: !0,
                inside: { punctuation: /\\\\/ }
              },
              property: { pattern: /(->\\s*)\\w+/, lookbehind: !0 },
              number: r,
              operator: o,
              punctuation: i
            };
            var a = {
                pattern:
                  /\\{\\$(?:\\{(?:\\{[^{}]+\\}|[^{}]+)\\}|[^{}])+\\}|(^|[^\\\\{])\\$+(?:\\w+(?:\\[[^\\r\\n\\[\\]]+\\]|->\\w+)?)/,
                lookbehind: !0,
                inside: e.languages.php
              },
              s = [
                {
                  pattern: /<<<'([^']+)'[\\r\\n](?:.*[\\r\\n])*?\\1;/,
                  alias: 'nowdoc-string',
                  greedy: !0,
                  inside: {
                    delimiter: {
                      pattern: /^<<<'[^']+'|[a-z_]\\w*;$/i,
                      alias: 'symbol',
                      inside: { punctuation: /^<<<'?|[';]$/ }
                    }
                  }
                },
                {
                  pattern:
                    /<<<(?:"([^"]+)"[\\r\\n](?:.*[\\r\\n])*?\\1;|([a-z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?\\2;)/i,
                  alias: 'heredoc-string',
                  greedy: !0,
                  inside: {
                    delimiter: {
                      pattern: /^<<<(?:"[^"]+"|[a-z_]\\w*)|[a-z_]\\w*;$/i,
                      alias: 'symbol',
                      inside: { punctuation: /^<<<"?|[";]$/ }
                    },
                    interpolation: a
                  }
                },
                {
                  pattern: /\`(?:\\\\[\\s\\S]|[^\\\\\`])*\`/,
                  alias: 'backtick-quoted-string',
                  greedy: !0
                },
                {
                  pattern: /'(?:\\\\[\\s\\S]|[^\\\\'])*'/,
                  alias: 'single-quoted-string',
                  greedy: !0
                },
                {
                  pattern: /"(?:\\\\[\\s\\S]|[^\\\\"])*"/,
                  alias: 'double-quoted-string',
                  greedy: !0,
                  inside: { interpolation: a }
                }
              ];
            e.languages.insertBefore('php', 'variable', {
              string: s,
              attribute: {
                pattern:
                  /#\\[(?:[^"'\\/#]|\\/(?![*/])|\\/\\/.*$|#(?!\\[).*$|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|"(?:\\\\[\\s\\S]|[^\\\\"])*"|'(?:\\\\[\\s\\S]|[^\\\\'])*')+\\](?=\\s*[a-z$#])/im,
                greedy: !0,
                inside: {
                  'attribute-content': {
                    pattern: /^(#\\[)[\\s\\S]+(?=\\]$)/,
                    lookbehind: !0,
                    inside: {
                      comment: t,
                      string: s,
                      'attribute-class-name': [
                        {
                          pattern: /([^:]|^)\\b[a-z_]\\w*(?!\\\\)\\b/i,
                          alias: 'class-name',
                          greedy: !0,
                          lookbehind: !0
                        },
                        {
                          pattern: /([^:]|^)(?:\\\\?\\b[a-z_]\\w*)+/i,
                          alias: ['class-name', 'class-name-fully-qualified'],
                          greedy: !0,
                          lookbehind: !0,
                          inside: { punctuation: /\\\\/ }
                        }
                      ],
                      constant: n,
                      number: r,
                      operator: o,
                      punctuation: i
                    }
                  },
                  delimiter: { pattern: /^#\\[|\\]$/, alias: 'punctuation' }
                }
              }
            }),
              e.hooks.add('before-tokenize', function (t) {
                /<\\?/.test(t.code) &&
                  e.languages['markup-templating'].buildPlaceholders(
                    t,
                    'php',
                    /<\\?(?:[^"'/#]|\\/(?![*/])|("|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|(?:\\/\\/|#(?!\\[))(?:[^?\\n\\r]|\\?(?!>))*(?=$|\\?>|[\\r\\n])|#\\[|\\/\\*(?:[^*]|\\*(?!\\/))*(?:\\*\\/|$))*?(?:\\?>|$)/g
                  );
              }),
              e.hooks.add('after-tokenize', function (t) {
                e.languages['markup-templating'].tokenizePlaceholders(t, 'php');
              });
          })(Prism);
        },
        366: function () {
          (Prism.languages.python = {
            comment: { pattern: /(^|[^\\\\])#.*/, lookbehind: !0, greedy: !0 },
            'string-interpolation': {
              pattern:
                /(?:f|fr|rf)(?:("""|''')[\\s\\S]*?\\1|("|')(?:\\\\.|(?!\\2)[^\\\\\\r\\n])*\\2)/i,
              greedy: !0,
              inside: {
                interpolation: {
                  pattern:
                    /((?:^|[^{])(?:\\{\\{)*)\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}])+\\})+\\})+\\}/,
                  lookbehind: !0,
                  inside: {
                    'format-spec': {
                      pattern: /(:)[^:(){}]+(?=\\}$)/,
                      lookbehind: !0
                    },
                    'conversion-option': {
                      pattern: /![sra](?=[:}]$)/,
                      alias: 'punctuation'
                    },
                    rest: null
                  }
                },
                string: /[\\s\\S]+/
              }
            },
            'triple-quoted-string': {
              pattern: /(?:[rub]|br|rb)?("""|''')[\\s\\S]*?\\1/i,
              greedy: !0,
              alias: 'string'
            },
            string: {
              pattern: /(?:[rub]|br|rb)?("|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/i,
              greedy: !0
            },
            function: {
              pattern: /((?:^|\\s)def[ \\t]+)[a-zA-Z_]\\w*(?=\\s*\\()/g,
              lookbehind: !0
            },
            'class-name': { pattern: /(\\bclass\\s+)\\w+/i, lookbehind: !0 },
            decorator: {
              pattern: /(^[\\t ]*)@\\w+(?:\\.\\w+)*/m,
              lookbehind: !0,
              alias: ['annotation', 'punctuation'],
              inside: { punctuation: /\\./ }
            },
            keyword:
              /\\b(?:_(?=\\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\\b/,
            builtin:
              /\\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\\b/,
            boolean: /\\b(?:False|None|True)\\b/,
            number:
              /\\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\\b|(?:\\b\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\B\\.\\d+(?:_\\d+)*)(?:e[+-]?\\d+(?:_\\d+)*)?j?(?!\\w)/i,
            operator: /[-+%=]=?|!=|:=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
            punctuation: /[{}[\\];(),.:]/
          }),
            (Prism.languages.python[
              'string-interpolation'
            ].inside.interpolation.inside.rest = Prism.languages.python),
            (Prism.languages.py = Prism.languages.python);
        },
        2939: function () {
          Prism.languages.q = {
            string: /"(?:\\\\.|[^"\\\\\\r\\n])*"/,
            comment: [
              { pattern: /([\\t )\\]}])\\/.*/, lookbehind: !0, greedy: !0 },
              {
                pattern:
                  /(^|\\r?\\n|\\r)\\/[\\t ]*(?:(?:\\r?\\n|\\r)(?:.*(?:\\r?\\n|\\r(?!\\n)))*?(?:\\\\(?=[\\t ]*(?:\\r?\\n|\\r))|$)|\\S.*)/,
                lookbehind: !0,
                greedy: !0
              },
              { pattern: /^\\\\[\\t ]*(?:\\r?\\n|\\r)[\\s\\S]+/m, greedy: !0 },
              { pattern: /^#!.+/m, greedy: !0 }
            ],
            symbol: /\`(?::\\S+|[\\w.]*)/,
            datetime: {
              pattern:
                /0N[mdzuvt]|0W[dtz]|\\d{4}\\.\\d\\d(?:m|\\.\\d\\d(?:T(?:\\d\\d(?::\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?)?)?)?[dz]?)|\\d\\d:\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?[uvt]?/,
              alias: 'number'
            },
            number:
              /\\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\\da-fA-F]+|\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?[hjfeb]?)/,
            keyword:
              /\\\\\\w+\\b|\\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\\b/,
            adverb: { pattern: /['\\/\\\\]:?|\\beach\\b/, alias: 'function' },
            verb: {
              pattern:
                /(?:\\B\\.\\B|\\b[01]:|<[=>]?|>=?|[:+\\-*%,!?~=|$&#@^]):?|\\b_\\b:?/,
              alias: 'operator'
            },
            punctuation: /[(){}\\[\\];.]/
          };
        },
        9385: function () {
          !(function (e) {
            (e.languages.ruby = e.languages.extend('clike', {
              comment: { pattern: /#.*|^=begin\\s[\\s\\S]*?^=end/m, greedy: !0 },
              'class-name': {
                pattern:
                  /(\\b(?:class|module)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+|\\b[A-Z_]\\w*(?=\\s*\\.\\s*new\\b)/,
                lookbehind: !0,
                inside: { punctuation: /[.\\\\]/ }
              },
              keyword:
                /\\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\\b/,
              operator:
                /\\.{2,3}|&\\.|===|<?=>|[!=]?~|(?:&&|\\|\\||<<|>>|\\*\\*|[+\\-*/%<>!^&|=])=?|[?:]/,
              punctuation: /[(){}[\\].,;]/
            })),
              e.languages.insertBefore('ruby', 'operator', {
                'double-colon': { pattern: /::/, alias: 'punctuation' }
              });
            var t = {
              pattern: /((?:^|[^\\\\])(?:\\\\{2})*)#\\{(?:[^{}]|\\{[^{}]*\\})*\\}/,
              lookbehind: !0,
              inside: {
                content: {
                  pattern: /^(#\\{)[\\s\\S]+(?=\\}$)/,
                  lookbehind: !0,
                  inside: e.languages.ruby
                },
                delimiter: { pattern: /^#\\{|\\}$/, alias: 'punctuation' }
              }
            };
            delete e.languages.ruby.function;
            var n =
                '(?:' +
                [
                  /([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source,
                  /\\((?:[^()\\\\]|\\\\[\\s\\S]|\\((?:[^()\\\\]|\\\\[\\s\\S])*\\))*\\)/.source,
                  /\\{(?:[^{}\\\\]|\\\\[\\s\\S]|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\})*\\}/.source,
                  /\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S]|\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S])*\\])*\\]/
                    .source,
                  /<(?:[^<>\\\\]|\\\\[\\s\\S]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)*>/.source
                ].join('|') +
                ')',
              r =
                /(?:"(?:\\\\.|[^"\\\\\\r\\n])*"|(?:\\b[a-zA-Z_]\\w*|[^\\s\\0-\\x7F]+)[?!]?|\\$.)/
                  .source;
            e.languages.insertBefore('ruby', 'keyword', {
              'regex-literal': [
                {
                  pattern: RegExp(/%r/.source + n + /[egimnosux]{0,6}/.source),
                  greedy: !0,
                  inside: { interpolation: t, regex: /[\\s\\S]+/ }
                },
                {
                  pattern:
                    /(^|[^/])\\/(?!\\/)(?:\\[[^\\r\\n\\]]+\\]|\\\\.|[^[/\\\\\\r\\n])+\\/[egimnosux]{0,6}(?=\\s*(?:$|[\\r\\n,.;})#]))/,
                  lookbehind: !0,
                  greedy: !0,
                  inside: { interpolation: t, regex: /[\\s\\S]+/ }
                }
              ],
              variable: /[@$]+[a-zA-Z_]\\w*(?:[?!]|\\b)/,
              symbol: [
                {
                  pattern: RegExp(/(^|[^:]):/.source + r),
                  lookbehind: !0,
                  greedy: !0
                },
                {
                  pattern: RegExp(
                    /([\\r\\n{(,][ \\t]*)/.source + r + /(?=:(?!:))/.source
                  ),
                  lookbehind: !0,
                  greedy: !0
                }
              ],
              'method-definition': {
                pattern: /(\\bdef\\s+)\\w+(?:\\s*\\.\\s*\\w+)?/,
                lookbehind: !0,
                inside: {
                  function: /\\b\\w+$/,
                  keyword: /^self\\b/,
                  'class-name': /^\\w+/,
                  punctuation: /\\./
                }
              }
            }),
              e.languages.insertBefore('ruby', 'string', {
                'string-literal': [
                  {
                    pattern: RegExp(/%[qQiIwWs]?/.source + n),
                    greedy: !0,
                    inside: { interpolation: t, string: /[\\s\\S]+/ }
                  },
                  {
                    pattern:
                      /("|')(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\#\\r\\n])*\\1/,
                    greedy: !0,
                    inside: { interpolation: t, string: /[\\s\\S]+/ }
                  },
                  {
                    pattern: /<<[-~]?([a-z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,
                    alias: 'heredoc-string',
                    greedy: !0,
                    inside: {
                      delimiter: {
                        pattern: /^<<[-~]?[a-z_]\\w*|\\b[a-z_]\\w*$/i,
                        inside: { symbol: /\\b\\w+/, punctuation: /^<<[-~]?/ }
                      },
                      interpolation: t,
                      string: /[\\s\\S]+/
                    }
                  },
                  {
                    pattern:
                      /<<[-~]?'([a-z_]\\w*)'[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,
                    alias: 'heredoc-string',
                    greedy: !0,
                    inside: {
                      delimiter: {
                        pattern: /^<<[-~]?'[a-z_]\\w*'|\\b[a-z_]\\w*$/i,
                        inside: { symbol: /\\b\\w+/, punctuation: /^<<[-~]?'|'$/ }
                      },
                      string: /[\\s\\S]+/
                    }
                  }
                ],
                'command-literal': [
                  {
                    pattern: RegExp(/%x/.source + n),
                    greedy: !0,
                    inside: {
                      interpolation: t,
                      command: { pattern: /[\\s\\S]+/, alias: 'string' }
                    }
                  },
                  {
                    pattern:
                      /\`(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\`#\\r\\n])*\`/,
                    greedy: !0,
                    inside: {
                      interpolation: t,
                      command: { pattern: /[\\s\\S]+/, alias: 'string' }
                    }
                  }
                ]
              }),
              delete e.languages.ruby.string,
              e.languages.insertBefore('ruby', 'number', {
                builtin:
                  /\\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\\b/,
                constant: /\\b[A-Z][A-Z0-9_]*(?:[?!]|\\b)/
              }),
              (e.languages.rb = e.languages.ruby);
          })(Prism);
        },
        2886: function () {
          (Prism.languages.scala = Prism.languages.extend('java', {
            'triple-quoted-string': {
              pattern: /"""[\\s\\S]*?"""/,
              greedy: !0,
              alias: 'string'
            },
            string: { pattern: /("|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/, greedy: !0 },
            keyword:
              /<-|=>|\\b(?:abstract|case|catch|class|def|do|else|extends|final|finally|for|forSome|if|implicit|import|lazy|match|new|null|object|override|package|private|protected|return|sealed|self|super|this|throw|trait|try|type|val|var|while|with|yield)\\b/,
            number:
              /\\b0x(?:[\\da-f]*\\.)?[\\da-f]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e\\d+)?[dfl]?/i,
            builtin:
              /\\b(?:Any|AnyRef|AnyVal|Boolean|Byte|Char|Double|Float|Int|Long|Nothing|Short|String|Unit)\\b/,
            symbol: /'[^\\d\\s\\\\]\\w*/
          })),
            Prism.languages.insertBefore('scala', 'triple-quoted-string', {
              'string-interpolation': {
                pattern:
                  /\\b[a-z]\\w*(?:"""(?:[^$]|\\$(?:[^{]|\\{(?:[^{}]|\\{[^{}]*\\})*\\}))*?"""|"(?:[^$"\\r\\n]|\\$(?:[^{]|\\{(?:[^{}]|\\{[^{}]*\\})*\\}))*")/i,
                greedy: !0,
                inside: {
                  id: { pattern: /^\\w+/, greedy: !0, alias: 'function' },
                  escape: {
                    pattern: /\\\\\\$"|\\$[$"]/,
                    greedy: !0,
                    alias: 'symbol'
                  },
                  interpolation: {
                    pattern: /\\$(?:\\w+|\\{(?:[^{}]|\\{[^{}]*\\})*\\})/,
                    greedy: !0,
                    inside: {
                      punctuation: /^\\$\\{?|\\}$/,
                      expression: {
                        pattern: /[\\s\\S]+/,
                        inside: Prism.languages.scala
                      }
                    }
                  },
                  string: /[\\s\\S]+/
                }
              }
            }),
            delete Prism.languages.scala['class-name'],
            delete Prism.languages.scala.function;
        },
        5266: function () {
          Prism.languages.sql = {
            comment: {
              pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:--|\\/\\/|#).*)/,
              lookbehind: !0
            },
            variable: [
              { pattern: /@(["'\`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1/, greedy: !0 },
              /@[\\w.$]+/
            ],
            string: {
              pattern: /(^|[^@\\\\])("|')(?:\\\\[\\s\\S]|(?!\\2)[^\\\\]|\\2\\2)*\\2/,
              greedy: !0,
              lookbehind: !0
            },
            identifier: {
              pattern: /(^|[^@\\\\])\`(?:\\\\[\\s\\S]|[^\`\\\\]|\`\`)*\`/,
              greedy: !0,
              lookbehind: !0,
              inside: { punctuation: /^\`|\`$/ }
            },
            function:
              /\\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\\s*\\()/i,
            keyword:
              /\\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\\b/i,
            boolean: /\\b(?:FALSE|NULL|TRUE)\\b/i,
            number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+\\b/i,
            operator:
              /[-+*\\/=%^~]|&&?|\\|\\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\\b/i,
            punctuation: /[;[\\]()\`,.]/
          };
        },
        874: function () {
          (Prism.languages.swift = {
            comment: {
              pattern:
                /(^|[^\\\\:])(?:\\/\\/.*|\\/\\*(?:[^/*]|\\/(?!\\*)|\\*(?!\\/)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*\\*\\/)/,
              lookbehind: !0,
              greedy: !0
            },
            'string-literal': [
              {
                pattern: RegExp(
                  /(^|[^"#])/.source +
                    '(?:' +
                    /"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^(])|[^\\\\\\r\\n"])*"/
                      .source +
                    '|' +
                    /"""(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\"]|"(?!""))*"""/
                      .source +
                    ')' +
                    /(?!["#])/.source
                ),
                lookbehind: !0,
                greedy: !0,
                inside: {
                  interpolation: {
                    pattern: /(\\\\\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,
                    lookbehind: !0,
                    inside: null
                  },
                  'interpolation-punctuation': {
                    pattern: /^\\)|\\\\\\($/,
                    alias: 'punctuation'
                  },
                  punctuation: /\\\\(?=[\\r\\n])/,
                  string: /[\\s\\S]+/
                }
              },
              {
                pattern: RegExp(
                  /(^|[^"#])(#+)/.source +
                    '(?:' +
                    /"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^#])|[^\\\\\\r\\n])*?"/
                      .source +
                    '|' +
                    /"""(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?"""/
                      .source +
                    ')\\\\2'
                ),
                lookbehind: !0,
                greedy: !0,
                inside: {
                  interpolation: {
                    pattern: /(\\\\#+\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,
                    lookbehind: !0,
                    inside: null
                  },
                  'interpolation-punctuation': {
                    pattern: /^\\)|\\\\#+\\($/,
                    alias: 'punctuation'
                  },
                  string: /[\\s\\S]+/
                }
              }
            ],
            directive: {
              pattern: RegExp(
                /#/.source +
                  '(?:' +
                  /(?:elseif|if)\\b/.source +
                  '(?:[ \\t]*' +
                  /(?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \\t]*(?:&&|\\|\\|))?/
                    .source +
                  ')+|' +
                  /(?:else|endif)\\b/.source +
                  ')'
              ),
              alias: 'property',
              inside: {
                'directive-name': /^#\\w+/,
                boolean: /\\b(?:false|true)\\b/,
                number: /\\b\\d+(?:\\.\\d+)*\\b/,
                operator: /!|&&|\\|\\||[<>]=?/,
                punctuation: /[(),]/
              }
            },
            literal: {
              pattern:
                /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\\b/,
              alias: 'constant'
            },
            'other-directive': { pattern: /#\\w+\\b/, alias: 'property' },
            attribute: { pattern: /@\\w+/, alias: 'atrule' },
            'function-definition': {
              pattern: /(\\bfunc\\s+)\\w+/,
              lookbehind: !0,
              alias: 'function'
            },
            label: {
              pattern:
                /\\b(break|continue)\\s+\\w+|\\b[a-zA-Z_]\\w*(?=\\s*:\\s*(?:for|repeat|while)\\b)/,
              lookbehind: !0,
              alias: 'important'
            },
            keyword:
              /\\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\\b/,
            boolean: /\\b(?:false|true)\\b/,
            nil: { pattern: /\\bnil\\b/, alias: 'constant' },
            'short-argument': /\\$\\d+\\b/,
            omit: { pattern: /\\b_\\b/, alias: 'keyword' },
            number:
              /\\b(?:[\\d_]+(?:\\.[\\de_]+)?|0x[a-f0-9_]+(?:\\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\\b/i,
            'class-name': /\\b[A-Z](?:[A-Z_\\d]*[a-z]\\w*)?\\b/,
            function: /\\b[a-z_]\\w*(?=\\s*\\()/i,
            constant: /\\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\\b/,
            operator: /[-+*/%=!<>&|^~?]+|\\.[.\\-+*/%=!<>&|^~?]+/,
            punctuation: /[{}[\\]();,.:\\\\]/
          }),
            Prism.languages.swift['string-literal'].forEach(function (e) {
              e.inside.interpolation.inside = Prism.languages.swift;
            });
        },
        3358: function () {
          !(function (e) {
            var t = /[*&][^\\s[\\]{},]+/,
              n =
                /!(?:<[\\w\\-%#;/?:@&=+$,.!~*'()[\\]]+>|(?:[a-zA-Z\\d-]*!)?[\\w\\-%#;/?:@&=+$.~*'()]+)?/,
              r =
                '(?:' +
                n.source +
                '(?:[ \\t]+' +
                t.source +
                ')?|' +
                t.source +
                '(?:[ \\t]+' +
                n.source +
                ')?)',
              o =
                /(?:[^\\s\\x00-\\x08\\x0e-\\x1f!"#%&'*,\\-:>?@[\\]\`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \\t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
                  /<PLAIN>/g,
                  function () {
                    return /[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]/
                      .source;
                  }
                ),
              i = /"(?:[^"\\\\\\r\\n]|\\\\.)*"|'(?:[^'\\\\\\r\\n]|\\\\.)*'/.source;
            function a(e, t) {
              t = (t || '').replace(/m/g, '') + 'm';
              var n =
                /([:\\-,[{]\\s*(?:\\s<<prop>>[ \\t]+)?)(?:<<value>>)(?=[ \\t]*(?:$|,|\\]|\\}|(?:[\\r\\n]\\s*)?#))/.source
                  .replace(/<<prop>>/g, function () {
                    return r;
                  })
                  .replace(/<<value>>/g, function () {
                    return e;
                  });
              return RegExp(n, t);
            }
            (e.languages.yaml = {
              scalar: {
                pattern: RegExp(
                  /([\\-:]\\s*(?:\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)\\S[^\\r\\n]*(?:\\2[^\\r\\n]+)*)/.source.replace(
                    /<<prop>>/g,
                    function () {
                      return r;
                    }
                  )
                ),
                lookbehind: !0,
                alias: 'string'
              },
              comment: /#.*/,
              key: {
                pattern: RegExp(
                  /((?:^|[:\\-,[{\\r\\n?])[ \\t]*(?:<<prop>>[ \\t]+)?)<<key>>(?=\\s*:\\s)/.source
                    .replace(/<<prop>>/g, function () {
                      return r;
                    })
                    .replace(/<<key>>/g, function () {
                      return '(?:' + o + '|' + i + ')';
                    })
                ),
                lookbehind: !0,
                greedy: !0,
                alias: 'atrule'
              },
              directive: {
                pattern: /(^[ \\t]*)%.+/m,
                lookbehind: !0,
                alias: 'important'
              },
              datetime: {
                pattern: a(
                  /\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ \\t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?/
                    .source
                ),
                lookbehind: !0,
                alias: 'number'
              },
              boolean: {
                pattern: a(/false|true/.source, 'i'),
                lookbehind: !0,
                alias: 'important'
              },
              null: {
                pattern: a(/null|~/.source, 'i'),
                lookbehind: !0,
                alias: 'important'
              },
              string: { pattern: a(i), lookbehind: !0, greedy: !0 },
              number: {
                pattern: a(
                  /[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)/
                    .source,
                  'i'
                ),
                lookbehind: !0
              },
              tag: n,
              important: t,
              punctuation: /---|[:[\\]{}\\-,|>?]|\\.\\.\\./
            }),
              (e.languages.yml = e.languages.yaml);
          })(Prism);
        },
        5660: function (e, t, n) {
          var r = (function (e) {
            var t = /(?:^|\\s)lang(?:uage)?-([\\w-]+)(?=\\s|$)/i,
              n = 0,
              r = {},
              o = {
                manual: e.Prism && e.Prism.manual,
                disableWorkerMessageHandler:
                  e.Prism && e.Prism.disableWorkerMessageHandler,
                util: {
                  encode: function e(t) {
                    return t instanceof i
                      ? new i(t.type, e(t.content), t.alias)
                      : Array.isArray(t)
                      ? t.map(e)
                      : t
                          .replace(/&/g, '&amp;')
                          .replace(/</g, '&lt;')
                          .replace(/\\u00a0/g, ' ');
                  },
                  type: function (e) {
                    return Object.prototype.toString.call(e).slice(8, -1);
                  },
                  objId: function (e) {
                    return (
                      e.__id ||
                        Object.defineProperty(e, '__id', { value: ++n }),
                      e.__id
                    );
                  },
                  clone: function e(t, n) {
                    var r, i;
                    switch (((n = n || {}), o.util.type(t))) {
                      case 'Object':
                        if (((i = o.util.objId(t)), n[i])) return n[i];
                        for (var a in ((r = {}), (n[i] = r), t))
                          t.hasOwnProperty(a) && (r[a] = e(t[a], n));
                        return r;
                      case 'Array':
                        return (
                          (i = o.util.objId(t)),
                          n[i]
                            ? n[i]
                            : ((r = []),
                              (n[i] = r),
                              t.forEach(function (t, o) {
                                r[o] = e(t, n);
                              }),
                              r)
                        );
                      default:
                        return t;
                    }
                  },
                  getLanguage: function (e) {
                    for (; e; ) {
                      var n = t.exec(e.className);
                      if (n) return n[1].toLowerCase();
                      e = e.parentElement;
                    }
                    return 'none';
                  },
                  setLanguage: function (e, n) {
                    (e.className = e.className.replace(RegExp(t, 'gi'), '')),
                      e.classList.add('language-' + n);
                  },
                  currentScript: function () {
                    if ('undefined' == typeof document) return null;
                    if ('currentScript' in document)
                      return document.currentScript;
                    try {
                      throw new Error();
                    } catch (r) {
                      var e = (/at [^(\\r\\n]*\\((.*):[^:]+:[^:]+\\)$/i.exec(
                        r.stack
                      ) || [])[1];
                      if (e) {
                        var t = document.getElementsByTagName('script');
                        for (var n in t) if (t[n].src == e) return t[n];
                      }
                      return null;
                    }
                  },
                  isActive: function (e, t, n) {
                    for (var r = 'no-' + t; e; ) {
                      var o = e.classList;
                      if (o.contains(t)) return !0;
                      if (o.contains(r)) return !1;
                      e = e.parentElement;
                    }
                    return !!n;
                  }
                },
                languages: {
                  plain: r,
                  plaintext: r,
                  text: r,
                  txt: r,
                  extend: function (e, t) {
                    var n = o.util.clone(o.languages[e]);
                    for (var r in t) n[r] = t[r];
                    return n;
                  },
                  insertBefore: function (e, t, n, r) {
                    var i = (r = r || o.languages)[e],
                      a = {};
                    for (var s in i)
                      if (i.hasOwnProperty(s)) {
                        if (s == t)
                          for (var l in n) n.hasOwnProperty(l) && (a[l] = n[l]);
                        n.hasOwnProperty(s) || (a[s] = i[s]);
                      }
                    var c = r[e];
                    return (
                      (r[e] = a),
                      o.languages.DFS(o.languages, function (t, n) {
                        n === c && t != e && (this[t] = a);
                      }),
                      a
                    );
                  },
                  DFS: function e(t, n, r, i) {
                    i = i || {};
                    var a = o.util.objId;
                    for (var s in t)
                      if (t.hasOwnProperty(s)) {
                        n.call(t, s, t[s], r || s);
                        var l = t[s],
                          c = o.util.type(l);
                        'Object' !== c || i[a(l)]
                          ? 'Array' !== c ||
                            i[a(l)] ||
                            ((i[a(l)] = !0), e(l, n, s, i))
                          : ((i[a(l)] = !0), e(l, n, null, i));
                      }
                  }
                },
                plugins: {},
                highlightAll: function (e, t) {
                  o.highlightAllUnder(document, e, t);
                },
                highlightAllUnder: function (e, t, n) {
                  var r = {
                    callback: n,
                    container: e,
                    selector:
                      'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
                  };
                  o.hooks.run('before-highlightall', r),
                    (r.elements = Array.prototype.slice.apply(
                      r.container.querySelectorAll(r.selector)
                    )),
                    o.hooks.run('before-all-elements-highlight', r);
                  for (var i, a = 0; (i = r.elements[a++]); )
                    o.highlightElement(i, !0 === t, r.callback);
                },
                highlightElement: function (t, n, r) {
                  var i = o.util.getLanguage(t),
                    a = o.languages[i];
                  o.util.setLanguage(t, i);
                  var s = t.parentElement;
                  s &&
                    'pre' === s.nodeName.toLowerCase() &&
                    o.util.setLanguage(s, i);
                  var l = {
                    element: t,
                    language: i,
                    grammar: a,
                    code: t.textContent
                  };
                  function c(e) {
                    (l.highlightedCode = e),
                      o.hooks.run('before-insert', l),
                      (l.element.innerHTML = l.highlightedCode),
                      o.hooks.run('after-highlight', l),
                      o.hooks.run('complete', l),
                      r && r.call(l.element);
                  }
                  if (
                    (o.hooks.run('before-sanity-check', l),
                    (s = l.element.parentElement) &&
                      'pre' === s.nodeName.toLowerCase() &&
                      !s.hasAttribute('tabindex') &&
                      s.setAttribute('tabindex', '0'),
                    !l.code)
                  )
                    return (
                      o.hooks.run('complete', l), void (r && r.call(l.element))
                    );
                  if ((o.hooks.run('before-highlight', l), l.grammar))
                    if (n && e.Worker) {
                      var u = new Worker(o.filename);
                      (u.onmessage = function (e) {
                        c(e.data);
                      }),
                        u.postMessage(
                          JSON.stringify({
                            language: l.language,
                            code: l.code,
                            immediateClose: !0
                          })
                        );
                    } else c(o.highlight(l.code, l.grammar, l.language));
                  else c(o.util.encode(l.code));
                },
                highlight: function (e, t, n) {
                  var r = { code: e, grammar: t, language: n };
                  if ((o.hooks.run('before-tokenize', r), !r.grammar))
                    throw new Error(
                      'The language "' + r.language + '" has no grammar.'
                    );
                  return (
                    (r.tokens = o.tokenize(r.code, r.grammar)),
                    o.hooks.run('after-tokenize', r),
                    i.stringify(o.util.encode(r.tokens), r.language)
                  );
                },
                tokenize: function (e, t) {
                  var n = t.rest;
                  if (n) {
                    for (var r in n) t[r] = n[r];
                    delete t.rest;
                  }
                  var o = new l();
                  return (
                    c(o, o.head, e),
                    s(e, o, t, o.head, 0),
                    (function (e) {
                      for (var t = [], n = e.head.next; n !== e.tail; )
                        t.push(n.value), (n = n.next);
                      return t;
                    })(o)
                  );
                },
                hooks: {
                  all: {},
                  add: function (e, t) {
                    var n = o.hooks.all;
                    (n[e] = n[e] || []), n[e].push(t);
                  },
                  run: function (e, t) {
                    var n = o.hooks.all[e];
                    if (n && n.length) for (var r, i = 0; (r = n[i++]); ) r(t);
                  }
                },
                Token: i
              };
            function i(e, t, n, r) {
              (this.type = e),
                (this.content = t),
                (this.alias = n),
                (this.length = 0 | (r || '').length);
            }
            function a(e, t, n, r) {
              e.lastIndex = t;
              var o = e.exec(n);
              if (o && r && o[1]) {
                var i = o[1].length;
                (o.index += i), (o[0] = o[0].slice(i));
              }
              return o;
            }
            function s(e, t, n, r, l, p) {
              for (var d in n)
                if (n.hasOwnProperty(d) && n[d]) {
                  var f = n[d];
                  f = Array.isArray(f) ? f : [f];
                  for (var h = 0; h < f.length; ++h) {
                    if (p && p.cause == d + ',' + h) return;
                    var m = f[h],
                      g = m.inside,
                      y = !!m.lookbehind,
                      v = !!m.greedy,
                      b = m.alias;
                    if (v && !m.pattern.global) {
                      var w = m.pattern.toString().match(/[imsuy]*$/)[0];
                      m.pattern = RegExp(m.pattern.source, w + 'g');
                    }
                    for (
                      var x = m.pattern || m, k = r.next, _ = l;
                      k !== t.tail && !(p && _ >= p.reach);
                      _ += k.value.length, k = k.next
                    ) {
                      var O = k.value;
                      if (t.length > e.length) return;
                      if (!(O instanceof i)) {
                        var S,
                          E = 1;
                        if (v) {
                          if (!(S = a(x, _, e, y)) || S.index >= e.length)
                            break;
                          var P = S.index,
                            A = S.index + S[0].length,
                            $ = _;
                          for ($ += k.value.length; P >= $; )
                            $ += (k = k.next).value.length;
                          if (((_ = $ -= k.value.length), k.value instanceof i))
                            continue;
                          for (
                            var C = k;
                            C !== t.tail &&
                            ($ < A || 'string' == typeof C.value);
                            C = C.next
                          )
                            E++, ($ += C.value.length);
                          E--, (O = e.slice(_, $)), (S.index -= _);
                        } else if (!(S = a(x, 0, O, y))) continue;
                        P = S.index;
                        var R = S[0],
                          j = O.slice(0, P),
                          T = O.slice(P + R.length),
                          I = _ + O.length;
                        p && I > p.reach && (p.reach = I);
                        var N = k.prev;
                        if (
                          (j && ((N = c(t, N, j)), (_ += j.length)),
                          u(t, N, E),
                          (k = c(
                            t,
                            N,
                            new i(d, g ? o.tokenize(R, g) : R, b, R)
                          )),
                          T && c(t, k, T),
                          E > 1)
                        ) {
                          var D = { cause: d + ',' + h, reach: I };
                          s(e, t, n, k.prev, _, D),
                            p && D.reach > p.reach && (p.reach = D.reach);
                        }
                      }
                    }
                  }
                }
            }
            function l() {
              var e = { value: null, prev: null, next: null },
                t = { value: null, prev: e, next: null };
              (e.next = t), (this.head = e), (this.tail = t), (this.length = 0);
            }
            function c(e, t, n) {
              var r = t.next,
                o = { value: n, prev: t, next: r };
              return (t.next = o), (r.prev = o), e.length++, o;
            }
            function u(e, t, n) {
              for (var r = t.next, o = 0; o < n && r !== e.tail; o++)
                r = r.next;
              (t.next = r), (r.prev = t), (e.length -= o);
            }
            if (
              ((e.Prism = o),
              (i.stringify = function e(t, n) {
                if ('string' == typeof t) return t;
                if (Array.isArray(t)) {
                  var r = '';
                  return (
                    t.forEach(function (t) {
                      r += e(t, n);
                    }),
                    r
                  );
                }
                var i = {
                    type: t.type,
                    content: e(t.content, n),
                    tag: 'span',
                    classes: ['token', t.type],
                    attributes: {},
                    language: n
                  },
                  a = t.alias;
                a &&
                  (Array.isArray(a)
                    ? Array.prototype.push.apply(i.classes, a)
                    : i.classes.push(a)),
                  o.hooks.run('wrap', i);
                var s = '';
                for (var l in i.attributes)
                  s +=
                    ' ' +
                    l +
                    '="' +
                    (i.attributes[l] || '').replace(/"/g, '&quot;') +
                    '"';
                return (
                  '<' +
                  i.tag +
                  ' class="' +
                  i.classes.join(' ') +
                  '"' +
                  s +
                  '>' +
                  i.content +
                  '</' +
                  i.tag +
                  '>'
                );
              }),
              !e.document)
            )
              return e.addEventListener
                ? (o.disableWorkerMessageHandler ||
                    e.addEventListener(
                      'message',
                      function (t) {
                        var n = JSON.parse(t.data),
                          r = n.language,
                          i = n.code,
                          a = n.immediateClose;
                        e.postMessage(o.highlight(i, o.languages[r], r)),
                          a && e.close();
                      },
                      !1
                    ),
                  o)
                : o;
            var p = o.util.currentScript();
            function d() {
              o.manual || o.highlightAll();
            }
            if (
              (p &&
                ((o.filename = p.src),
                p.hasAttribute('data-manual') && (o.manual = !0)),
              !o.manual)
            ) {
              var f = document.readyState;
              'loading' === f || ('interactive' === f && p && p.defer)
                ? document.addEventListener('DOMContentLoaded', d)
                : window.requestAnimationFrame
                ? window.requestAnimationFrame(d)
                : window.setTimeout(d, 16);
            }
            return o;
          })(
            'undefined' != typeof window
              ? window
              : 'undefined' != typeof WorkerGlobalScope &&
                self instanceof WorkerGlobalScope
              ? self
              : {}
          );
          e.exports && (e.exports = r),
            void 0 !== n.g && (n.g.Prism = r),
            (r.languages.markup = {
              comment: { pattern: /<!--(?:(?!<!--)[\\s\\S])*?-->/, greedy: !0 },
              prolog: { pattern: /<\\?[\\s\\S]+?\\?>/, greedy: !0 },
              doctype: {
                pattern:
                  /<!DOCTYPE(?:[^>"'[\\]]|"[^"]*"|'[^']*')+(?:\\[(?:[^<"'\\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\\]\\s*)?>/i,
                greedy: !0,
                inside: {
                  'internal-subset': {
                    pattern: /(^[^\\[]*\\[)[\\s\\S]+(?=\\]>$)/,
                    lookbehind: !0,
                    greedy: !0,
                    inside: null
                  },
                  string: { pattern: /"[^"]*"|'[^']*'/, greedy: !0 },
                  punctuation: /^<!|>$|[[\\]]/,
                  'doctype-tag': /^DOCTYPE/i,
                  name: /[^\\s<>'"]+/
                }
              },
              cdata: { pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i, greedy: !0 },
              tag: {
                pattern:
                  /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s(?:\\s*[^\\s>\\/=]+(?:\\s*=\\s*(?:"[^"]*"|'[^']*'|[^\\s'">=]+(?=[\\s>]))|(?=[\\s/>])))+)?\\s*\\/?>/,
                greedy: !0,
                inside: {
                  tag: {
                    pattern: /^<\\/?[^\\s>\\/]+/,
                    inside: { punctuation: /^<\\/?/, namespace: /^[^\\s>\\/:]+:/ }
                  },
                  'special-attr': [],
                  'attr-value': {
                    pattern: /=\\s*(?:"[^"]*"|'[^']*'|[^\\s'">=]+)/,
                    inside: {
                      punctuation: [
                        { pattern: /^=/, alias: 'attr-equals' },
                        /"|'/
                      ]
                    }
                  },
                  punctuation: /\\/?>/,
                  'attr-name': {
                    pattern: /[^\\s>\\/]+/,
                    inside: { namespace: /^[^\\s>\\/:]+:/ }
                  }
                }
              },
              entity: [
                { pattern: /&[\\da-z]{1,8};/i, alias: 'named-entity' },
                /&#x?[\\da-f]{1,8};/i
              ]
            })