{datum.text}
- {:else} -{datum}
- {/if} - 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;
+
+ var hljs = /*@__PURE__*/getDefaultExportFromCjs(core);
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source$4(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat$4(...args) {
+ const joined = args.map((x) => source$4(x)).join("");
+ return joined;
+ }
+
+ /*
+ Language: Bash
+ Author: vah
+ Contributrors: Benjamin Pannell
+ Website: https://www.gnu.org/software/bash/
+ Category: common
+ */
+
+ /** @type LanguageFn */
+ function bash(hljs) {
+ const VAR = {};
+ const BRACED_VAR = {
+ begin: /\$\{/,
+ end:/\}/,
+ contains: [
+ "self",
+ {
+ begin: /:-/,
+ contains: [ VAR ]
+ } // default values
+ ]
+ };
+ Object.assign(VAR,{
+ className: 'variable',
+ variants: [
+ {begin: concat$4(/\$[\w\d#@][\w\d_]*/,
+ // negative look-ahead tries to avoid matching patterns that are not
+ // Perl at all like $ident$, @ident@, etc.
+ `(?![\\w\\d])(?![$])`) },
+ BRACED_VAR
+ ]
+ });
+
+ const SUBST = {
+ className: 'subst',
+ begin: /\$\(/, end: /\)/,
+ contains: [hljs.BACKSLASH_ESCAPE]
+ };
+ const HERE_DOC = {
+ begin: /<<-?\s*(?=\w+)/,
+ starts: {
+ contains: [
+ hljs.END_SAME_AS_BEGIN({
+ begin: /(\w+)/,
+ end: /(\w+)/,
+ className: 'string'
+ })
+ ]
+ }
+ };
+ const QUOTE_STRING = {
+ className: 'string',
+ begin: /"/, end: /"/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ VAR,
+ SUBST
+ ]
+ };
+ SUBST.contains.push(QUOTE_STRING);
+ const ESCAPED_QUOTE = {
+ className: '',
+ begin: /\\"/
+
+ };
+ const APOS_STRING = {
+ className: 'string',
+ begin: /'/, end: /'/
+ };
+ const ARITHMETIC = {
+ begin: /\$\(\(/,
+ end: /\)\)/,
+ contains: [
+ { begin: /\d+#[0-9a-f]+/, className: "number" },
+ hljs.NUMBER_MODE,
+ VAR
+ ]
+ };
+ const SH_LIKE_SHELLS = [
+ "fish",
+ "bash",
+ "zsh",
+ "sh",
+ "csh",
+ "ksh",
+ "tcsh",
+ "dash",
+ "scsh",
+ ];
+ const KNOWN_SHEBANG = hljs.SHEBANG({
+ binary: `(${SH_LIKE_SHELLS.join("|")})`,
+ relevance: 10
+ });
+ const FUNCTION = {
+ className: 'function',
+ begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/,
+ returnBegin: true,
+ contains: [hljs.inherit(hljs.TITLE_MODE, {begin: /\w[\w\d_]*/})],
+ relevance: 0
+ };
+
+ return {
+ name: 'Bash',
+ aliases: ['sh', 'zsh'],
+ keywords: {
+ $pattern: /\b[a-z._-]+\b/,
+ keyword:
+ 'if then else elif fi for while in do done case esac function',
+ literal:
+ 'true false',
+ built_in:
+ // Shell built-ins
+ // http://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+ 'break cd continue eval exec exit export getopts hash pwd readonly return shift test times ' +
+ 'trap umask unset ' +
+ // Bash built-ins
+ 'alias bind builtin caller command declare echo enable help let local logout mapfile printf ' +
+ 'read readarray source type typeset ulimit unalias ' +
+ // Shell modifiers
+ 'set shopt ' +
+ // Zsh built-ins
+ 'autoload bg bindkey bye cap chdir clone comparguments compcall compctl compdescribe compfiles ' +
+ 'compgroups compquote comptags comptry compvalues dirs disable disown echotc echoti emulate ' +
+ 'fc fg float functions getcap getln history integer jobs kill limit log noglob popd print ' +
+ 'pushd pushln rehash sched setcap setopt stat suspend ttyctl unfunction unhash unlimit ' +
+ 'unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof ' +
+ 'zpty zregexparse zsocket zstyle ztcp'
+ },
+ contains: [
+ KNOWN_SHEBANG, // to catch known shells and boost relevancy
+ hljs.SHEBANG(), // to catch unknown shells but still highlight the shebang
+ FUNCTION,
+ ARITHMETIC,
+ hljs.HASH_COMMENT_MODE,
+ HERE_DOC,
+ QUOTE_STRING,
+ ESCAPED_QUOTE,
+ APOS_STRING,
+ VAR
+ ]
+ };
+ }
+
+ var bash_1 = bash;
+
+ var bash$1 = /*@__PURE__*/getDefaultExportFromCjs(bash_1);
+
+ /*
+ Language: Batch file (DOS)
+ Author: Alexander Makarov
+ Contributors: Anton Kochkov
+ Website: https://en.wikipedia.org/wiki/Batch_file
+ */
+
+ /** @type LanguageFn */
+ function dos(hljs) {
+ const COMMENT = hljs.COMMENT(
+ /^\s*@?rem\b/, /$/,
+ {
+ relevance: 10
+ }
+ );
+ const LABEL = {
+ className: 'symbol',
+ begin: '^\\s*[A-Za-z._?][A-Za-z0-9_$#@~.?]*(:|\\s+label)',
+ relevance: 0
+ };
+ return {
+ name: 'Batch file (DOS)',
+ aliases: [
+ 'bat',
+ 'cmd'
+ ],
+ case_insensitive: true,
+ illegal: /\/\*/,
+ keywords: {
+ keyword:
+ 'if else goto for in do call exit not exist errorlevel defined ' +
+ 'equ neq lss leq gtr geq',
+ built_in:
+ 'prn nul lpt3 lpt2 lpt1 con com4 com3 com2 com1 aux ' +
+ 'shift cd dir echo setlocal endlocal set pause copy ' +
+ 'append assoc at attrib break cacls cd chcp chdir chkdsk chkntfs cls cmd color ' +
+ 'comp compact convert date dir diskcomp diskcopy doskey erase fs ' +
+ 'find findstr format ftype graftabl help keyb label md mkdir mode more move path ' +
+ 'pause print popd pushd promt rd recover rem rename replace restore rmdir shift ' +
+ 'sort start subst time title tree type ver verify vol ' +
+ // winutils
+ 'ping net ipconfig taskkill xcopy ren del'
+ },
+ contains: [
+ {
+ className: 'variable',
+ begin: /%%[^ ]|%[^ ]+?%|![^ ]+?!/
+ },
+ {
+ className: 'function',
+ begin: LABEL.begin,
+ end: 'goto:eof',
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, {
+ begin: '([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*'
+ }),
+ COMMENT
+ ]
+ },
+ {
+ className: 'number',
+ begin: '\\b\\d+',
+ relevance: 0
+ },
+ COMMENT
+ ]
+ };
+ }
+
+ var dos_1 = dos;
+
+ var batch = /*@__PURE__*/getDefaultExportFromCjs(dos_1);
+
+ // https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-3.10
+ var decimalDigits = '[0-9](_*[0-9])*';
+ var frac = `\\.(${decimalDigits})`;
+ var hexDigits = '[0-9a-fA-F](_*[0-9a-fA-F])*';
+ var NUMERIC = {
+ className: 'number',
+ variants: [
+ // DecimalFloatingPointLiteral
+ // including ExponentPart
+ { begin: `(\\b(${decimalDigits})((${frac})|\\.)?|(${frac}))` +
+ `[eE][+-]?(${decimalDigits})[fFdD]?\\b` },
+ // excluding ExponentPart
+ { begin: `\\b(${decimalDigits})((${frac})[fFdD]?\\b|\\.([fFdD]\\b)?)` },
+ { begin: `(${frac})[fFdD]?\\b` },
+ { begin: `\\b(${decimalDigits})[fFdD]\\b` },
+
+ // HexadecimalFloatingPointLiteral
+ { begin: `\\b0[xX]((${hexDigits})\\.?|(${hexDigits})?\\.(${hexDigits}))` +
+ `[pP][+-]?(${decimalDigits})[fFdD]?\\b` },
+
+ // DecimalIntegerLiteral
+ { begin: '\\b(0|[1-9](_*[0-9])*)[lL]?\\b' },
+
+ // HexIntegerLiteral
+ { begin: `\\b0[xX](${hexDigits})[lL]?\\b` },
+
+ // OctalIntegerLiteral
+ { begin: '\\b0(_*[0-7])*[lL]?\\b' },
+
+ // BinaryIntegerLiteral
+ { begin: '\\b0[bB][01](_*[01])*[lL]?\\b' },
+ ],
+ relevance: 0
+ };
+
+ /*
+ Language: Java
+ Author: Vsevolod Solovyov
+ Category: common, enterprise
+ Website: https://www.java.com/
+ */
+
+ function java(hljs) {
+ var JAVA_IDENT_RE = '[\u00C0-\u02B8a-zA-Z_$][\u00C0-\u02B8a-zA-Z_$0-9]*';
+ var GENERIC_IDENT_RE = JAVA_IDENT_RE + '(<' + JAVA_IDENT_RE + '(\\s*,\\s*' + JAVA_IDENT_RE + ')*>)?';
+ var KEYWORDS = 'false synchronized int abstract float private char boolean var static null if const ' +
+ 'for true while long strictfp finally protected import native final void ' +
+ 'enum else break transient catch instanceof byte super volatile case assert short ' +
+ 'package default double public try this switch continue throws protected public private ' +
+ 'module requires exports do';
+
+ var ANNOTATION = {
+ className: 'meta',
+ begin: '@' + JAVA_IDENT_RE,
+ contains: [
+ {
+ begin: /\(/,
+ end: /\)/,
+ contains: ["self"] // allow nested () inside our annotation
+ },
+ ]
+ };
+ const NUMBER = NUMERIC;
+
+ return {
+ name: 'Java',
+ aliases: ['jsp'],
+ keywords: KEYWORDS,
+ illegal: /<\/|#/,
+ contains: [
+ hljs.COMMENT(
+ '/\\*\\*',
+ '\\*/',
+ {
+ relevance: 0,
+ contains: [
+ {
+ // eat up @'s in emails to prevent them to be recognized as doctags
+ begin: /\w+@/, relevance: 0
+ },
+ {
+ className: 'doctag',
+ begin: '@[A-Za-z]+'
+ }
+ ]
+ }
+ ),
+ // relevance boost
+ {
+ begin: /import java\.[a-z]+\./,
+ keywords: "import",
+ relevance: 2
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ {
+ className: 'class',
+ beginKeywords: 'class interface enum', end: /[{;=]/, excludeEnd: true,
+ // TODO: can this be removed somehow?
+ // an extra boost because Java is more popular than other languages with
+ // this same syntax feature (this is just to preserve our tests passing
+ // for now)
+ relevance: 1,
+ keywords: 'class interface enum',
+ illegal: /[:"\[\]]/,
+ contains: [
+ { beginKeywords: 'extends implements' },
+ hljs.UNDERSCORE_TITLE_MODE
+ ]
+ },
+ {
+ // Expression keywords prevent 'keyword Name(...)' from being
+ // recognized as a function definition
+ beginKeywords: 'new throw return else',
+ relevance: 0
+ },
+ {
+ className: 'class',
+ begin: 'record\\s+' + hljs.UNDERSCORE_IDENT_RE + '\\s*\\(',
+ returnBegin: true,
+ excludeEnd: true,
+ end: /[{;=]/,
+ keywords: KEYWORDS,
+ contains: [
+ { beginKeywords: "record" },
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE + '\\s*\\(',
+ returnBegin: true,
+ relevance: 0,
+ contains: [hljs.UNDERSCORE_TITLE_MODE]
+ },
+ {
+ className: 'params',
+ begin: /\(/, end: /\)/,
+ keywords: KEYWORDS,
+ relevance: 0,
+ contains: [
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ {
+ className: 'function',
+ begin: '(' + GENERIC_IDENT_RE + '\\s+)+' + hljs.UNDERSCORE_IDENT_RE + '\\s*\\(', returnBegin: true, end: /[{;=]/,
+ excludeEnd: true,
+ keywords: KEYWORDS,
+ contains: [
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE + '\\s*\\(', returnBegin: true,
+ relevance: 0,
+ contains: [hljs.UNDERSCORE_TITLE_MODE]
+ },
+ {
+ className: 'params',
+ begin: /\(/, end: /\)/,
+ keywords: KEYWORDS,
+ relevance: 0,
+ contains: [
+ ANNOTATION,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ NUMBER,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ NUMBER,
+ ANNOTATION
+ ]
+ };
+ }
+
+ var java_1 = java;
+
+ var java$1 = /*@__PURE__*/getDefaultExportFromCjs(java_1);
+
+ const IDENT_RE$1 = '[A-Za-z$_][0-9A-Za-z$_]*';
+ const KEYWORDS$1 = [
+ "as", // for exports
+ "in",
+ "of",
+ "if",
+ "for",
+ "while",
+ "finally",
+ "var",
+ "new",
+ "function",
+ "do",
+ "return",
+ "void",
+ "else",
+ "break",
+ "catch",
+ "instanceof",
+ "with",
+ "throw",
+ "case",
+ "default",
+ "try",
+ "switch",
+ "continue",
+ "typeof",
+ "delete",
+ "let",
+ "yield",
+ "const",
+ "class",
+ // JS handles these with a special rule
+ // "get",
+ // "set",
+ "debugger",
+ "async",
+ "await",
+ "static",
+ "import",
+ "from",
+ "export",
+ "extends"
+ ];
+ const LITERALS$1 = [
+ "true",
+ "false",
+ "null",
+ "undefined",
+ "NaN",
+ "Infinity"
+ ];
+
+ const TYPES$1 = [
+ "Intl",
+ "DataView",
+ "Number",
+ "Math",
+ "Date",
+ "String",
+ "RegExp",
+ "Object",
+ "Function",
+ "Boolean",
+ "Error",
+ "Symbol",
+ "Set",
+ "Map",
+ "WeakSet",
+ "WeakMap",
+ "Proxy",
+ "Reflect",
+ "JSON",
+ "Promise",
+ "Float64Array",
+ "Int16Array",
+ "Int32Array",
+ "Int8Array",
+ "Uint16Array",
+ "Uint32Array",
+ "Float32Array",
+ "Array",
+ "Uint8Array",
+ "Uint8ClampedArray",
+ "ArrayBuffer",
+ "BigInt64Array",
+ "BigUint64Array",
+ "BigInt"
+ ];
+
+ const ERROR_TYPES$1 = [
+ "EvalError",
+ "InternalError",
+ "RangeError",
+ "ReferenceError",
+ "SyntaxError",
+ "TypeError",
+ "URIError"
+ ];
+
+ const BUILT_IN_GLOBALS$1 = [
+ "setInterval",
+ "setTimeout",
+ "clearInterval",
+ "clearTimeout",
+
+ "require",
+ "exports",
+
+ "eval",
+ "isFinite",
+ "isNaN",
+ "parseFloat",
+ "parseInt",
+ "decodeURI",
+ "decodeURIComponent",
+ "encodeURI",
+ "encodeURIComponent",
+ "escape",
+ "unescape"
+ ];
+
+ const BUILT_IN_VARIABLES$1 = [
+ "arguments",
+ "this",
+ "super",
+ "console",
+ "window",
+ "document",
+ "localStorage",
+ "module",
+ "global" // Node.js
+ ];
+
+ const BUILT_INS$1 = [].concat(
+ BUILT_IN_GLOBALS$1,
+ BUILT_IN_VARIABLES$1,
+ TYPES$1,
+ ERROR_TYPES$1
+ );
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source$3(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead$3(re) {
+ return concat$3('(?=', re, ')');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat$3(...args) {
+ const joined = args.map((x) => source$3(x)).join("");
+ return joined;
+ }
+
+ /*
+ Language: JavaScript
+ Description: JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions.
+ Category: common, scripting
+ Website: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+ */
+
+ /** @type LanguageFn */
+ function javascript$1(hljs) {
+ /**
+ * Takes a string like " {
+ const tag = "',
+ end: ''
+ };
+ const XML_TAG = {
+ begin: /<[A-Za-z0-9\\._:-]+/,
+ end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+ /**
+ * @param {RegExpMatchArray} match
+ * @param {CallbackResponse} response
+ */
+ isTrulyOpeningTag: (match, response) => {
+ const afterMatchIndex = match[0].length + match.index;
+ const nextChar = match.input[afterMatchIndex];
+ // nested type?
+ // HTML should not include another raw `<` inside a tag
+ // But a type might: `>`, etc.
+ if (nextChar === "<") {
+ response.ignoreMatch();
+ return;
+ }
+ //
+ // This is now either a tag or a type.
+ if (nextChar === ">") {
+ // if we cannot find a matching closing tag, then we
+ // will ignore it
+ if (!hasClosingTag(match, { after: afterMatchIndex })) {
+ response.ignoreMatch();
+ }
+ }
+ }
+ };
+ const KEYWORDS$1$1 = {
+ $pattern: IDENT_RE$1,
+ keyword: KEYWORDS$1,
+ literal: LITERALS$1,
+ built_in: BUILT_INS$1
+ };
+
+ // https://tc39.es/ecma262/#sec-literals-numeric-literals
+ const decimalDigits = '[0-9](_?[0-9])*';
+ const frac = `\\.(${decimalDigits})`;
+ // DecimalIntegerLiteral, including Annex B NonOctalDecimalIntegerLiteral
+ // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+ const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+ const NUMBER = {
+ className: 'number',
+ variants: [
+ // DecimalLiteral
+ { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` +
+ `[eE][+-]?(${decimalDigits})\\b` },
+ { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
+
+ // DecimalBigIntegerLiteral
+ { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
+
+ // NonDecimalIntegerLiteral
+ { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+ { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+ { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+
+ // LegacyOctalIntegerLiteral (does not include underscore separators)
+ // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+ { begin: "\\b0[0-7]+n?\\b" },
+ ],
+ relevance: 0
+ };
+
+ const SUBST = {
+ className: 'subst',
+ begin: '\\$\\{',
+ end: '\\}',
+ keywords: KEYWORDS$1$1,
+ contains: [] // defined later
+ };
+ const HTML_TEMPLATE = {
+ begin: 'html`',
+ end: '',
+ starts: {
+ end: '`',
+ returnEnd: false,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ],
+ subLanguage: 'xml'
+ }
+ };
+ const CSS_TEMPLATE = {
+ begin: 'css`',
+ end: '',
+ starts: {
+ end: '`',
+ returnEnd: false,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ],
+ subLanguage: 'css'
+ }
+ };
+ const TEMPLATE_STRING = {
+ className: 'string',
+ begin: '`',
+ end: '`',
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ]
+ };
+ const JSDOC_COMMENT = hljs.COMMENT(
+ /\/\*\*(?!\/)/,
+ '\\*/',
+ {
+ relevance: 0,
+ contains: [
+ {
+ className: 'doctag',
+ begin: '@[A-Za-z]+',
+ contains: [
+ {
+ className: 'type',
+ begin: '\\{',
+ end: '\\}',
+ relevance: 0
+ },
+ {
+ className: 'variable',
+ begin: IDENT_RE$1$1 + '(?=\\s*(-)|$)',
+ endsParent: true,
+ relevance: 0
+ },
+ // eat spaces (not newlines) so we can find
+ // types or variables
+ {
+ begin: /(?=[^\n])\s/,
+ relevance: 0
+ }
+ ]
+ }
+ ]
+ }
+ );
+ const COMMENT = {
+ className: "comment",
+ variants: [
+ JSDOC_COMMENT,
+ hljs.C_BLOCK_COMMENT_MODE,
+ hljs.C_LINE_COMMENT_MODE
+ ]
+ };
+ const SUBST_INTERNALS = [
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ HTML_TEMPLATE,
+ CSS_TEMPLATE,
+ TEMPLATE_STRING,
+ NUMBER,
+ hljs.REGEXP_MODE
+ ];
+ SUBST.contains = SUBST_INTERNALS
+ .concat({
+ // we need to pair up {} inside our subst to prevent
+ // it from ending too early by matching another }
+ begin: /\{/,
+ end: /\}/,
+ keywords: KEYWORDS$1$1,
+ contains: [
+ "self"
+ ].concat(SUBST_INTERNALS)
+ });
+ const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+ const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
+ // eat recursive parens in sub expressions
+ {
+ begin: /\(/,
+ end: /\)/,
+ keywords: KEYWORDS$1$1,
+ contains: ["self"].concat(SUBST_AND_COMMENTS)
+ }
+ ]);
+ const PARAMS = {
+ className: 'params',
+ begin: /\(/,
+ end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS$1$1,
+ contains: PARAMS_CONTAINS
+ };
+
+ return {
+ name: 'Javascript',
+ aliases: ['js', 'jsx', 'mjs', 'cjs'],
+ keywords: KEYWORDS$1$1,
+ // this will be extended by TypeScript
+ exports: { PARAMS_CONTAINS },
+ illegal: /#(?![$_A-z])/,
+ contains: [
+ hljs.SHEBANG({
+ label: "shebang",
+ binary: "node",
+ relevance: 5
+ }),
+ {
+ label: "use_strict",
+ className: 'meta',
+ relevance: 10,
+ begin: /^\s*['"]use (strict|asm)['"]/
+ },
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ HTML_TEMPLATE,
+ CSS_TEMPLATE,
+ TEMPLATE_STRING,
+ COMMENT,
+ NUMBER,
+ { // object attr container
+ begin: concat$3(/[{,\n]\s*/,
+ // we need to look ahead to make sure that we actually have an
+ // attribute coming up so we don't steal a comma from a potential
+ // "value" container
+ //
+ // NOTE: this might not work how you think. We don't actually always
+ // enter this mode and stay. Instead it might merely match `,
+ // ` and then immediately end after the , because it
+ // fails to find any actual attrs. But this still does the job because
+ // it prevents the value contain rule from grabbing this instead and
+ // prevening this rule from firing when we actually DO have keys.
+ lookahead$3(concat$3(
+ // we also need to allow for multiple possible comments inbetween
+ // the first key:value pairing
+ /(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/,
+ IDENT_RE$1$1 + '\\s*:'))),
+ relevance: 0,
+ contains: [
+ {
+ className: 'attr',
+ begin: IDENT_RE$1$1 + lookahead$3('\\s*:'),
+ relevance: 0
+ }
+ ]
+ },
+ { // "value" container
+ begin: '(' + hljs.RE_STARTERS_RE + '|\\b(case|return|throw)\\b)\\s*',
+ keywords: 'return throw case',
+ contains: [
+ COMMENT,
+ hljs.REGEXP_MODE,
+ {
+ className: 'function',
+ // we have to count the parens to make sure we actually have the
+ // correct bounding ( ) before the =>. There could be any number of
+ // sub-expressions inside also surrounded by parens.
+ begin: '(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*' +
+ '\\)[^()]*)*' +
+ '\\)[^()]*)*' +
+ '\\)|' + hljs.UNDERSCORE_IDENT_RE + ')\\s*=>',
+ returnBegin: true,
+ end: '\\s*=>',
+ contains: [
+ {
+ className: 'params',
+ variants: [
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE,
+ relevance: 0
+ },
+ {
+ className: null,
+ begin: /\(\s*\)/,
+ skip: true
+ },
+ {
+ begin: /\(/,
+ end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS$1$1,
+ contains: PARAMS_CONTAINS
+ }
+ ]
+ }
+ ]
+ },
+ { // could be a comma delimited list of params to a function call
+ begin: /,/, relevance: 0
+ },
+ {
+ className: '',
+ begin: /\s/,
+ end: /\s*/,
+ skip: true
+ },
+ { // JSX
+ variants: [
+ { begin: FRAGMENT.begin, end: FRAGMENT.end },
+ {
+ begin: XML_TAG.begin,
+ // we carefully check the opening tag to see if it truly
+ // is a tag and not a false positive
+ 'on:begin': XML_TAG.isTrulyOpeningTag,
+ end: XML_TAG.end
+ }
+ ],
+ subLanguage: 'xml',
+ contains: [
+ {
+ begin: XML_TAG.begin,
+ end: XML_TAG.end,
+ skip: true,
+ contains: ['self']
+ }
+ ]
+ }
+ ],
+ relevance: 0
+ },
+ {
+ className: 'function',
+ beginKeywords: 'function',
+ end: /[{;]/,
+ excludeEnd: true,
+ keywords: KEYWORDS$1$1,
+ contains: [
+ 'self',
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1$1 }),
+ PARAMS
+ ],
+ illegal: /%/
+ },
+ {
+ // prevent this from getting swallowed up by function
+ // since they appear "function like"
+ beginKeywords: "while if switch catch for"
+ },
+ {
+ className: 'function',
+ // we have to count the parens to make sure we actually have the correct
+ // bounding ( ). There could be any number of sub-expressions inside
+ // also surrounded by parens.
+ begin: hljs.UNDERSCORE_IDENT_RE +
+ '\\(' + // first parens
+ '[^()]*(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*' +
+ '\\)[^()]*)*' +
+ '\\)[^()]*)*' +
+ '\\)\\s*\\{', // end parens
+ returnBegin:true,
+ contains: [
+ PARAMS,
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1$1 }),
+ ]
+ },
+ // hack: prevents detection of keywords in some circumstances
+ // .keyword()
+ // $keyword = x
+ {
+ variants: [
+ { begin: '\\.' + IDENT_RE$1$1 },
+ { begin: '\\$' + IDENT_RE$1$1 }
+ ],
+ relevance: 0
+ },
+ { // ES6 class
+ className: 'class',
+ beginKeywords: 'class',
+ end: /[{;=]/,
+ excludeEnd: true,
+ illegal: /[:"[\]]/,
+ contains: [
+ { beginKeywords: 'extends' },
+ hljs.UNDERSCORE_TITLE_MODE
+ ]
+ },
+ {
+ begin: /\b(?=constructor)/,
+ end: /[{;]/,
+ excludeEnd: true,
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1$1 }),
+ 'self',
+ PARAMS
+ ]
+ },
+ {
+ begin: '(get|set)\\s+(?=' + IDENT_RE$1$1 + '\\()',
+ end: /\{/,
+ keywords: "get set",
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1$1 }),
+ { begin: /\(\)/ }, // eat to avoid empty params
+ PARAMS
+ ]
+ },
+ {
+ begin: /\$[(.]/ // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+ }
+ ]
+ };
+ }
+
+ var javascript_1 = javascript$1;
+
+ var javascript$2 = /*@__PURE__*/getDefaultExportFromCjs(javascript_1);
+
+ /*
+ Language: Plain text
+ Author: Egor Rogov (e.rogov@postgrespro.ru)
+ Description: Plain text without any highlighting.
+ Category: common
+ */
+
+ function plaintext(hljs) {
+ return {
+ name: 'Plain text',
+ aliases: [
+ 'text',
+ 'txt'
+ ],
+ disableAutodetect: true
+ };
+ }
+
+ var plaintext_1 = plaintext;
+
+ var plaintext$1 = /*@__PURE__*/getDefaultExportFromCjs(plaintext_1);
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source$2(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead$2(re) {
+ return concat$2('(?=', re, ')');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat$2(...args) {
+ const joined = args.map((x) => source$2(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$2(/# 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;
+
+ var python$1 = /*@__PURE__*/getDefaultExportFromCjs(python_1);
+
+ const IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+ const KEYWORDS = [
+ "as", // for exports
+ "in",
+ "of",
+ "if",
+ "for",
+ "while",
+ "finally",
+ "var",
+ "new",
+ "function",
+ "do",
+ "return",
+ "void",
+ "else",
+ "break",
+ "catch",
+ "instanceof",
+ "with",
+ "throw",
+ "case",
+ "default",
+ "try",
+ "switch",
+ "continue",
+ "typeof",
+ "delete",
+ "let",
+ "yield",
+ "const",
+ "class",
+ // JS handles these with a special rule
+ // "get",
+ // "set",
+ "debugger",
+ "async",
+ "await",
+ "static",
+ "import",
+ "from",
+ "export",
+ "extends"
+ ];
+ const LITERALS = [
+ "true",
+ "false",
+ "null",
+ "undefined",
+ "NaN",
+ "Infinity"
+ ];
+
+ const TYPES = [
+ "Intl",
+ "DataView",
+ "Number",
+ "Math",
+ "Date",
+ "String",
+ "RegExp",
+ "Object",
+ "Function",
+ "Boolean",
+ "Error",
+ "Symbol",
+ "Set",
+ "Map",
+ "WeakSet",
+ "WeakMap",
+ "Proxy",
+ "Reflect",
+ "JSON",
+ "Promise",
+ "Float64Array",
+ "Int16Array",
+ "Int32Array",
+ "Int8Array",
+ "Uint16Array",
+ "Uint32Array",
+ "Float32Array",
+ "Array",
+ "Uint8Array",
+ "Uint8ClampedArray",
+ "ArrayBuffer",
+ "BigInt64Array",
+ "BigUint64Array",
+ "BigInt"
+ ];
+
+ const ERROR_TYPES = [
+ "EvalError",
+ "InternalError",
+ "RangeError",
+ "ReferenceError",
+ "SyntaxError",
+ "TypeError",
+ "URIError"
+ ];
+
+ const BUILT_IN_GLOBALS = [
+ "setInterval",
+ "setTimeout",
+ "clearInterval",
+ "clearTimeout",
+
+ "require",
+ "exports",
+
+ "eval",
+ "isFinite",
+ "isNaN",
+ "parseFloat",
+ "parseInt",
+ "decodeURI",
+ "decodeURIComponent",
+ "encodeURI",
+ "encodeURIComponent",
+ "escape",
+ "unescape"
+ ];
+
+ const BUILT_IN_VARIABLES = [
+ "arguments",
+ "this",
+ "super",
+ "console",
+ "window",
+ "document",
+ "localStorage",
+ "module",
+ "global" // Node.js
+ ];
+
+ const BUILT_INS = [].concat(
+ BUILT_IN_GLOBALS,
+ BUILT_IN_VARIABLES,
+ TYPES,
+ ERROR_TYPES
+ );
+
+ /**
+ * @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: JavaScript
+ Description: JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions.
+ Category: common, scripting
+ Website: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+ */
+
+ /** @type LanguageFn */
+ function javascript(hljs) {
+ /**
+ * Takes a string like " {
+ const tag = "',
+ end: ''
+ };
+ const XML_TAG = {
+ begin: /<[A-Za-z0-9\\._:-]+/,
+ end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+ /**
+ * @param {RegExpMatchArray} match
+ * @param {CallbackResponse} response
+ */
+ isTrulyOpeningTag: (match, response) => {
+ const afterMatchIndex = match[0].length + match.index;
+ const nextChar = match.input[afterMatchIndex];
+ // nested type?
+ // HTML should not include another raw `<` inside a tag
+ // But a type might: `>`, etc.
+ if (nextChar === "<") {
+ response.ignoreMatch();
+ return;
+ }
+ //
+ // This is now either a tag or a type.
+ if (nextChar === ">") {
+ // if we cannot find a matching closing tag, then we
+ // will ignore it
+ if (!hasClosingTag(match, { after: afterMatchIndex })) {
+ response.ignoreMatch();
+ }
+ }
+ }
+ };
+ const KEYWORDS$1 = {
+ $pattern: IDENT_RE,
+ keyword: KEYWORDS,
+ literal: LITERALS,
+ built_in: BUILT_INS
+ };
+
+ // https://tc39.es/ecma262/#sec-literals-numeric-literals
+ const decimalDigits = '[0-9](_?[0-9])*';
+ const frac = `\\.(${decimalDigits})`;
+ // DecimalIntegerLiteral, including Annex B NonOctalDecimalIntegerLiteral
+ // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+ const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+ const NUMBER = {
+ className: 'number',
+ variants: [
+ // DecimalLiteral
+ { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` +
+ `[eE][+-]?(${decimalDigits})\\b` },
+ { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
+
+ // DecimalBigIntegerLiteral
+ { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
+
+ // NonDecimalIntegerLiteral
+ { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+ { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+ { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+
+ // LegacyOctalIntegerLiteral (does not include underscore separators)
+ // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+ { begin: "\\b0[0-7]+n?\\b" },
+ ],
+ relevance: 0
+ };
+
+ const SUBST = {
+ className: 'subst',
+ begin: '\\$\\{',
+ end: '\\}',
+ keywords: KEYWORDS$1,
+ contains: [] // defined later
+ };
+ const HTML_TEMPLATE = {
+ begin: 'html`',
+ end: '',
+ starts: {
+ end: '`',
+ returnEnd: false,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ],
+ subLanguage: 'xml'
+ }
+ };
+ const CSS_TEMPLATE = {
+ begin: 'css`',
+ end: '',
+ starts: {
+ end: '`',
+ returnEnd: false,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ],
+ subLanguage: 'css'
+ }
+ };
+ const TEMPLATE_STRING = {
+ className: 'string',
+ begin: '`',
+ end: '`',
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ]
+ };
+ const JSDOC_COMMENT = hljs.COMMENT(
+ /\/\*\*(?!\/)/,
+ '\\*/',
+ {
+ relevance: 0,
+ contains: [
+ {
+ className: 'doctag',
+ begin: '@[A-Za-z]+',
+ contains: [
+ {
+ className: 'type',
+ begin: '\\{',
+ end: '\\}',
+ relevance: 0
+ },
+ {
+ className: 'variable',
+ begin: IDENT_RE$1 + '(?=\\s*(-)|$)',
+ endsParent: true,
+ relevance: 0
+ },
+ // eat spaces (not newlines) so we can find
+ // types or variables
+ {
+ begin: /(?=[^\n])\s/,
+ relevance: 0
+ }
+ ]
+ }
+ ]
+ }
+ );
+ const COMMENT = {
+ className: "comment",
+ variants: [
+ JSDOC_COMMENT,
+ hljs.C_BLOCK_COMMENT_MODE,
+ hljs.C_LINE_COMMENT_MODE
+ ]
+ };
+ const SUBST_INTERNALS = [
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ HTML_TEMPLATE,
+ CSS_TEMPLATE,
+ TEMPLATE_STRING,
+ NUMBER,
+ hljs.REGEXP_MODE
+ ];
+ SUBST.contains = SUBST_INTERNALS
+ .concat({
+ // we need to pair up {} inside our subst to prevent
+ // it from ending too early by matching another }
+ begin: /\{/,
+ end: /\}/,
+ keywords: KEYWORDS$1,
+ contains: [
+ "self"
+ ].concat(SUBST_INTERNALS)
+ });
+ const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+ const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
+ // eat recursive parens in sub expressions
+ {
+ begin: /\(/,
+ end: /\)/,
+ keywords: KEYWORDS$1,
+ contains: ["self"].concat(SUBST_AND_COMMENTS)
+ }
+ ]);
+ const PARAMS = {
+ className: 'params',
+ begin: /\(/,
+ end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS$1,
+ contains: PARAMS_CONTAINS
+ };
+
+ return {
+ name: 'Javascript',
+ aliases: ['js', 'jsx', 'mjs', 'cjs'],
+ keywords: KEYWORDS$1,
+ // this will be extended by TypeScript
+ exports: { PARAMS_CONTAINS },
+ illegal: /#(?![$_A-z])/,
+ contains: [
+ hljs.SHEBANG({
+ label: "shebang",
+ binary: "node",
+ relevance: 5
+ }),
+ {
+ label: "use_strict",
+ className: 'meta',
+ relevance: 10,
+ begin: /^\s*['"]use (strict|asm)['"]/
+ },
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ HTML_TEMPLATE,
+ CSS_TEMPLATE,
+ TEMPLATE_STRING,
+ COMMENT,
+ NUMBER,
+ { // object attr container
+ begin: concat$1(/[{,\n]\s*/,
+ // we need to look ahead to make sure that we actually have an
+ // attribute coming up so we don't steal a comma from a potential
+ // "value" container
+ //
+ // NOTE: this might not work how you think. We don't actually always
+ // enter this mode and stay. Instead it might merely match `,
+ // ` and then immediately end after the , because it
+ // fails to find any actual attrs. But this still does the job because
+ // it prevents the value contain rule from grabbing this instead and
+ // prevening this rule from firing when we actually DO have keys.
+ lookahead$1(concat$1(
+ // we also need to allow for multiple possible comments inbetween
+ // the first key:value pairing
+ /(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/,
+ IDENT_RE$1 + '\\s*:'))),
+ relevance: 0,
+ contains: [
+ {
+ className: 'attr',
+ begin: IDENT_RE$1 + lookahead$1('\\s*:'),
+ relevance: 0
+ }
+ ]
+ },
+ { // "value" container
+ begin: '(' + hljs.RE_STARTERS_RE + '|\\b(case|return|throw)\\b)\\s*',
+ keywords: 'return throw case',
+ contains: [
+ COMMENT,
+ hljs.REGEXP_MODE,
+ {
+ className: 'function',
+ // we have to count the parens to make sure we actually have the
+ // correct bounding ( ) before the =>. There could be any number of
+ // sub-expressions inside also surrounded by parens.
+ begin: '(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*' +
+ '\\)[^()]*)*' +
+ '\\)[^()]*)*' +
+ '\\)|' + hljs.UNDERSCORE_IDENT_RE + ')\\s*=>',
+ returnBegin: true,
+ end: '\\s*=>',
+ contains: [
+ {
+ className: 'params',
+ variants: [
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE,
+ relevance: 0
+ },
+ {
+ className: null,
+ begin: /\(\s*\)/,
+ skip: true
+ },
+ {
+ begin: /\(/,
+ end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS$1,
+ contains: PARAMS_CONTAINS
+ }
+ ]
+ }
+ ]
+ },
+ { // could be a comma delimited list of params to a function call
+ begin: /,/, relevance: 0
+ },
+ {
+ className: '',
+ begin: /\s/,
+ end: /\s*/,
+ skip: true
+ },
+ { // JSX
+ variants: [
+ { begin: FRAGMENT.begin, end: FRAGMENT.end },
+ {
+ begin: XML_TAG.begin,
+ // we carefully check the opening tag to see if it truly
+ // is a tag and not a false positive
+ 'on:begin': XML_TAG.isTrulyOpeningTag,
+ end: XML_TAG.end
+ }
+ ],
+ subLanguage: 'xml',
+ contains: [
+ {
+ begin: XML_TAG.begin,
+ end: XML_TAG.end,
+ skip: true,
+ contains: ['self']
+ }
+ ]
+ }
+ ],
+ relevance: 0
+ },
+ {
+ className: 'function',
+ beginKeywords: 'function',
+ end: /[{;]/,
+ excludeEnd: true,
+ keywords: KEYWORDS$1,
+ contains: [
+ 'self',
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ PARAMS
+ ],
+ illegal: /%/
+ },
+ {
+ // prevent this from getting swallowed up by function
+ // since they appear "function like"
+ beginKeywords: "while if switch catch for"
+ },
+ {
+ className: 'function',
+ // we have to count the parens to make sure we actually have the correct
+ // bounding ( ). There could be any number of sub-expressions inside
+ // also surrounded by parens.
+ begin: hljs.UNDERSCORE_IDENT_RE +
+ '\\(' + // first parens
+ '[^()]*(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*' +
+ '\\)[^()]*)*' +
+ '\\)[^()]*)*' +
+ '\\)\\s*\\{', // end parens
+ returnBegin:true,
+ contains: [
+ PARAMS,
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ ]
+ },
+ // hack: prevents detection of keywords in some circumstances
+ // .keyword()
+ // $keyword = x
+ {
+ variants: [
+ { begin: '\\.' + IDENT_RE$1 },
+ { begin: '\\$' + IDENT_RE$1 }
+ ],
+ relevance: 0
+ },
+ { // ES6 class
+ className: 'class',
+ beginKeywords: 'class',
+ end: /[{;=]/,
+ excludeEnd: true,
+ illegal: /[:"[\]]/,
+ contains: [
+ { beginKeywords: 'extends' },
+ hljs.UNDERSCORE_TITLE_MODE
+ ]
+ },
+ {
+ begin: /\b(?=constructor)/,
+ end: /[{;]/,
+ excludeEnd: true,
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ 'self',
+ PARAMS
+ ]
+ },
+ {
+ begin: '(get|set)\\s+(?=' + IDENT_RE$1 + '\\()',
+ end: /\{/,
+ keywords: "get set",
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ { begin: /\(\)/ }, // eat to avoid empty params
+ PARAMS
+ ]
+ },
+ {
+ begin: /\$[(.]/ // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+ }
+ ]
+ };
+ }
+
+ /*
+ Language: TypeScript
+ Author: Panu Horsmalahti
+ Contributors: Ike Ku
+ Description: TypeScript is a strict superset of JavaScript
+ Website: https://www.typescriptlang.org
+ Category: common, scripting
+ */
+
+ /** @type LanguageFn */
+ function typescript(hljs) {
+ const IDENT_RE$1 = IDENT_RE;
+ const NAMESPACE = {
+ beginKeywords: 'namespace', end: /\{/, excludeEnd: true
+ };
+ const INTERFACE = {
+ beginKeywords: 'interface', end: /\{/, excludeEnd: true,
+ keywords: 'interface extends'
+ };
+ const USE_STRICT = {
+ className: 'meta',
+ relevance: 10,
+ begin: /^\s*['"]use strict['"]/
+ };
+ const TYPES = [
+ "any",
+ "void",
+ "number",
+ "boolean",
+ "string",
+ "object",
+ "never",
+ "enum"
+ ];
+ const TS_SPECIFIC_KEYWORDS = [
+ "type",
+ "namespace",
+ "typedef",
+ "interface",
+ "public",
+ "private",
+ "protected",
+ "implements",
+ "declare",
+ "abstract",
+ "readonly"
+ ];
+ const KEYWORDS$1 = {
+ $pattern: IDENT_RE,
+ keyword: KEYWORDS.concat(TS_SPECIFIC_KEYWORDS),
+ literal: LITERALS,
+ built_in: BUILT_INS.concat(TYPES)
+ };
+ const DECORATOR = {
+ className: 'meta',
+ begin: '@' + IDENT_RE$1,
+ };
+
+ const swapMode = (mode, label, replacement) => {
+ const indx = mode.contains.findIndex(m => m.label === label);
+ if (indx === -1) { throw new Error("can not find mode to replace"); }
+ mode.contains.splice(indx, 1, replacement);
+ };
+
+ const tsLanguage = javascript(hljs);
+
+ // this should update anywhere keywords is used since
+ // it will be the same actual JS object
+ Object.assign(tsLanguage.keywords, KEYWORDS$1);
+
+ tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);
+ tsLanguage.contains = tsLanguage.contains.concat([
+ DECORATOR,
+ NAMESPACE,
+ INTERFACE,
+ ]);
+
+ // TS gets a simpler shebang rule than JS
+ swapMode(tsLanguage, "shebang", hljs.SHEBANG());
+ // JS use strict rule purposely excludes `asm` which makes no sense
+ swapMode(tsLanguage, "use_strict", USE_STRICT);
+
+ const functionDeclaration = tsLanguage.contains.find(m => m.className === "function");
+ functionDeclaration.relevance = 0; // () => {} is more typical in TypeScript
+
+ Object.assign(tsLanguage, {
+ name: 'TypeScript',
+ aliases: ['ts', 'tsx']
+ });
+
+ return tsLanguage;
+ }
+
+ var typescript_1 = typescript;
+
+ var typescript$1 = /*@__PURE__*/getDefaultExportFromCjs(typescript_1);
+
+ /**
+ * @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
diff --git a/src/components/Animated.svelte b/src/components/Animated.svelte
index 417878a..7c1878d 100644
--- a/src/components/Animated.svelte
+++ b/src/components/Animated.svelte
@@ -14,7 +14,7 @@
{#key update}
-
+
{datum.text}
- {:else}
- {datum}
- {/if}
-
+
+ {#if datum.html}
+ {@html datum.html}
+ {:else if datum.text}
+ {datum.text}
+ {:else}
+ {datum}
+ {/if}
+
-
-
- {/each}
-
+
+
+ {/each}
+
diff --git a/src/components/Hint.svelte b/src/components/Hint.svelte
index 94135de..e8f661f 100644
--- a/src/components/Hint.svelte
+++ b/src/components/Hint.svelte
@@ -5,7 +5,7 @@
{#if show}
-
+
💡 {@html hint}
{/if}
diff --git a/src/components/Icon.svelte b/src/components/Icon.svelte
deleted file mode 100644
index 203e20c..0000000
--- a/src/components/Icon.svelte
+++ /dev/null
@@ -1,38 +0,0 @@
-
-
-{@html html}
diff --git a/src/components/Loading.svelte b/src/components/Loading.svelte
index fbff122..882fa8c 100644
--- a/src/components/Loading.svelte
+++ b/src/components/Loading.svelte
@@ -1,38 +1,36 @@
{#key update}
- {#await wait(ms)}
-
- = {
+ let componentMap: Record> = {
Sequence: SequenceView,
MultipleChoice: ChoiceView,
SingleChoice: ChoiceView,
diff --git a/src/components/ResultsView.svelte b/src/components/ResultsView.svelte
index 9cc0838..78b0e31 100644
--- a/src/components/ResultsView.svelte
+++ b/src/components/ResultsView.svelte
@@ -1,88 +1,86 @@
{$_('resultsTitle')}
-
-
-
-
+
+
+
+
-
- {#each quiz.questions as question, i}
- -
-
- {emojis[+question.solved]}
- {@html question.text}
-
-
-
- {#each question.selected as selected}
- {#if question.answers[selected].comment !== ''}
- -
- {@html question.answers[selected]
- .html}:
- {@html question.answers[selected].comment}
-
- {/if}
- {/each}
-
-
- {/each}
-
-
+
+ {#each quiz.questions as question, i}
+ - quiz.jump(i)}>
+
+ {emojis[+question.solved]}
+ {@html question.text}
+
+
+
+ {#each question.selected as selected}
+ {#if question.answers[selected].comment !== ''}
+ -
+ {@html question.answers[selected].html}:
+ {@html question.answers[selected].comment}
+
+ {/if}
+ {/each}
+
+
+ {/each}
+
+
diff --git a/src/customizedMarked.ts b/src/customizedMarked.ts
index df57ec8..c6a3970 100644
--- a/src/customizedMarked.ts
+++ b/src/customizedMarked.ts
@@ -1,4 +1,4 @@
-import marked from 'marked';
+import { marked } from 'marked';
import { parse as parseYaml } from 'yaml';
// customize tokenizer to include yaml like header blocks
diff --git a/src/parser.ts b/src/parser.ts
index 4b81946..2667a4a 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -7,7 +7,7 @@ import {
SingleChoice,
Sequence,
Answer,
- QuestionType,
+ type QuestionType,
} from './quiz';
import { Config, mergeAttributes } from './config';
import marked from './customizedMarked';
diff --git a/src/quiz.ts b/src/quiz.ts
index 91b3b11..b79a39f 100644
--- a/src/quiz.ts
+++ b/src/quiz.ts
@@ -1,4 +1,4 @@
-import { writable, get, Writable } from 'svelte/store';
+import { writable, get, type Writable } from 'svelte/store';
import autoBind from 'auto-bind';
import type { Config } from './config.js';
diff --git a/tsconfig.json b/tsconfig.json
index 04a788c..1ca29fd 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,11 +1,20 @@
{
- "extends": "@tsconfig/svelte/tsconfig.json",
- "allowSyntheticDefaultImports": true,
- "compilerOptions": {
- "resolveJsonModule": true,
- "types": ["marked", "svelte"]
- },
-
- "include": ["src/**/*"],
- "exclude": ["node_modules/*", "__sapper__/*", "public/*", "docs/*"]
-}
+ "extends": "@tsconfig/svelte/tsconfig.json",
+ "allowSyntheticDefaultImports": true,
+ "compilerOptions": {
+ "resolveJsonModule": true,
+ "types": [
+ "marked",
+ "svelte"
+ ]
+ },
+ "include": [
+ "src/**/*"
+ ],
+ "exclude": [
+ "node_modules/*",
+ "__sapper__/*",
+ "public/*",
+ "docs/*"
+ ]
+}
\ No newline at end of file