? a(r, o) : e.hasOwnProperty(o) ? a(r, e[o]) : c(o, r, n); }; } function p(e, t, n, r) { return function (r) { var o = r.toLowerCase(); return ( !!t.hasOwnProperty(o) || (!e.hasOwnProperty(o) && c(o, o, n) === o) ); }; } function d(e, t, n) { return ( (n ? t + ' ' : '') + (1 === t ? d.singular(e) : d.plural(e)) ); } return ( (d.plural = u(o, r, e)), (d.isPlural = p(o, r, e)), (d.singular = u(r, o, t)), (d.isSingular = p(r, o, t)), (d.addPluralRule = function (t, n) { e.push([i(t), n]); }), (d.addSingularRule = function (e, n) { t.push([i(e), n]); }), (d.addUncountableRule = function (e) { 'string' != typeof e ? (d.addPluralRule(e, '$0'), d.addSingularRule(e, '$0')) : (n[e.toLowerCase()] = !0); }), (d.addIrregularRule = function (e, t) { (t = t.toLowerCase()), (e = e.toLowerCase()), (o[e] = t), (r[t] = e); }), [ ['I', 'we'], ['me', 'us'], ['he', 'they'], ['she', 'they'], ['them', 'them'], ['myself', 'ourselves'], ['yourself', 'yourselves'], ['itself', 'themselves'], ['herself', 'themselves'], ['himself', 'themselves'], ['themself', 'themselves'], ['is', 'are'], ['was', 'were'], ['has', 'have'], ['this', 'these'], ['that', 'those'], ['echo', 'echoes'], ['dingo', 'dingoes'], ['volcano', 'volcanoes'], ['tornado', 'tornadoes'], ['torpedo', 'torpedoes'], ['genus', 'genera'], ['viscus', 'viscera'], ['stigma', 'stigmata'], ['stoma', 'stomata'], ['dogma', 'dogmata'], ['lemma', 'lemmata'], ['schema', 'schemata'], ['anathema', 'anathemata'], ['ox', 'oxen'], ['axe', 'axes'], ['die', 'dice'], ['yes', 'yeses'], ['foot', 'feet'], ['eave', 'eaves'], ['goose', 'geese'], ['tooth', 'teeth'], ['quiz', 'quizzes'], ['human', 'humans'], ['proof', 'proofs'], ['carve', 'carves'], ['valve', 'valves'], ['looey', 'looies'], ['thief', 'thieves'], ['groove', 'grooves'], ['pickaxe', 'pickaxes'], ['passerby', 'passersby'] ].forEach(function (e) { return d.addIrregularRule(e[0], e[1]); }), [ [/s?$/i, 's'], [/[^\\u0000-\\u007F]$/i, '$0'], [/([^aeiou]ese)$/i, '$1'], [/(ax|test)is$/i, '$1es'], [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'], [/(e[mn]u)s?$/i, '$1s'], [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'], [ /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i' ], [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'], [/(seraph|cherub)(?:im)?$/i, '$1im'], [/(her|at|gr)o$/i, '$1oes'], [ /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a' ], [ /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a' ], [/sis$/i, 'ses'], [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'], [/([^aeiouy]|qu)y$/i, '$1ies'], [/([^ch][ieo][ln])ey$/i, '$1ies'], [/(x|ch|ss|sh|zz)$/i, '$1es'], [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'], [/\\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'], [/(pe)(?:rson|ople)$/i, '$1ople'], [/(child)(?:ren)?$/i, '$1ren'], [/eaux$/i, '$0'], [/m[ae]n$/i, 'men'], ['thou', 'you'] ].forEach(function (e) { return d.addPluralRule(e[0], e[1]); }), [ [/s$/i, ''], [/(ss)$/i, '$1'], [ /(wi|kni|(?:after|half|high|low|mid|non|night|[^\\w]|^)li)ves$/i, '$1fe' ], [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'], [/ies$/i, 'y'], [ /\\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie' ], [/\\b(mon|smil)ies$/i, '$1ey'], [/\\b((?:tit)?m|l)ice$/i, '$1ouse'], [/(seraph|cherub)im$/i, '$1'], [ /(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1' ], [ /(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis' ], [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'], [/(test)(?:is|es)$/i, '$1is'], [ /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us' ], [ /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um' ], [ /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on' ], [/(alumn|alg|vertebr)ae$/i, '$1a'], [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'], [/(matr|append)ices$/i, '$1ix'], [/(pe)(rson|ople)$/i, '$1rson'], [/(child)ren$/i, '$1'], [/(eau)x?$/i, '$1'], [/men$/i, 'man'] ].forEach(function (e) { return d.addSingularRule(e[0], e[1]); }), [ 'adulthood', 'advice', 'agenda', 'aid', 'aircraft', 'alcohol', 'ammo', 'analytics', 'anime', 'athletics', 'audio', 'bison', 'blood', 'bream', 'buffalo', 'butter', 'carp', 'cash', 'chassis', 'chess', 'clothing', 'cod', 'commerce', 'cooperation', 'corps', 'debris', 'diabetes', 'digestion', 'elk', 'energy', 'equipment', 'excretion', 'expertise', 'firmware', 'flounder', 'fun', 'gallows', 'garbage', 'graffiti', 'hardware', 'headquarters', 'health', 'herpes', 'highjinks', 'homework', 'housework', 'information', 'jeans', 'justice', 'kudos', 'labour', 'literature', 'machinery', 'mackerel', 'mail', 'media', 'mews', 'moose', 'music', 'mud', 'manga', 'news', 'only', 'personnel', 'pike', 'plankton', 'pliers', 'police', 'pollution', 'premises', 'rain', 'research', 'rice', 'salmon', 'scissors', 'series', 'sewage', 'shambles', 'shrimp', 'software', 'species', 'staff', 'swine', 'tennis', 'traffic', 'transportation', 'trout', 'tuna', 'wealth', 'welfare', 'whiting', 'wildebeest', 'wildlife', 'you', /pok[e\xE9]mon$/i, /[^aeiou]ese$/i, /deer$/i, /fish$/i, /measles$/i, /o[iu]s$/i, /pox$/i, /sheep$/i ].forEach(d.addUncountableRule), d ); })(); }, 7874: function () { !(function (e) { var t = '\\\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\\\b', n = { pattern: /(^(["']?)\\w+\\2)[ \\t]+\\S.*/, lookbehind: !0, alias: 'punctuation', inside: null }, r = { bash: n, environment: { pattern: RegExp('\\\\$' + t), alias: 'constant' }, variable: [ { pattern: /\\$?\\(\\([\\s\\S]+?\\)\\)/, greedy: !0, inside: { variable: [ { pattern: /(^\\$\\(\\([\\s\\S]+)\\)\\)/, lookbehind: !0 }, /^\\$\\(\\(/ ], number: /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee]-?\\d+)?/, operator: /--|\\+\\+|\\*\\*=?|<<=?|>>=?|&&|\\|\\||[=!+\\-*/%<>^&|]=?|[?~:]/, punctuation: /\\(\\(?|\\)\\)?|,|;/ } }, { pattern: /\\$\\((?:\\([^)]+\\)|[^()])+\\)|\`[^\`]+\`/, greedy: !0, inside: { variable: /^\\$\\(|^\`|\\)$|\`$/ } }, { pattern: /\\$\\{[^}]+\\}/, greedy: !0, inside: { operator: /:[-=?+]?|[!\\/]|##?|%%?|\\^\\^?|,,?/, punctuation: /[\\[\\]]/, environment: { pattern: RegExp('(\\\\{)' + t), lookbehind: !0, alias: 'constant' } } }, /\\$(?:\\w+|[#?*!@$])/ ], entity: /\\\\(?:[abceEfnrtv\\\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/ }; (e.languages.bash = { shebang: { pattern: /^#!\\s*\\/.*/, alias: 'important' }, comment: { pattern: /(^|[^"{\\\\$])#.*/, lookbehind: !0 }, 'function-name': [ { pattern: /(\\bfunction\\s+)[\\w-]+(?=(?:\\s*\\(?:\\s*\\))?\\s*\\{)/, lookbehind: !0, alias: 'function' }, { pattern: /\\b[\\w-]+(?=\\s*\\(\\s*\\)\\s*\\{)/, alias: 'function' } ], 'for-or-select': { pattern: /(\\b(?:for|select)\\s+)\\w+(?=\\s+in\\s)/, alias: 'variable', lookbehind: !0 }, 'assign-left': { pattern: /(^|[\\s;|&]|[<>]\\()\\w+(?=\\+?=)/, inside: { environment: { pattern: RegExp('(^|[\\\\s;|&]|[<>]\\\\()' + t), lookbehind: !0, alias: 'constant' } }, alias: 'variable', lookbehind: !0 }, string: [ { pattern: /((?:^|[^<])<<-?\\s*)(\\w+)\\s[\\s\\S]*?(?:\\r?\\n|\\r)\\2/, lookbehind: !0, greedy: !0, inside: r }, { pattern: /((?:^|[^<])<<-?\\s*)(["'])(\\w+)\\2\\s[\\s\\S]*?(?:\\r?\\n|\\r)\\3/, lookbehind: !0, greedy: !0, inside: { bash: n } }, { pattern: /(^|[^\\\\](?:\\\\\\\\)*)"(?:\\\\[\\s\\S]|\\$\\([^)]+\\)|\\$(?!\\()|\`[^\`]+\`|[^"\\\\\`$])*"/, lookbehind: !0, greedy: !0, inside: r }, { pattern: /(^|[^$\\\\])'[^']*'/, lookbehind: !0, greedy: !0 }, { pattern: /\\$'(?:[^'\\\\]|\\\\[\\s\\S])*'/, greedy: !0, inside: { entity: r.entity } } ], environment: { pattern: RegExp('\\\\$?' + t), alias: 'constant' }, variable: r.variable, function: { pattern: /(^|[\\s;|&]|[<>]\\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\\s;|&])/, lookbehind: !0 }, keyword: { pattern: /(^|[\\s;|&]|[<>]\\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\\s;|&])/, lookbehind: !0 }, builtin: { pattern: /(^|[\\s;|&]|[<>]\\()(?:\\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\\s;|&])/, lookbehind: !0, alias: 'class-name' }, boolean: { pattern: /(^|[\\s;|&]|[<>]\\()(?:false|true)(?=$|[)\\s;|&])/, lookbehind: !0 }, 'file-descriptor': { pattern: /\\B&\\d\\b/, alias: 'important' }, operator: { pattern: /\\d?<>|>\\||\\+=|=[=~]?|!=?|<<[<-]?|[&\\d]?>>|\\d[<>]&?|[<>][&=]?|&[>&]?|\\|[&|]?/, inside: { 'file-descriptor': { pattern: /^\\d/, alias: 'important' } } }, punctuation: /\\$?\\(\\(?|\\)\\)?|\\.\\.|[{}[\\];\\\\]/, number: { pattern: /(^|\\s)(?:[1-9]\\d*|0)(?:[.,]\\d+)?\\b/, lookbehind: !0 } }), (n.inside = e.languages.bash); for ( var o = [ 'comment', 'function-name', 'for-or-select', 'assign-left', 'string', 'environment', 'function', 'keyword', 'builtin', 'boolean', 'file-descriptor', 'operator', 'punctuation', 'number' ], i = r.variable[1].inside, a = 0; a < o.length; a++ ) i[o[a]] = e.languages.bash[o[a]]; e.languages.shell = e.languages.bash; })(Prism); }, 4279: function () { (Prism.languages.c = Prism.languages.extend('clike', { comment: { pattern: /\\/\\/(?:[^\\r\\n\\\\]|\\\\(?:\\r\\n?|\\n|(?![\\r\\n])))*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/, greedy: !0 }, string: { pattern: /"(?:\\\\(?:\\r\\n|[\\s\\S])|[^"\\\\\\r\\n])*"/, greedy: !0 }, 'class-name': { pattern: /(\\b(?:enum|struct)\\s+(?:__attribute__\\s*\\(\\([\\s\\S]*?\\)\\)\\s*)?)\\w+|\\b[a-z]\\w*_t\\b/, lookbehind: !0 }, keyword: /\\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\\b/, function: /\\b[a-z_]\\w*(?=\\s*\\()/i, number: /(?:\\b0x(?:[\\da-f]+(?:\\.[\\da-f]*)?|\\.[\\da-f]+)(?:p[+-]?\\d+)?|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?)[ful]{0,4}/i, operator: />>=?|<<=?|->|([-+&|:])\\1|[?:~]|[-+*/%&|^!=<>]=?/ })), Prism.languages.insertBefore('c', 'string', { char: { pattern: /'(?:\\\\(?:\\r\\n|[\\s\\S])|[^'\\\\\\r\\n]){0,32}'/, greedy: !0 } }), Prism.languages.insertBefore('c', 'string', { macro: { pattern: /(^[\\t ]*)#\\s*[a-z](?:[^\\r\\n\\\\/]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|\\\\(?:\\r\\n|[\\s\\S]))*/im, lookbehind: !0, greedy: !0, alias: 'property', inside: { string: [ { pattern: /^(#\\s*include\\s*)<[^>]+>/, lookbehind: !0 }, Prism.languages.c.string ], char: Prism.languages.c.char, comment: Prism.languages.c.comment, 'macro-name': [ { pattern: /(^#\\s*define\\s+)\\w+\\b(?!\\()/i, lookbehind: !0 }, { pattern: /(^#\\s*define\\s+)\\w+\\b(?=\\()/i, lookbehind: !0, alias: 'function' } ], directive: { pattern: /^(#\\s*)[a-z]+/, lookbehind: !0, alias: 'keyword' }, 'directive-hash': /^#/, punctuation: /##|\\\\(?=[\\r\\n])/, expression: { pattern: /\\S[\\s\\S]*/, inside: Prism.languages.c } } } }), Prism.languages.insertBefore('c', 'function', { constant: /\\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\\b/ }), delete Prism.languages.c.boolean; }, 5433: function () { Prism.languages.clike = { comment: [ { pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/, lookbehind: !0, greedy: !0 }, { pattern: /(^|[^\\\\:])\\/\\/.*/, lookbehind: !0, greedy: !0 } ], string: { pattern: /(["'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/, greedy: !0 }, 'class-name': { pattern: /(\\b(?:class|extends|implements|instanceof|interface|new|trait)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+/i, lookbehind: !0, inside: { punctuation: /[.\\\\]/ } }, keyword: /\\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\\b/, boolean: /\\b(?:false|true)\\b/, function: /\\b\\w+(?=\\()/, number: /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i, operator: /[<>]=?|[!=]=?=?|--?|\\+\\+?|&&?|\\|\\|?|[?*/~^%]/, punctuation: /[{}[\\];(),.:]/ }; }, 6213: function () { !(function (e) { var t = /#(?!\\{).+/, n = { pattern: /#\\{[^}]+\\}/, alias: 'variable' }; (e.languages.coffeescript = e.languages.extend('javascript', { comment: t, string: [ { pattern: /'(?:\\\\[\\s\\S]|[^\\\\'])*'/, greedy: !0 }, { pattern: /"(?:\\\\[\\s\\S]|[^\\\\"])*"/, greedy: !0, inside: { interpolation: 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/, 'class-member': { pattern: /@(?!\\d)\\w+/, alias: 'variable' } })), e.languages.insertBefore('coffeescript', 'comment', { 'multiline-comment': { pattern: /###[\\s\\S]+?###/, alias: 'comment' }, 'block-regex': { pattern: /\\/{3}[\\s\\S]*?\\/{3}/, alias: 'regex', inside: { comment: t, interpolation: n } } }), e.languages.insertBefore('coffeescript', 'string', { 'inline-javascript': { pattern: /\`(?:\\\\[\\s\\S]|[^\\\\\`])*\`/, inside: { delimiter: { pattern: /^\`|\`$/, alias: 'punctuation' }, script: { pattern: /[\\s\\S]+/, alias: 'language-javascript', inside: e.languages.javascript } } }, 'multiline-string': [ { pattern: /'''[\\s\\S]*?'''/, greedy: !0, alias: 'string' }, { pattern: /"""[\\s\\S]*?"""/, greedy: !0, alias: 'string', inside: { interpolation: n } } ] }), e.languages.insertBefore('coffeescript', 'keyword', { property: /(?!\\d)\\w+(?=\\s*:(?!:))/ }), delete e.languages.coffeescript['template-string'], (e.languages.coffee = e.languages.coffeescript); })(Prism); }, 2731: function () { !(function (e) { var t = /\\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\\b/, n = /\\b(?!)\\w+(?:\\s*\\.\\s*\\w+)*\\b/.source.replace( //g, function () { return t.source; } ); (e.languages.cpp = e.languages.extend('c', { 'class-name': [ { pattern: RegExp( /(\\b(?:class|concept|enum|struct|typename)\\s+)(?!)\\w+/.source.replace( //g, function () { return t.source; } ) ), lookbehind: !0 }, /\\b[A-Z]\\w*(?=\\s*::\\s*\\w+\\s*\\()/, /\\b[A-Z_]\\w*(?=\\s*::\\s*~\\w+\\s*\\()/i, /\\b\\w+(?=\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\\s*::\\s*\\w+\\s*\\()/ ], keyword: t, number: { pattern: /(?:\\b0b[01']+|\\b0x(?:[\\da-f']+(?:\\.[\\da-f']*)?|\\.[\\da-f']+)(?:p[+-]?[\\d']+)?|(?:\\b[\\d']+(?:\\.[\\d']*)?|\\B\\.[\\d']+)(?:e[+-]?[\\d']+)?)[ful]{0,4}/i, greedy: !0 }, operator: />>=?|<<=?|->|--|\\+\\+|&&|\\|\\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\\b/, boolean: /\\b(?:false|true)\\b/ })), e.languages.insertBefore('cpp', 'string', { module: { pattern: RegExp( /(\\b(?:import|module)\\s+)/.source + '(?:' + /"(?:\\\\(?:\\r\\n|[\\s\\S])|[^"\\\\\\r\\n])*"|<[^<>\\r\\n]*>/ .source + '|' + /(?:\\s*:\\s*)?|:\\s*/.source.replace( //g, function () { return n; } ) + ')' ), lookbehind: !0, greedy: !0, inside: { string: /^[<"][\\s\\S]+/, operator: /:/, punctuation: /\\./ } }, 'raw-string': { pattern: /R"([^()\\\\ ]{0,16})\\([\\s\\S]*?\\)\\1"/, alias: 'string', greedy: !0 } }), e.languages.insertBefore('cpp', 'keyword', { 'generic-function': { pattern: /\\b(?!operator\\b)[a-z_]\\w*\\s*<(?:[^<>]|<[^<>]*>)*>(?=\\s*\\()/i, inside: { function: /^\\w+/, generic: { pattern: /<[\\s\\S]+/, alias: 'class-name', inside: e.languages.cpp } } } }), e.languages.insertBefore('cpp', 'operator', { 'double-colon': { pattern: /::/, alias: 'punctuation' } }), e.languages.insertBefore('cpp', 'class-name', { 'base-clause': { pattern: /(\\b(?:class|struct)\\s+\\w+\\s*:\\s*)[^;{}"'\\s]+(?:\\s+[^;{}"'\\s]+)*(?=\\s*[;{])/, lookbehind: !0, greedy: !0, inside: e.languages.extend('cpp', {}) } }), e.languages.insertBefore( 'inside', 'double-colon', { 'class-name': /\\b[a-z_]\\w*\\b(?!\\s*::)/i }, e.languages.cpp['base-clause'] ); })(Prism); }, 3967: function () { !(function (e) { function t(e, t) { return e.replace(/<<(\\d+)>>/g, function (e, n) { return '(?:' + t[+n] + ')'; }); } function n(e, n, r) { return RegExp(t(e, n), r || ''); } function r(e, t) { for (var n = 0; n < t; n++) e = e.replace(/<>/g, function () { return '(?:' + e + ')'; }); return e.replace(/<>/g, '[^\\\\s\\\\S]'); } var o = 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void', i = 'class enum interface record struct', a = 'add alias and ascending async await by descending from(?=\\\\s*(?:\\\\w|$)) get global group into init(?=\\\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\\\s*{)', s = 'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield'; function l(e) { return '\\\\b(?:' + e.trim().replace(/ /g, '|') + ')\\\\b'; } var c = l(i), u = RegExp(l(o + ' ' + i + ' ' + a + ' ' + s)), p = l(i + ' ' + a + ' ' + s), d = l(o + ' ' + i + ' ' + s), f = r(/<(?:[^<>;=+\\-*/%&|^]|<>)*>/.source, 2), h = r(/\\((?:[^()]|<>)*\\)/.source, 2), m = /@?\\b[A-Za-z_]\\w*\\b/.source, g = t(/<<0>>(?:\\s*<<1>>)?/.source, [m, f]), y = t(/(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*/.source, [p, g]), v = /\\[\\s*(?:,\\s*)*\\]/.source, b = t(/<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?/.source, [y, v]), w = t(/[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [ f, h, v ]), x = t(/\\(<<0>>+(?:,<<0>>+)+\\)/.source, [w]), k = t(/(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?/.source, [ x, y, v ]), _ = { keyword: u, punctuation: /[<>()?,.:[\\]]/ }, O = /'(?:[^\\r\\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'/.source, S = /"(?:\\\\.|[^\\\\"\\r\\n])*"/.source, E = /@"(?:""|\\\\[\\s\\S]|[^\\\\"])*"(?!")/.source; (e.languages.csharp = e.languages.extend('clike', { string: [ { pattern: n(/(^|[^$\\\\])<<0>>/.source, [E]), lookbehind: !0, greedy: !0 }, { pattern: n(/(^|[^@$\\\\])<<0>>/.source, [S]), lookbehind: !0, greedy: !0 } ], 'class-name': [ { pattern: n(/(\\busing\\s+static\\s+)<<0>>(?=\\s*;)/.source, [y]), lookbehind: !0, inside: _ }, { pattern: n(/(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)/.source, [ m, k ]), lookbehind: !0, inside: _ }, { pattern: n(/(\\busing\\s+)<<0>>(?=\\s*=)/.source, [m]), lookbehind: !0 }, { pattern: n(/(\\b<<0>>\\s+)<<1>>/.source, [c, g]), lookbehind: !0, inside: _ }, { pattern: n(/(\\bcatch\\s*\\(\\s*)<<0>>/.source, [y]), lookbehind: !0, inside: _ }, { pattern: n(/(\\bwhere\\s+)<<0>>/.source, [m]), lookbehind: !0 }, { pattern: n(/(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>/.source, [b]), lookbehind: !0, inside: _ }, { pattern: n( /\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))/ .source, [k, d, m] ), inside: _ } ], keyword: u, number: /(?:\\b0(?:x[\\da-f_]*[\\da-f]|b[01_]*[01])|(?:\\B\\.\\d+(?:_+\\d+)*|\\b\\d+(?:_+\\d+)*(?:\\.\\d+(?:_+\\d+)*)?)(?:e[-+]?\\d+(?:_+\\d+)*)?)(?:[dflmu]|lu|ul)?\\b/i, operator: />>=?|<<=?|[-=]>|([-+&|])\\1|~|\\?\\?=?|[-+*/%&|^!=<>]=?/, punctuation: /\\?\\.?|::|[{}[\\];(),.:]/ })), e.languages.insertBefore('csharp', 'number', { range: { pattern: /\\.\\./, alias: 'operator' } }), e.languages.insertBefore('csharp', 'punctuation', { 'named-parameter': { pattern: n(/([(,]\\s*)<<0>>(?=\\s*:)/.source, [m]), lookbehind: !0, alias: 'punctuation' } }), e.languages.insertBefore('csharp', 'class-name', { namespace: { pattern: n( /(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])/ .source, [m] ), lookbehind: !0, inside: { punctuation: /\\./ } }, 'type-expression': { pattern: n( /(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))/ .source, [h] ), lookbehind: !0, alias: 'class-name', inside: _ }, 'return-type': { pattern: n( /<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))/ .source, [k, y] ), inside: _, alias: 'class-name' }, 'constructor-invocation': { pattern: n(/(\\bnew\\s+)<<0>>(?=\\s*[[({])/.source, [k]), lookbehind: !0, inside: _, alias: 'class-name' }, 'generic-method': { pattern: n(/<<0>>\\s*<<1>>(?=\\s*\\()/.source, [m, f]), inside: { function: n(/^<<0>>/.source, [m]), generic: { pattern: RegExp(f), alias: 'class-name', inside: _ } } }, 'type-list': { pattern: n( /\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))/ .source, [c, g, m, k, u.source, h, /\\bnew\\s*\\(\\s*\\)/.source] ), lookbehind: !0, inside: { 'record-arguments': { pattern: n(/(^(?!new\\s*\\()<<0>>\\s*)<<1>>/.source, [g, h]), lookbehind: !0, greedy: !0, inside: e.languages.csharp }, keyword: u, 'class-name': { pattern: RegExp(k), greedy: !0, inside: _ }, punctuation: /[,()]/ } }, preprocessor: { pattern: /(^[\\t ]*)#.*/m, lookbehind: !0, alias: 'property', inside: { directive: { pattern: /(#)\\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\\b/, lookbehind: !0, alias: 'keyword' } } } }); var P = S + '|' + O, A = t( /\\/(?![*/])|\\/\\/[^\\r\\n]*[\\r\\n]|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>/ .source, [P] ), $ = r(t(/[^"'/()]|<<0>>|\\(<>*\\)/.source, [A]), 2), C = /\\b(?:assembly|event|field|method|module|param|property|return|type)\\b/ .source, R = t(/<<0>>(?:\\s*\\(<<1>>*\\))?/.source, [y, $]); e.languages.insertBefore('csharp', 'class-name', { attribute: { pattern: n( /((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])/ .source, [C, R] ), lookbehind: !0, greedy: !0, inside: { target: { pattern: n(/^<<0>>(?=\\s*:)/.source, [C]), alias: 'keyword' }, 'attribute-arguments': { pattern: n(/\\(<<0>>*\\)/.source, [$]), inside: e.languages.csharp }, 'class-name': { pattern: RegExp(y), inside: { punctuation: /\\./ } }, punctuation: /[:,]/ } } }); var j = /:[^}\\r\\n]+/.source, T = r(t(/[^"'/()]|<<0>>|\\(<>*\\)/.source, [A]), 2), I = t(/\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}/.source, [T, j]), N = r( t( /[^"'/()]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>|\\(<>*\\)/ .source, [P] ), 2 ), D = t(/\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}/.source, [N, j]); function L(t, r) { return { interpolation: { pattern: n(/((?:^|[^{])(?:\\{\\{)*)<<0>>/.source, [t]), lookbehind: !0, inside: { 'format-string': { pattern: n(/(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)/.source, [ r, j ]), lookbehind: !0, inside: { punctuation: /^:/ } }, punctuation: /^\\{|\\}$/, expression: { pattern: /[\\s\\S]+/, alias: 'language-csharp', inside: e.languages.csharp } } }, string: /[\\s\\S]+/ }; } e.languages.insertBefore('csharp', 'string', { 'interpolation-string': [ { pattern: n( /(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[\\s\\S]|\\{\\{|<<0>>|[^\\\\{"])*"/ .source, [I] ), lookbehind: !0, greedy: !0, inside: L(I, T) }, { pattern: n( /(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<<0>>|[^\\\\"{])*"/.source, [D] ), lookbehind: !0, greedy: !0, inside: L(D, N) } ], char: { pattern: RegExp(O), greedy: !0 } }), (e.languages.dotnet = e.languages.cs = e.languages.csharp); })(Prism); }, 8052: function () { Prism.languages.csv = { value: /[^\\r\\n,"]+|"(?:[^"]|"")*"(?!")/, punctuation: /,/ }; }, 7046: function () { (Prism.languages.go = Prism.languages.extend('clike', { string: { pattern: /(^|[^\\\\])"(?:\\\\.|[^"\\\\\\r\\n])*"|\`[^\`]*\`/, lookbehind: !0, greedy: !0 }, keyword: /\\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\\b/, boolean: /\\b(?:_|false|iota|nil|true)\\b/, number: [ /\\b0(?:b[01_]+|o[0-7_]+)i?\\b/i, /\\b0x(?:[a-f\\d_]+(?:\\.[a-f\\d_]*)?|\\.[a-f\\d_]+)(?:p[+-]?\\d+(?:_\\d+)*)?i?(?!\\w)/i, /(?:\\b\\d[\\d_]*(?:\\.[\\d_]*)?|\\B\\.\\d[\\d_]*)(?:e[+-]?[\\d_]+)?i?(?!\\w)/i ], operator: /[*\\/%^!=]=?|\\+[=+]?|-[=-]?|\\|[=|]?|&(?:=|&|\\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\\.\\.\\./, builtin: /\\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\\b/ })), Prism.languages.insertBefore('go', 'string', { char: { pattern: /'(?:\\\\.|[^'\\\\\\r\\n]){0,10}'/, greedy: !0 } }), delete Prism.languages.go['class-name']; }, 57: function () { !(function (e) { function t(e) { return RegExp('(^(?:' + e + '):[ \\t]*(?![ \\t]))[^]+', 'i'); } e.languages.http = { 'request-line': { pattern: /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\\s(?:https?:\\/\\/|\\/)\\S*\\sHTTP\\/[\\d.]+/m, inside: { method: { pattern: /^[A-Z]+\\b/, alias: 'property' }, 'request-target': { pattern: /^(\\s)(?:https?:\\/\\/|\\/)\\S*(?=\\s)/, lookbehind: !0, alias: 'url', inside: e.languages.uri }, 'http-version': { pattern: /^(\\s)HTTP\\/[\\d.]+/, lookbehind: !0, alias: 'property' } } }, 'response-status': { pattern: /^HTTP\\/[\\d.]+ \\d+ .+/m, inside: { 'http-version': { pattern: /^HTTP\\/[\\d.]+/, alias: 'property' }, 'status-code': { pattern: /^(\\s)\\d+(?=\\s)/, lookbehind: !0, alias: 'number' }, 'reason-phrase': { pattern: /^(\\s).+/, lookbehind: !0, alias: 'string' } } }, header: { pattern: /^[\\w-]+:.+(?:(?:\\r\\n?|\\n)[ \\t].+)*/m, inside: { 'header-value': [ { pattern: t(/Content-Security-Policy/.source), lookbehind: !0, alias: ['csp', 'languages-csp'], inside: e.languages.csp }, { pattern: t(/Public-Key-Pins(?:-Report-Only)?/.source), lookbehind: !0, alias: ['hpkp', 'languages-hpkp'], inside: e.languages.hpkp }, { pattern: t(/Strict-Transport-Security/.source), lookbehind: !0, alias: ['hsts', 'languages-hsts'], inside: e.languages.hsts }, { pattern: t(/[^:]+/.source), lookbehind: !0 } ], 'header-name': { pattern: /^[^:]+/, alias: 'keyword' }, punctuation: /^:/ } } }; var n, r = e.languages, o = { 'application/javascript': r.javascript, 'application/json': r.json || r.javascript, 'application/xml': r.xml, 'text/xml': r.xml, 'text/html': r.html, 'text/css': r.css, 'text/plain': r.plain }, i = { 'application/json': !0, 'application/xml': !0 }; function a(e) { var t = e.replace(/^[a-z]+\\//, ''); return '(?:' + e + '|\\\\w+/(?:[\\\\w.-]+\\\\+)+' + t + '(?![+\\\\w.-]))'; } for (var s in o) if (o[s]) { n = n || {}; var l = i[s] ? a(s) : s; n[s.replace(/\\//g, '-')] = { pattern: RegExp( '(' + /content-type:\\s*/.source + l + /(?:(?:\\r\\n?|\\n)[\\w-].*)*(?:\\r(?:\\n|(?!\\n))|\\n)/.source + ')' + /[^ \\t\\w-][\\s\\S]*/.source, 'i' ), lookbehind: !0, inside: o[s] }; } n && e.languages.insertBefore('http', 'header', n); })(Prism); }, 2503: function () { !(function (e) { var t = /\\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\\b/, n = /(^|[^\\w.])(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*/.source, r = { pattern: RegExp(n + /[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b/.source), lookbehind: !0, inside: { namespace: { pattern: /^[a-z]\\w*(?:\\s*\\.\\s*[a-z]\\w*)*(?:\\s*\\.)?/, inside: { punctuation: /\\./ } }, punctuation: /\\./ } }; (e.languages.java = e.languages.extend('clike', { string: { pattern: /(^|[^\\\\])"(?:\\\\.|[^"\\\\\\r\\n])*"/, lookbehind: !0, greedy: !0 }, 'class-name': [ r, { pattern: RegExp(n + /[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()])/.source), lookbehind: !0, inside: r.inside } ], keyword: t, function: [ e.languages.clike.function, { pattern: /(::\\s*)[a-z_]\\w*/, lookbehind: !0 } ], number: /\\b0b[01][01_]*L?\\b|\\b0x(?:\\.[\\da-f_p+-]+|[\\da-f_]+(?:\\.[\\da-f_p+-]+)?)\\b|(?:\\b\\d[\\d_]*(?:\\.[\\d_]*)?|\\B\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[dfl]?/i, operator: { pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\\+\\+|&&|\\|\\||::|[?:~]|[-+*/%&|^!=<>]=?)/m, lookbehind: !0 } })), e.languages.insertBefore('java', 'string', { 'triple-quoted-string': { pattern: /"""[ \\t]*[\\r\\n](?:(?:"|"")?(?:\\\\.|[^"\\\\]))*"""/, greedy: !0, alias: 'string' }, char: { pattern: /'(?:\\\\.|[^'\\\\\\r\\n]){1,6}'/, greedy: !0 } }), e.languages.insertBefore('java', 'class-name', { annotation: { pattern: /(^|[^.])@\\w+(?:\\s*\\.\\s*\\w+)*/, lookbehind: !0, alias: 'punctuation' }, generics: { pattern: /<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&))*>)*>)*>)*>/, inside: { 'class-name': r, keyword: t, punctuation: /[<>(),.:]/, operator: /[?&|]/ } }, namespace: { pattern: RegExp( /(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?/.source.replace( //g, function () { return t.source; } ) ), lookbehind: !0, inside: { punctuation: /\\./ } } }); })(Prism); }, 6841: function () { Prism.languages.lua = { comment: /^#!.+|--(?:\\[(=*)\\[[\\s\\S]*?\\]\\1\\]|.*)/m, string: { pattern: /(["'])(?:(?!\\1)[^\\\\\\r\\n]|\\\\z(?:\\r\\n|\\s)|\\\\(?:\\r\\n|[^z]))*\\1|\\[(=*)\\[[\\s\\S]*?\\]\\2\\]/, greedy: !0 }, number: /\\b0x[a-f\\d]+(?:\\.[a-f\\d]*)?(?:p[+-]?\\d+)?\\b|\\b\\d+(?:\\.\\B|(?:\\.\\d*)?(?:e[+-]?\\d+)?\\b)|\\B\\.\\d+(?:e[+-]?\\d+)?\\b/i, keyword: /\\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\\b/, function: /(?!\\d)\\w+(?=\\s*(?:[({]))/, operator: [ /[-+*%^&|#]|\\/\\/?|<[<=]?|>[>=]?|[=~]=?/, { pattern: /(^|[^.])\\.\\.(?!\\.)/, lookbehind: !0 } ], punctuation: /[\\[\\](){},;]|\\.+|:+/ }; }, 6854: function () { !(function (e) { function t(e, t) { return '___' + e.toUpperCase() + t + '___'; } Object.defineProperties((e.languages['markup-templating'] = {}), { buildPlaceholders: { value: function (n, r, o, i) { if (n.language === r) { var a = (n.tokenStack = []); (n.code = n.code.replace(o, function (e) { if ('function' == typeof i && !i(e)) return e; for ( var o, s = a.length; -1 !== n.code.indexOf((o = t(r, s))); ) ++s; return (a[s] = e), o; })), (n.grammar = e.languages.markup); } } }, tokenizePlaceholders: { value: function (n, r) { if (n.language === r && n.tokenStack) { n.grammar = e.languages[r]; var o = 0, i = Object.keys(n.tokenStack); !(function a(s) { for (var l = 0; l < s.length && !(o >= i.length); l++) { var c = s[l]; if ( 'string' == typeof c || (c.content && 'string' == typeof c.content) ) { var u = i[o], p = n.tokenStack[u], d = 'string' == typeof c ? c : c.content, f = t(r, u), h = d.indexOf(f); if (h > -1) { ++o; var m = d.substring(0, h), g = new e.Token( r, e.tokenize(p, n.grammar), 'language-' + r, p ), y = d.substring(h + f.length), v = []; m && v.push.apply(v, a([m])), v.push(g), y && v.push.apply(v, a([y])), 'string' == typeof c ? s.splice.apply(s, [l, 1].concat(v)) : (c.content = v); } } else c.content && a(c.content); } return s; })(n.tokens); } } } }); })(Prism); }, 4335: function () { (Prism.languages.markup = { comment: { pattern: //, greedy: !0 }, prolog: { pattern: /<\\?[\\s\\S]+?\\?>/, greedy: !0 }, doctype: { pattern: /"'[\\]]|"[^"]*"|'[^']*')+(?:\\[(?:[^<"'\\]]|"[^"]*"|'[^']*'|<(?!!--)|)*\\]\\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: //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 ] }), (Prism.languages.markup.tag.inside['attr-value'].inside.entity = Prism.languages.markup.entity), (Prism.languages.markup.doctype.inside['internal-subset'].inside = Prism.languages.markup), Prism.hooks.add('wrap', function (e) { 'entity' === e.type && (e.attributes.title = e.content.replace(/&/, '&')); }), Object.defineProperty(Prism.languages.markup.tag, 'addInlined', { value: function (e, t) { var n = {}; (n['language-' + t] = { pattern: /(^$)/i, lookbehind: !0, inside: Prism.languages[t] }), (n.cdata = /^$/i); var r = { 'included-cdata': { pattern: //i, inside: n } }; r['language-' + t] = { pattern: /[\\s\\S]+/, inside: Prism.languages[t] }; var o = {}; (o[e] = { pattern: RegExp( /(<__[^>]*>)(?:))*\\]\\]>|(?!)/.source.replace( /__/g, function () { return e; } ), 'i' ), lookbehind: !0, greedy: !0, inside: r }), Prism.languages.insertBefore('markup', 'cdata', o); } }), Object.defineProperty(Prism.languages.markup.tag, 'addAttribute', { value: function (e, t) { Prism.languages.markup.tag.inside['special-attr'].push({ pattern: RegExp( /(^|["'\\s])/.source + '(?:' + e + ')' + /\\s*=\\s*(?:"[^"]*"|'[^']*'|[^\\s'">=]+(?=[\\s>]))/.source, 'i' ), lookbehind: !0, inside: { 'attr-name': /^[^\\s=]+/, 'attr-value': { pattern: /=[\\s\\S]+/, inside: { value: { pattern: /(^=\\s*(["']|(?!["'])))\\S[\\s\\S]*(?=\\2$)/, lookbehind: !0, alias: [t, 'language-' + t], inside: Prism.languages[t] }, punctuation: [ { pattern: /^=/, alias: 'attr-equals' }, /"|'/ ] } } } }); } }),