} userOptions
+ */
+ function configure(userOptions) {
+ if (userOptions.useBR) {
+ deprecated("10.3.0", "'useBR' will be removed entirely in v11.0");
+ deprecated("10.3.0", "Please see https://github.com/highlightjs/highlight.js/issues/2559");
+ }
+ options = inherit$1(options, userOptions);
+ }
+
+ /**
+ * Highlights to all blocks on a page
+ *
+ * @type {Function & {called?: boolean}}
+ */
+ // TODO: remove v12, deprecated
+ const initHighlighting = () => {
+ if (initHighlighting.called) return;
+ initHighlighting.called = true;
+
+ deprecated("10.6.0", "initHighlighting() is deprecated. Use highlightAll() instead.");
+
+ const blocks = document.querySelectorAll('pre code');
+ blocks.forEach(highlightElement);
+ };
+
+ // Higlights all when DOMContentLoaded fires
+ // TODO: remove v12, deprecated
+ function initHighlightingOnLoad() {
+ deprecated("10.6.0", "initHighlightingOnLoad() is deprecated. Use highlightAll() instead.");
+ wantsHighlight = true;
+ }
+
+ let wantsHighlight = false;
+
+ /**
+ * auto-highlights all pre>code elements on the page
+ */
+ function highlightAll() {
+ // if we are called too early in the loading process
+ if (document.readyState === "loading") {
+ wantsHighlight = true;
+ return;
+ }
+
+ const blocks = document.querySelectorAll('pre code');
+ blocks.forEach(highlightElement);
+ }
+
+ function boot() {
+ // if a highlight was requested before DOM was loaded, do now
+ if (wantsHighlight) highlightAll();
+ }
+
+ // make sure we are in the browser environment
+ if (typeof window !== 'undefined' && window.addEventListener) {
+ window.addEventListener('DOMContentLoaded', boot, false);
+ }
+
+ /**
+ * Register a language grammar module
+ *
+ * @param {string} languageName
+ * @param {LanguageFn} languageDefinition
+ */
+ function registerLanguage(languageName, languageDefinition) {
+ let lang = null;
+ try {
+ lang = languageDefinition(hljs);
+ } catch (error$1) {
+ error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+ // hard or soft error
+ if (!SAFE_MODE) { throw error$1; } else { error(error$1); }
+ // languages that have serious errors are replaced with essentially a
+ // "plaintext" stand-in so that the code blocks will still get normal
+ // css classes applied to them - and one bad language won't break the
+ // entire highlighter
+ lang = PLAINTEXT_LANGUAGE;
+ }
+ // give it a temporary name if it doesn't have one in the meta-data
+ if (!lang.name) lang.name = languageName;
+ languages[languageName] = lang;
+ lang.rawDefinition = languageDefinition.bind(null, hljs);
+
+ if (lang.aliases) {
+ registerAliases(lang.aliases, { languageName });
+ }
+ }
+
+ /**
+ * Remove a language grammar module
+ *
+ * @param {string} languageName
+ */
+ function unregisterLanguage(languageName) {
+ delete languages[languageName];
+ for (const alias of Object.keys(aliases)) {
+ if (aliases[alias] === languageName) {
+ delete aliases[alias];
+ }
+ }
+ }
+
+ /**
+ * @returns {string[]} List of language internal names
+ */
+ function listLanguages() {
+ return Object.keys(languages);
+ }
+
+ /**
+ intended usage: When one language truly requires another
+
+ Unlike `getLanguage`, this will throw when the requested language
+ is not available.
+
+ @param {string} name - name of the language to fetch/require
+ @returns {Language | never}
+ */
+ function requireLanguage(name) {
+ deprecated("10.4.0", "requireLanguage will be removed entirely in v11.");
+ deprecated("10.4.0", "Please see https://github.com/highlightjs/highlight.js/pull/2844");
+
+ const lang = getLanguage(name);
+ if (lang) { return lang; }
+
+ const err = new Error('The \'{}\' language is required, but not loaded.'.replace('{}', name));
+ throw err;
+ }
+
+ /**
+ * @param {string} name - name of the language to retrieve
+ * @returns {Language | undefined}
+ */
+ function getLanguage(name) {
+ name = (name || '').toLowerCase();
+ return languages[name] || languages[aliases[name]];
+ }
+
+ /**
+ *
+ * @param {string|string[]} aliasList - single alias or list of aliases
+ * @param {{languageName: string}} opts
+ */
+ function registerAliases(aliasList, { languageName }) {
+ if (typeof aliasList === 'string') {
+ aliasList = [aliasList];
+ }
+ aliasList.forEach(alias => { aliases[alias.toLowerCase()] = languageName; });
+ }
+
+ /**
+ * Determines if a given language has auto-detection enabled
+ * @param {string} name - name of the language
+ */
+ function autoDetection(name) {
+ const lang = getLanguage(name);
+ return lang && !lang.disableAutodetect;
+ }
+
+ /**
+ * Upgrades the old highlightBlock plugins to the new
+ * highlightElement API
+ * @param {HLJSPlugin} plugin
+ */
+ function upgradePluginAPI(plugin) {
+ // TODO: remove with v12
+ if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+ plugin["before:highlightElement"] = (data) => {
+ plugin["before:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+ plugin["after:highlightElement"] = (data) => {
+ plugin["after:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function addPlugin(plugin) {
+ upgradePluginAPI(plugin);
+ plugins.push(plugin);
+ }
+
+ /**
+ *
+ * @param {PluginEvent} event
+ * @param {any} args
+ */
+ function fire(event, args) {
+ const cb = event;
+ plugins.forEach(function(plugin) {
+ if (plugin[cb]) {
+ plugin[cb](args);
+ }
+ });
+ }
+
+ /**
+ Note: fixMarkup is deprecated and will be removed entirely in v11
+
+ @param {string} arg
+ @returns {string}
+ */
+ function deprecateFixMarkup(arg) {
+ deprecated("10.2.0", "fixMarkup will be removed entirely in v11.0");
+ deprecated("10.2.0", "Please see https://github.com/highlightjs/highlight.js/issues/2534");
+
+ return fixMarkup(arg);
+ }
+
+ /**
+ *
+ * @param {HighlightedHTMLElement} el
+ */
+ function deprecateHighlightBlock(el) {
+ deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+ deprecated("10.7.0", "Please use highlightElement now.");
+
+ return highlightElement(el);
+ }
+
+ /* Interface definition */
+ Object.assign(hljs, {
+ highlight,
+ highlightAuto,
+ highlightAll,
+ fixMarkup: deprecateFixMarkup,
+ highlightElement,
+ // TODO: Remove with v12 API
+ highlightBlock: deprecateHighlightBlock,
+ configure,
+ initHighlighting,
+ initHighlightingOnLoad,
+ registerLanguage,
+ unregisterLanguage,
+ listLanguages,
+ getLanguage,
+ registerAliases,
+ requireLanguage,
+ autoDetection,
+ inherit: inherit$1,
+ addPlugin,
+ // plugins for frameworks
+ vuePlugin: BuildVuePlugin(hljs).VuePlugin
+ });
+
+ hljs.debugMode = function() { SAFE_MODE = false; };
+ hljs.safeMode = function() { SAFE_MODE = true; };
+ hljs.versionString = version;
+
+ for (const key in MODES) {
+ // @ts-ignore
+ if (typeof MODES[key] === "object") {
+ // @ts-ignore
+ deepFreezeEs6(MODES[key]);
+ }
+ }
+
+ // merge all the modes/regexs into our main object
+ Object.assign(hljs, MODES);
+
+ // built-in plugins, likely to be moved out of core in the future
+ hljs.addPlugin(brPlugin); // slated to be removed in v11
+ hljs.addPlugin(mergeHTMLPlugin);
+ hljs.addPlugin(tabReplacePlugin);
+ return hljs;
+ };
+
+ // export an "instance" of the highlighter
+ var highlight = HLJS({});
+
+ var core = highlight;
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source$1(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead$1(re) {
+ return concat$1('(?=', re, ')');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat$1(...args) {
+ const joined = args.map((x) => source$1(x)).join("");
+ return joined;
+ }
+
+ /*
+ Language: Python
+ Description: Python is an interpreted, object-oriented, high-level programming language with dynamic semantics.
+ Website: https://www.python.org
+ Category: common
+ */
+
+ function python(hljs) {
+ const RESERVED_WORDS = [
+ 'and',
+ 'as',
+ 'assert',
+ 'async',
+ 'await',
+ 'break',
+ 'class',
+ 'continue',
+ 'def',
+ 'del',
+ 'elif',
+ 'else',
+ 'except',
+ 'finally',
+ 'for',
+ 'from',
+ 'global',
+ 'if',
+ 'import',
+ 'in',
+ 'is',
+ 'lambda',
+ 'nonlocal|10',
+ 'not',
+ 'or',
+ 'pass',
+ 'raise',
+ 'return',
+ 'try',
+ 'while',
+ 'with',
+ 'yield'
+ ];
+
+ const BUILT_INS = [
+ '__import__',
+ 'abs',
+ 'all',
+ 'any',
+ 'ascii',
+ 'bin',
+ 'bool',
+ 'breakpoint',
+ 'bytearray',
+ 'bytes',
+ 'callable',
+ 'chr',
+ 'classmethod',
+ 'compile',
+ 'complex',
+ 'delattr',
+ 'dict',
+ 'dir',
+ 'divmod',
+ 'enumerate',
+ 'eval',
+ 'exec',
+ 'filter',
+ 'float',
+ 'format',
+ 'frozenset',
+ 'getattr',
+ 'globals',
+ 'hasattr',
+ 'hash',
+ 'help',
+ 'hex',
+ 'id',
+ 'input',
+ 'int',
+ 'isinstance',
+ 'issubclass',
+ 'iter',
+ 'len',
+ 'list',
+ 'locals',
+ 'map',
+ 'max',
+ 'memoryview',
+ 'min',
+ 'next',
+ 'object',
+ 'oct',
+ 'open',
+ 'ord',
+ 'pow',
+ 'print',
+ 'property',
+ 'range',
+ 'repr',
+ 'reversed',
+ 'round',
+ 'set',
+ 'setattr',
+ 'slice',
+ 'sorted',
+ 'staticmethod',
+ 'str',
+ 'sum',
+ 'super',
+ 'tuple',
+ 'type',
+ 'vars',
+ 'zip'
+ ];
+
+ const LITERALS = [
+ '__debug__',
+ 'Ellipsis',
+ 'False',
+ 'None',
+ 'NotImplemented',
+ 'True'
+ ];
+
+ // https://docs.python.org/3/library/typing.html
+ // TODO: Could these be supplemented by a CamelCase matcher in certain
+ // contexts, leaving these remaining only for relevance hinting?
+ const TYPES = [
+ "Any",
+ "Callable",
+ "Coroutine",
+ "Dict",
+ "List",
+ "Literal",
+ "Generic",
+ "Optional",
+ "Sequence",
+ "Set",
+ "Tuple",
+ "Type",
+ "Union"
+ ];
+
+ const KEYWORDS = {
+ $pattern: /[A-Za-z]\w+|__\w+__/,
+ keyword: RESERVED_WORDS,
+ built_in: BUILT_INS,
+ literal: LITERALS,
+ type: TYPES
+ };
+
+ const PROMPT = {
+ className: 'meta',
+ begin: /^(>>>|\.\.\.) /
+ };
+
+ const SUBST = {
+ className: 'subst',
+ begin: /\{/,
+ end: /\}/,
+ keywords: KEYWORDS,
+ illegal: /#/
+ };
+
+ const LITERAL_BRACKET = {
+ begin: /\{\{/,
+ relevance: 0
+ };
+
+ const STRING = {
+ className: 'string',
+ contains: [ hljs.BACKSLASH_ESCAPE ],
+ variants: [
+ {
+ begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
+ end: /'''/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ PROMPT
+ ],
+ relevance: 10
+ },
+ {
+ begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
+ end: /"""/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ PROMPT
+ ],
+ relevance: 10
+ },
+ {
+ begin: /([fF][rR]|[rR][fF]|[fF])'''/,
+ end: /'''/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ PROMPT,
+ LITERAL_BRACKET,
+ SUBST
+ ]
+ },
+ {
+ begin: /([fF][rR]|[rR][fF]|[fF])"""/,
+ end: /"""/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ PROMPT,
+ LITERAL_BRACKET,
+ SUBST
+ ]
+ },
+ {
+ begin: /([uU]|[rR])'/,
+ end: /'/,
+ relevance: 10
+ },
+ {
+ begin: /([uU]|[rR])"/,
+ end: /"/,
+ relevance: 10
+ },
+ {
+ begin: /([bB]|[bB][rR]|[rR][bB])'/,
+ end: /'/
+ },
+ {
+ begin: /([bB]|[bB][rR]|[rR][bB])"/,
+ end: /"/
+ },
+ {
+ begin: /([fF][rR]|[rR][fF]|[fF])'/,
+ end: /'/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ LITERAL_BRACKET,
+ SUBST
+ ]
+ },
+ {
+ begin: /([fF][rR]|[rR][fF]|[fF])"/,
+ end: /"/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ LITERAL_BRACKET,
+ SUBST
+ ]
+ },
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE
+ ]
+ };
+
+ // https://docs.python.org/3.9/reference/lexical_analysis.html#numeric-literals
+ const digitpart = '[0-9](_?[0-9])*';
+ const pointfloat = `(\\b(${digitpart}))?\\.(${digitpart})|\\b(${digitpart})\\.`;
+ const NUMBER = {
+ className: 'number',
+ relevance: 0,
+ variants: [
+ // exponentfloat, pointfloat
+ // https://docs.python.org/3.9/reference/lexical_analysis.html#floating-point-literals
+ // optionally imaginary
+ // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+ // Note: no leading \b because floats can start with a decimal point
+ // and we don't want to mishandle e.g. `fn(.5)`,
+ // no trailing \b for pointfloat because it can end with a decimal point
+ // and we don't want to mishandle e.g. `0..hex()`; this should be safe
+ // because both MUST contain a decimal point and so cannot be confused with
+ // the interior part of an identifier
+ {
+ begin: `(\\b(${digitpart})|(${pointfloat}))[eE][+-]?(${digitpart})[jJ]?\\b`
+ },
+ {
+ begin: `(${pointfloat})[jJ]?`
+ },
+
+ // decinteger, bininteger, octinteger, hexinteger
+ // https://docs.python.org/3.9/reference/lexical_analysis.html#integer-literals
+ // optionally "long" in Python 2
+ // https://docs.python.org/2.7/reference/lexical_analysis.html#integer-and-long-integer-literals
+ // decinteger is optionally imaginary
+ // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+ {
+ begin: '\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?\\b'
+ },
+ {
+ begin: '\\b0[bB](_?[01])+[lL]?\\b'
+ },
+ {
+ begin: '\\b0[oO](_?[0-7])+[lL]?\\b'
+ },
+ {
+ begin: '\\b0[xX](_?[0-9a-fA-F])+[lL]?\\b'
+ },
+
+ // imagnumber (digitpart-based)
+ // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+ {
+ begin: `\\b(${digitpart})[jJ]\\b`
+ }
+ ]
+ };
+ const COMMENT_TYPE = {
+ className: "comment",
+ begin: lookahead$1(/# type:/),
+ end: /$/,
+ keywords: KEYWORDS,
+ contains: [
+ { // prevent keywords from coloring `type`
+ begin: /# type:/
+ },
+ // comment within a datatype comment includes no keywords
+ {
+ begin: /#/,
+ end: /\b\B/,
+ endsWithParent: true
+ }
+ ]
+ };
+ const PARAMS = {
+ className: 'params',
+ variants: [
+ // Exclude params in functions without params
+ {
+ className: "",
+ begin: /\(\s*\)/,
+ skip: true
+ },
+ {
+ begin: /\(/,
+ end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS,
+ contains: [
+ 'self',
+ PROMPT,
+ NUMBER,
+ STRING,
+ hljs.HASH_COMMENT_MODE
+ ]
+ }
+ ]
+ };
+ SUBST.contains = [
+ STRING,
+ NUMBER,
+ PROMPT
+ ];
+
+ return {
+ name: 'Python',
+ aliases: [
+ 'py',
+ 'gyp',
+ 'ipython'
+ ],
+ keywords: KEYWORDS,
+ illegal: /(<\/|->|\?)|=>/,
+ contains: [
+ PROMPT,
+ NUMBER,
+ {
+ // very common convention
+ begin: /\bself\b/
+ },
+ {
+ // eat "if" prior to string so that it won't accidentally be
+ // labeled as an f-string
+ beginKeywords: "if",
+ relevance: 0
+ },
+ STRING,
+ COMMENT_TYPE,
+ hljs.HASH_COMMENT_MODE,
+ {
+ variants: [
+ {
+ className: 'function',
+ beginKeywords: 'def'
+ },
+ {
+ className: 'class',
+ beginKeywords: 'class'
+ }
+ ],
+ end: /:/,
+ illegal: /[${=;\n,]/,
+ contains: [
+ hljs.UNDERSCORE_TITLE_MODE,
+ PARAMS,
+ {
+ begin: /->/,
+ endsWithParent: true,
+ keywords: KEYWORDS
+ }
+ ]
+ },
+ {
+ className: 'meta',
+ begin: /^[\t ]*@/,
+ end: /(?=#)|$/,
+ contains: [
+ NUMBER,
+ PARAMS,
+ STRING
+ ]
+ }
+ ]
+ };
+ }
+
+ var python_1 = python;
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead(re) {
+ return concat('(?=', re, ')');
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function optional(re) {
+ return concat('(', re, ')?');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+ }
+
+ /**
+ * Any of the passed expresssions may match
+ *
+ * Creates a huge this | this | that | that match
+ * @param {(RegExp | string)[] } args
+ * @returns {string}
+ */
+ function either(...args) {
+ const joined = '(' + args.map((x) => source(x)).join("|") + ")";
+ return joined;
+ }
+
+ /*
+ Language: HTML, XML
+ Website: https://www.w3.org/XML/
+ Category: common
+ Audit: 2020
+ */
+
+ /** @type LanguageFn */
+ function xml(hljs) {
+ // Element names can contain letters, digits, hyphens, underscores, and periods
+ const TAG_NAME_RE = concat(/[A-Z_]/, optional(/[A-Z0-9_.-]*:/), /[A-Z0-9_.-]*/);
+ const XML_IDENT_RE = /[A-Za-z0-9._:-]+/;
+ const XML_ENTITIES = {
+ className: 'symbol',
+ begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
+ };
+ const XML_META_KEYWORDS = {
+ begin: /\s/,
+ contains: [
+ {
+ className: 'meta-keyword',
+ begin: /#?[a-z_][a-z1-9_-]+/,
+ illegal: /\n/
+ }
+ ]
+ };
+ const XML_META_PAR_KEYWORDS = hljs.inherit(XML_META_KEYWORDS, {
+ begin: /\(/,
+ end: /\)/
+ });
+ const APOS_META_STRING_MODE = hljs.inherit(hljs.APOS_STRING_MODE, {
+ className: 'meta-string'
+ });
+ const QUOTE_META_STRING_MODE = hljs.inherit(hljs.QUOTE_STRING_MODE, {
+ className: 'meta-string'
+ });
+ const TAG_INTERNALS = {
+ endsWithParent: true,
+ illegal: /`]+/
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ };
+ return {
+ name: 'HTML, XML',
+ aliases: [
+ 'html',
+ 'xhtml',
+ 'rss',
+ 'atom',
+ 'xjb',
+ 'xsd',
+ 'xsl',
+ 'plist',
+ 'wsf',
+ 'svg'
+ ],
+ case_insensitive: true,
+ contains: [
+ {
+ className: 'meta',
+ begin: //,
+ relevance: 10,
+ contains: [
+ XML_META_KEYWORDS,
+ QUOTE_META_STRING_MODE,
+ APOS_META_STRING_MODE,
+ XML_META_PAR_KEYWORDS,
+ {
+ begin: /\[/,
+ end: /\]/,
+ contains: [
+ {
+ className: 'meta',
+ begin: //,
+ contains: [
+ XML_META_KEYWORDS,
+ XML_META_PAR_KEYWORDS,
+ QUOTE_META_STRING_MODE,
+ APOS_META_STRING_MODE
+ ]
+ }
+ ]
+ }
+ ]
+ },
+ hljs.COMMENT(
+ //,
+ {
+ relevance: 10
+ }
+ ),
+ {
+ begin: //,
+ relevance: 10
+ },
+ XML_ENTITIES,
+ {
+ className: 'meta',
+ begin: /<\?xml/,
+ end: /\?>/,
+ relevance: 10
+ },
+ {
+ className: 'tag',
+ /*
+ The lookahead pattern (?=...) ensures that 'begin' only matches
+ ')/,
+ end: />/,
+ keywords: {
+ name: 'style'
+ },
+ contains: [ TAG_INTERNALS ],
+ starts: {
+ end: /<\/style>/,
+ returnEnd: true,
+ subLanguage: [
+ 'css',
+ 'xml'
+ ]
+ }
+ },
+ {
+ className: 'tag',
+ // See the comment in the