' + (n ? i : O(i, true)) + `" + (n ? i : O(i, true)) + `+${this.parser.parse(e)}+`; + } + html({ text: e }) { + return e; + } + def(e) { + return ""; + } + heading({ tokens: e, depth: t }) { + return `
+`; + } + list(e) { + let { ordered: t, start: n } = e, r = ""; + for (let a = 0;a < e.items.length; a++) { + let o = e.items[a]; + r += this.listitem(o); + } + let i = t ? "ol" : "ul", s = t && n !== 1 ? ' start="' + n + '"' : ""; + return "<" + i + s + `> +` + r + " +`; + } + listitem(e) { + return `
${this.parser.parseInline(e)}
+`; + } + table(e) { + let t = "", n = ""; + for (let i = 0;i < e.header.length; i++) + n += this.tablecell(e.header[i]); + t += this.tablerow({ text: n }); + let r = ""; + for (let i = 0;i < e.rows.length; i++) { + let s = e.rows[i]; + n = ""; + for (let a = 0;a < s.length; a++) + n += this.tablecell(s[a]); + r += this.tablerow({ text: n }); + } + return r && (r = `${r}`), `${O(e, true)}`;
+ }
+ br(e) {
+ return ""; + } + del({ tokens: e }) { + return `
An error occurred:
" + O(n.message + "", true) + ""; + return t ? Promise.resolve(r) : r; + } + if (t) + return Promise.reject(n); + throw n; + }; + } + }; + var L = new B; + function g(u3, e) { + return L.parse(u3, e); + } + g.options = g.setOptions = function(u3) { + return L.setOptions(u3), g.defaults = L.defaults, G(g.defaults), g; + }; + g.getDefaults = M; + g.defaults = T; + g.use = function(...u3) { + return L.use(...u3), g.defaults = L.defaults, G(g.defaults), g; + }; + g.walkTokens = function(u3, e) { + return L.walkTokens(u3, e); + }; + g.parseInline = L.parseInline; + g.Parser = b; + g.parser = b.parse; + g.Renderer = y; + g.TextRenderer = $; + g.Lexer = x; + g.lexer = x.lex; + g.Tokenizer = w; + g.Hooks = P; + g.parse = g; + var Ut = g.options; + var Kt = g.setOptions; + var Wt = g.use; + var Xt = g.walkTokens; + var Jt = g.parseInline; + var Yt = b.parse; + var en = x.lex; + + // node_modules/highlight.js/es/core.js + var import_core = __toESM(require_core(), 1); + var core_default = import_core.default; + + // node_modules/highlight.js/es/languages/javascript.js + var IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*"; + var KEYWORDS = [ + "as", + "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", + "debugger", + "async", + "await", + "static", + "import", + "from", + "export", + "extends", + "using" + ]; + var LITERALS = [ + "true", + "false", + "null", + "undefined", + "NaN", + "Infinity" + ]; + var TYPES = [ + "Object", + "Function", + "Boolean", + "Symbol", + "Math", + "Date", + "Number", + "BigInt", + "String", + "RegExp", + "Array", + "Float32Array", + "Float64Array", + "Int8Array", + "Uint8Array", + "Uint8ClampedArray", + "Int16Array", + "Int32Array", + "Uint16Array", + "Uint32Array", + "BigInt64Array", + "BigUint64Array", + "Set", + "Map", + "WeakSet", + "WeakMap", + "ArrayBuffer", + "SharedArrayBuffer", + "Atomics", + "DataView", + "JSON", + "Promise", + "Generator", + "GeneratorFunction", + "AsyncFunction", + "Reflect", + "Proxy", + "Intl", + "WebAssembly" + ]; + var ERROR_TYPES = [ + "Error", + "EvalError", + "InternalError", + "RangeError", + "ReferenceError", + "SyntaxError", + "TypeError", + "URIError" + ]; + var BUILT_IN_GLOBALS = [ + "setInterval", + "setTimeout", + "clearInterval", + "clearTimeout", + "require", + "exports", + "eval", + "isFinite", + "isNaN", + "parseFloat", + "parseInt", + "decodeURI", + "decodeURIComponent", + "encodeURI", + "encodeURIComponent", + "escape", + "unescape" + ]; + var BUILT_IN_VARIABLES = [ + "arguments", + "this", + "super", + "console", + "window", + "document", + "localStorage", + "sessionStorage", + "module", + "global" + ]; + var BUILT_INS = [].concat(BUILT_IN_GLOBALS, TYPES, ERROR_TYPES); + function javascript(hljs) { + const regex = hljs.regex; + const hasClosingTag = (match, { after }) => { + const tag = "", + end: "" + }; + const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/; + const XML_TAG = { + begin: /<[A-Za-z0-9\\._:-]+/, + end: /\/[A-Za-z0-9\\._:-]+>|\/>/, + isTrulyOpeningTag: (match, response) => { + const afterMatchIndex = match[0].length + match.index; + const nextChar = match.input[afterMatchIndex]; + if (nextChar === "<" || nextChar === ",") { + response.ignoreMatch(); + return; + } + if (nextChar === ">") { + if (!hasClosingTag(match, { after: afterMatchIndex })) { + response.ignoreMatch(); + } + } + let m2; + const afterMatch = match.input.substring(afterMatchIndex); + if (m2 = afterMatch.match(/^\s*=/)) { + response.ignoreMatch(); + return; + } + if (m2 = afterMatch.match(/^\s+extends\s+/)) { + if (m2.index === 0) { + response.ignoreMatch(); + return; + } + } + } + }; + const KEYWORDS$1 = { + $pattern: IDENT_RE, + keyword: KEYWORDS, + literal: LITERALS, + built_in: BUILT_INS, + "variable.language": BUILT_IN_VARIABLES + }; + const decimalDigits = "[0-9](_?[0-9])*"; + const frac = `\\.(${decimalDigits})`; + const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`; + const NUMBER = { + className: "number", + variants: [ + { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` + `[eE][+-]?(${decimalDigits})\\b` }, + { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` }, + { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` }, + { 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" }, + { begin: "\\b0[0-7]+n?\\b" } + ], + relevance: 0 + }; + const SUBST = { + className: "subst", + begin: "\\$\\{", + end: "\\}", + keywords: KEYWORDS$1, + contains: [] + }; + 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 GRAPHQL_TEMPLATE = { + begin: ".?gql`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "graphql" + } + }; + const TEMPLATE_STRING = { + className: "string", + begin: "`", + end: "`", + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ] + }; + const JSDOC_COMMENT = hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", { + relevance: 0, + contains: [ + { + begin: "(?=@[A-Za-z]+)", + relevance: 0, + contains: [ + { + className: "doctag", + begin: "@[A-Za-z]+" + }, + { + className: "type", + begin: "\\{", + end: "\\}", + excludeEnd: true, + excludeBegin: true, + relevance: 0 + }, + { + className: "variable", + begin: IDENT_RE$1 + "(?=\\s*(-)|$)", + endsParent: true, + relevance: 0 + }, + { + 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, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + { match: /\$\d+/ }, + NUMBER + ]; + SUBST.contains = SUBST_INTERNALS.concat({ + 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([ + { + begin: /(\s*)\(/, + end: /\)/, + keywords: KEYWORDS$1, + contains: ["self"].concat(SUBST_AND_COMMENTS) + } + ]); + const PARAMS = { + className: "params", + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + }; + const CLASS_OR_EXTENDS = { + variants: [ + { + match: [ + /class/, + /\s+/, + IDENT_RE$1, + /\s+/, + /extends/, + /\s+/, + regex.concat(IDENT_RE$1, "(", regex.concat(/\./, IDENT_RE$1), ")*") + ], + scope: { + 1: "keyword", + 3: "title.class", + 5: "keyword", + 7: "title.class.inherited" + } + }, + { + match: [ + /class/, + /\s+/, + IDENT_RE$1 + ], + scope: { + 1: "keyword", + 3: "title.class" + } + } + ] + }; + const CLASS_REFERENCE = { + relevance: 0, + match: regex.either(/\bJSON/, /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/, /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/, /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/), + className: "title.class", + keywords: { + _: [ + ...TYPES, + ...ERROR_TYPES + ] + } + }; + const USE_STRICT = { + label: "use_strict", + className: "meta", + relevance: 10, + begin: /^\s*['"]use (strict|asm)['"]/ + }; + const FUNCTION_DEFINITION = { + variants: [ + { + match: [ + /function/, + /\s+/, + IDENT_RE$1, + /(?=\s*\()/ + ] + }, + { + match: [ + /function/, + /\s*(?=\()/ + ] + } + ], + className: { + 1: "keyword", + 3: "title.function" + }, + label: "func.def", + contains: [PARAMS], + illegal: /%/ + }; + const UPPER_CASE_CONSTANT = { + relevance: 0, + match: /\b[A-Z][A-Z_0-9]+\b/, + className: "variable.constant" + }; + function noneOf(list) { + return regex.concat("(?!", list.join("|"), ")"); + } + const FUNCTION_CALL = { + match: regex.concat(/\b/, noneOf([ + ...BUILT_IN_GLOBALS, + "super", + "import" + ].map((x2) => `${x2}\\s*\\(`)), IDENT_RE$1, regex.lookahead(/\s*\(/)), + className: "title.function", + relevance: 0 + }; + const PROPERTY_ACCESS = { + begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/))), + end: IDENT_RE$1, + excludeBegin: true, + keywords: "prototype", + className: "property", + relevance: 0 + }; + const GETTER_OR_SETTER = { + match: [ + /get|set/, + /\s+/, + IDENT_RE$1, + /(?=\()/ + ], + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + { + begin: /\(\)/ + }, + PARAMS + ] + }; + const FUNC_LEAD_IN_RE = "(\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>"; + const FUNCTION_VARIABLE = { + match: [ + /const|var|let/, + /\s+/, + IDENT_RE$1, + /\s*/, + /=\s*/, + /(async\s*)?/, + regex.lookahead(FUNC_LEAD_IN_RE) + ], + keywords: "async", + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + PARAMS + ] + }; + return { + name: "JavaScript", + aliases: ["js", "jsx", "mjs", "cjs"], + keywords: KEYWORDS$1, + exports: { PARAMS_CONTAINS, CLASS_REFERENCE }, + illegal: /#(?![$_A-z])/, + contains: [ + hljs.SHEBANG({ + label: "shebang", + binary: "node", + relevance: 5 + }), + USE_STRICT, + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE, + HTML_TEMPLATE, + CSS_TEMPLATE, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + COMMENT, + { match: /\$\d+/ }, + NUMBER, + CLASS_REFERENCE, + { + scope: "attr", + match: IDENT_RE$1 + regex.lookahead(":"), + relevance: 0 + }, + FUNCTION_VARIABLE, + { + begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*", + keywords: "return throw case", + relevance: 0, + contains: [ + COMMENT, + hljs.REGEXP_MODE, + { + className: "function", + begin: FUNC_LEAD_IN_RE, + returnBegin: true, + end: "\\s*=>", + contains: [ + { + className: "params", + variants: [ + { + begin: hljs.UNDERSCORE_IDENT_RE, + relevance: 0 + }, + { + className: null, + begin: /\(\s*\)/, + skip: true + }, + { + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + } + ] + } + ] + }, + { + begin: /,/, + relevance: 0 + }, + { + match: /\s+/, + relevance: 0 + }, + { + variants: [ + { begin: FRAGMENT.begin, end: FRAGMENT.end }, + { match: XML_SELF_CLOSING }, + { + begin: XML_TAG.begin, + "on:begin": XML_TAG.isTrulyOpeningTag, + end: XML_TAG.end + } + ], + subLanguage: "xml", + contains: [ + { + begin: XML_TAG.begin, + end: XML_TAG.end, + skip: true, + contains: ["self"] + } + ] + } + ] + }, + FUNCTION_DEFINITION, + { + beginKeywords: "while if switch catch for" + }, + { + begin: "\\b(?!function)" + hljs.UNDERSCORE_IDENT_RE + "\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)\\s*\\{", + returnBegin: true, + label: "func.def", + contains: [ + PARAMS, + hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" }) + ] + }, + { + match: /\.\.\./, + relevance: 0 + }, + PROPERTY_ACCESS, + { + match: "\\$" + IDENT_RE$1, + relevance: 0 + }, + { + match: [/\bconstructor(?=\s*\()/], + className: { 1: "title.function" }, + contains: [PARAMS] + }, + FUNCTION_CALL, + UPPER_CASE_CONSTANT, + CLASS_OR_EXTENDS, + GETTER_OR_SETTER, + { + match: /\$[(.]/ + } + ] + }; + } + + // node_modules/highlight.js/es/languages/python.js + function python(hljs) { + const regex = hljs.regex; + const IDENT_RE2 = /[\p{XID_Start}_]\p{XID_Continue}*/u; + const RESERVED_WORDS = [ + "and", + "as", + "assert", + "async", + "await", + "break", + "case", + "class", + "continue", + "def", + "del", + "elif", + "else", + "except", + "finally", + "for", + "from", + "global", + "if", + "import", + "in", + "is", + "lambda", + "match", + "nonlocal|10", + "not", + "or", + "pass", + "raise", + "return", + "try", + "while", + "with", + "yield" + ]; + const BUILT_INS2 = [ + "__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 LITERALS2 = [ + "__debug__", + "Ellipsis", + "False", + "None", + "NotImplemented", + "True" + ]; + const TYPES2 = [ + "Any", + "Callable", + "Coroutine", + "Dict", + "List", + "Literal", + "Generic", + "Optional", + "Sequence", + "Set", + "Tuple", + "Type", + "Union" + ]; + const KEYWORDS2 = { + $pattern: /[A-Za-z]\w+|__\w+__/, + keyword: RESERVED_WORDS, + built_in: BUILT_INS2, + literal: LITERALS2, + type: TYPES2 + }; + const PROMPT = { + className: "meta", + begin: /^(>>>|\.\.\.) / + }; + const SUBST = { + className: "subst", + begin: /\{/, + end: /\}/, + keywords: KEYWORDS2, + 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 + ] + }; + const digitpart = "[0-9](_?[0-9])*"; + const pointfloat = `(\\b(${digitpart}))?\\.(${digitpart})|\\b(${digitpart})\\.`; + const lookahead = `\\b|${RESERVED_WORDS.join("|")}`; + const NUMBER = { + className: "number", + relevance: 0, + variants: [ + { + begin: `(\\b(${digitpart})|(${pointfloat}))[eE][+-]?(${digitpart})[jJ]?(?=${lookahead})` + }, + { + begin: `(${pointfloat})[jJ]?` + }, + { + begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${lookahead})` + }, + { + begin: `\\b0[bB](_?[01])+[lL]?(?=${lookahead})` + }, + { + begin: `\\b0[oO](_?[0-7])+[lL]?(?=${lookahead})` + }, + { + begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${lookahead})` + }, + { + begin: `\\b(${digitpart})[jJ](?=${lookahead})` + } + ] + }; + const COMMENT_TYPE = { + className: "comment", + begin: regex.lookahead(/# type:/), + end: /$/, + keywords: KEYWORDS2, + contains: [ + { + begin: /# type:/ + }, + { + begin: /#/, + end: /\b\B/, + endsWithParent: true + } + ] + }; + const PARAMS = { + className: "params", + variants: [ + { + className: "", + begin: /\(\s*\)/, + skip: true + }, + { + begin: /\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS2, + contains: [ + "self", + PROMPT, + NUMBER, + STRING, + hljs.HASH_COMMENT_MODE + ] + } + ] + }; + SUBST.contains = [ + STRING, + NUMBER, + PROMPT + ]; + return { + name: "Python", + aliases: [ + "py", + "gyp", + "ipython" + ], + unicodeRegex: true, + keywords: KEYWORDS2, + illegal: /(<\/|\?)|=>/, + contains: [ + PROMPT, + NUMBER, + { + scope: "variable.language", + match: /\bself\b/ + }, + { + beginKeywords: "if", + relevance: 0 + }, + { match: /\bor\b/, scope: "keyword" }, + STRING, + COMMENT_TYPE, + hljs.HASH_COMMENT_MODE, + { + match: [ + /\bdef/, + /\s+/, + IDENT_RE2 + ], + scope: { + 1: "keyword", + 3: "title.function" + }, + contains: [PARAMS] + }, + { + variants: [ + { + match: [ + /\bclass/, + /\s+/, + IDENT_RE2, + /\s*/, + /\(\s*/, + IDENT_RE2, + /\s*\)/ + ] + }, + { + match: [ + /\bclass/, + /\s+/, + IDENT_RE2 + ] + } + ], + scope: { + 1: "keyword", + 3: "title.class", + 6: "title.class.inherited" + } + }, + { + className: "meta", + begin: /^[\t ]*@/, + end: /(?=#)|$/, + contains: [ + NUMBER, + PARAMS, + STRING + ] + } + ] + }; + } + + // node_modules/highlight.js/es/languages/go.js + function go(hljs) { + const LITERALS2 = [ + "true", + "false", + "iota", + "nil" + ]; + const BUILT_INS2 = [ + "append", + "cap", + "close", + "complex", + "copy", + "imag", + "len", + "make", + "new", + "panic", + "print", + "println", + "real", + "recover", + "delete" + ]; + const TYPES2 = [ + "bool", + "byte", + "complex64", + "complex128", + "error", + "float32", + "float64", + "int8", + "int16", + "int32", + "int64", + "string", + "uint8", + "uint16", + "uint32", + "uint64", + "int", + "uint", + "uintptr", + "rune" + ]; + const KWS = [ + "break", + "case", + "chan", + "const", + "continue", + "default", + "defer", + "else", + "fallthrough", + "for", + "func", + "go", + "goto", + "if", + "import", + "interface", + "map", + "package", + "range", + "return", + "select", + "struct", + "switch", + "type", + "var" + ]; + const KEYWORDS2 = { + keyword: KWS, + type: TYPES2, + literal: LITERALS2, + built_in: BUILT_INS2 + }; + return { + name: "Go", + aliases: ["golang"], + keywords: KEYWORDS2, + illegal: "]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*" + }, + { + begin: "<%[%=-]?", + end: "[%-]?%>", + subLanguage: "ruby", + excludeBegin: true, + excludeEnd: true, + relevance: 0 + }, + { + className: "type", + begin: "!\\w+!" + URI_CHARACTERS + }, + { + className: "type", + begin: "!<" + URI_CHARACTERS + ">" + }, + { + className: "type", + begin: "!" + URI_CHARACTERS + }, + { + className: "type", + begin: "!!" + URI_CHARACTERS + }, + { + className: "meta", + begin: "&" + hljs.UNDERSCORE_IDENT_RE + "$" + }, + { + className: "meta", + begin: "\\*" + hljs.UNDERSCORE_IDENT_RE + "$" + }, + { + className: "bullet", + begin: "-(?=[ ]|$)", + relevance: 0 + }, + hljs.HASH_COMMENT_MODE, + { + beginKeywords: LITERALS2, + keywords: { literal: LITERALS2 } + }, + TIMESTAMP, + { + className: "number", + begin: hljs.C_NUMBER_RE + "\\b", + relevance: 0 + }, + OBJECT, + ARRAY, + SINGLE_QUOTE_STRING, + STRING + ]; + const VALUE_MODES = [...MODES]; + VALUE_MODES.pop(); + VALUE_MODES.push(CONTAINER_STRING); + VALUE_CONTAINER.contains = VALUE_MODES; + return { + name: "YAML", + case_insensitive: true, + aliases: ["yml"], + contains: MODES + }; + } + + // node_modules/highlight.js/es/languages/typescript.js + var IDENT_RE2 = "[A-Za-z$_][0-9A-Za-z$_]*"; + var KEYWORDS2 = [ + "as", + "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", + "debugger", + "async", + "await", + "static", + "import", + "from", + "export", + "extends", + "using" + ]; + var LITERALS2 = [ + "true", + "false", + "null", + "undefined", + "NaN", + "Infinity" + ]; + var TYPES2 = [ + "Object", + "Function", + "Boolean", + "Symbol", + "Math", + "Date", + "Number", + "BigInt", + "String", + "RegExp", + "Array", + "Float32Array", + "Float64Array", + "Int8Array", + "Uint8Array", + "Uint8ClampedArray", + "Int16Array", + "Int32Array", + "Uint16Array", + "Uint32Array", + "BigInt64Array", + "BigUint64Array", + "Set", + "Map", + "WeakSet", + "WeakMap", + "ArrayBuffer", + "SharedArrayBuffer", + "Atomics", + "DataView", + "JSON", + "Promise", + "Generator", + "GeneratorFunction", + "AsyncFunction", + "Reflect", + "Proxy", + "Intl", + "WebAssembly" + ]; + var ERROR_TYPES2 = [ + "Error", + "EvalError", + "InternalError", + "RangeError", + "ReferenceError", + "SyntaxError", + "TypeError", + "URIError" + ]; + var BUILT_IN_GLOBALS2 = [ + "setInterval", + "setTimeout", + "clearInterval", + "clearTimeout", + "require", + "exports", + "eval", + "isFinite", + "isNaN", + "parseFloat", + "parseInt", + "decodeURI", + "decodeURIComponent", + "encodeURI", + "encodeURIComponent", + "escape", + "unescape" + ]; + var BUILT_IN_VARIABLES2 = [ + "arguments", + "this", + "super", + "console", + "window", + "document", + "localStorage", + "sessionStorage", + "module", + "global" + ]; + var BUILT_INS2 = [].concat(BUILT_IN_GLOBALS2, TYPES2, ERROR_TYPES2); + function javascript2(hljs) { + const regex = hljs.regex; + const hasClosingTag = (match, { after }) => { + const tag = "", + end: "" + }; + const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/; + const XML_TAG = { + begin: /<[A-Za-z0-9\\._:-]+/, + end: /\/[A-Za-z0-9\\._:-]+>|\/>/, + isTrulyOpeningTag: (match, response) => { + const afterMatchIndex = match[0].length + match.index; + const nextChar = match.input[afterMatchIndex]; + if (nextChar === "<" || nextChar === ",") { + response.ignoreMatch(); + return; + } + if (nextChar === ">") { + if (!hasClosingTag(match, { after: afterMatchIndex })) { + response.ignoreMatch(); + } + } + let m2; + const afterMatch = match.input.substring(afterMatchIndex); + if (m2 = afterMatch.match(/^\s*=/)) { + response.ignoreMatch(); + return; + } + if (m2 = afterMatch.match(/^\s+extends\s+/)) { + if (m2.index === 0) { + response.ignoreMatch(); + return; + } + } + } + }; + const KEYWORDS$1 = { + $pattern: IDENT_RE2, + keyword: KEYWORDS2, + literal: LITERALS2, + built_in: BUILT_INS2, + "variable.language": BUILT_IN_VARIABLES2 + }; + const decimalDigits = "[0-9](_?[0-9])*"; + const frac = `\\.(${decimalDigits})`; + const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`; + const NUMBER = { + className: "number", + variants: [ + { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` + `[eE][+-]?(${decimalDigits})\\b` }, + { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` }, + { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` }, + { 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" }, + { begin: "\\b0[0-7]+n?\\b" } + ], + relevance: 0 + }; + const SUBST = { + className: "subst", + begin: "\\$\\{", + end: "\\}", + keywords: KEYWORDS$1, + contains: [] + }; + 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 GRAPHQL_TEMPLATE = { + begin: ".?gql`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "graphql" + } + }; + const TEMPLATE_STRING = { + className: "string", + begin: "`", + end: "`", + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ] + }; + const JSDOC_COMMENT = hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", { + relevance: 0, + contains: [ + { + begin: "(?=@[A-Za-z]+)", + relevance: 0, + contains: [ + { + className: "doctag", + begin: "@[A-Za-z]+" + }, + { + className: "type", + begin: "\\{", + end: "\\}", + excludeEnd: true, + excludeBegin: true, + relevance: 0 + }, + { + className: "variable", + begin: IDENT_RE$1 + "(?=\\s*(-)|$)", + endsParent: true, + relevance: 0 + }, + { + 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, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + { match: /\$\d+/ }, + NUMBER + ]; + SUBST.contains = SUBST_INTERNALS.concat({ + 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([ + { + begin: /(\s*)\(/, + end: /\)/, + keywords: KEYWORDS$1, + contains: ["self"].concat(SUBST_AND_COMMENTS) + } + ]); + const PARAMS = { + className: "params", + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + }; + const CLASS_OR_EXTENDS = { + variants: [ + { + match: [ + /class/, + /\s+/, + IDENT_RE$1, + /\s+/, + /extends/, + /\s+/, + regex.concat(IDENT_RE$1, "(", regex.concat(/\./, IDENT_RE$1), ")*") + ], + scope: { + 1: "keyword", + 3: "title.class", + 5: "keyword", + 7: "title.class.inherited" + } + }, + { + match: [ + /class/, + /\s+/, + IDENT_RE$1 + ], + scope: { + 1: "keyword", + 3: "title.class" + } + } + ] + }; + const CLASS_REFERENCE = { + relevance: 0, + match: regex.either(/\bJSON/, /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/, /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/, /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/), + className: "title.class", + keywords: { + _: [ + ...TYPES2, + ...ERROR_TYPES2 + ] + } + }; + const USE_STRICT = { + label: "use_strict", + className: "meta", + relevance: 10, + begin: /^\s*['"]use (strict|asm)['"]/ + }; + const FUNCTION_DEFINITION = { + variants: [ + { + match: [ + /function/, + /\s+/, + IDENT_RE$1, + /(?=\s*\()/ + ] + }, + { + match: [ + /function/, + /\s*(?=\()/ + ] + } + ], + className: { + 1: "keyword", + 3: "title.function" + }, + label: "func.def", + contains: [PARAMS], + illegal: /%/ + }; + const UPPER_CASE_CONSTANT = { + relevance: 0, + match: /\b[A-Z][A-Z_0-9]+\b/, + className: "variable.constant" + }; + function noneOf(list) { + return regex.concat("(?!", list.join("|"), ")"); + } + const FUNCTION_CALL = { + match: regex.concat(/\b/, noneOf([ + ...BUILT_IN_GLOBALS2, + "super", + "import" + ].map((x2) => `${x2}\\s*\\(`)), IDENT_RE$1, regex.lookahead(/\s*\(/)), + className: "title.function", + relevance: 0 + }; + const PROPERTY_ACCESS = { + begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/))), + end: IDENT_RE$1, + excludeBegin: true, + keywords: "prototype", + className: "property", + relevance: 0 + }; + const GETTER_OR_SETTER = { + match: [ + /get|set/, + /\s+/, + IDENT_RE$1, + /(?=\()/ + ], + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + { + begin: /\(\)/ + }, + PARAMS + ] + }; + const FUNC_LEAD_IN_RE = "(\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>"; + const FUNCTION_VARIABLE = { + match: [ + /const|var|let/, + /\s+/, + IDENT_RE$1, + /\s*/, + /=\s*/, + /(async\s*)?/, + regex.lookahead(FUNC_LEAD_IN_RE) + ], + keywords: "async", + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + PARAMS + ] + }; + return { + name: "JavaScript", + aliases: ["js", "jsx", "mjs", "cjs"], + keywords: KEYWORDS$1, + exports: { PARAMS_CONTAINS, CLASS_REFERENCE }, + illegal: /#(?![$_A-z])/, + contains: [ + hljs.SHEBANG({ + label: "shebang", + binary: "node", + relevance: 5 + }), + USE_STRICT, + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE, + HTML_TEMPLATE, + CSS_TEMPLATE, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + COMMENT, + { match: /\$\d+/ }, + NUMBER, + CLASS_REFERENCE, + { + scope: "attr", + match: IDENT_RE$1 + regex.lookahead(":"), + relevance: 0 + }, + FUNCTION_VARIABLE, + { + begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*", + keywords: "return throw case", + relevance: 0, + contains: [ + COMMENT, + hljs.REGEXP_MODE, + { + className: "function", + begin: FUNC_LEAD_IN_RE, + returnBegin: true, + end: "\\s*=>", + contains: [ + { + className: "params", + variants: [ + { + begin: hljs.UNDERSCORE_IDENT_RE, + relevance: 0 + }, + { + className: null, + begin: /\(\s*\)/, + skip: true + }, + { + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + } + ] + } + ] + }, + { + begin: /,/, + relevance: 0 + }, + { + match: /\s+/, + relevance: 0 + }, + { + variants: [ + { begin: FRAGMENT.begin, end: FRAGMENT.end }, + { match: XML_SELF_CLOSING }, + { + begin: XML_TAG.begin, + "on:begin": XML_TAG.isTrulyOpeningTag, + end: XML_TAG.end + } + ], + subLanguage: "xml", + contains: [ + { + begin: XML_TAG.begin, + end: XML_TAG.end, + skip: true, + contains: ["self"] + } + ] + } + ] + }, + FUNCTION_DEFINITION, + { + beginKeywords: "while if switch catch for" + }, + { + begin: "\\b(?!function)" + hljs.UNDERSCORE_IDENT_RE + "\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)\\s*\\{", + returnBegin: true, + label: "func.def", + contains: [ + PARAMS, + hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" }) + ] + }, + { + match: /\.\.\./, + relevance: 0 + }, + PROPERTY_ACCESS, + { + match: "\\$" + IDENT_RE$1, + relevance: 0 + }, + { + match: [/\bconstructor(?=\s*\()/], + className: { 1: "title.function" }, + contains: [PARAMS] + }, + FUNCTION_CALL, + UPPER_CASE_CONSTANT, + CLASS_OR_EXTENDS, + GETTER_OR_SETTER, + { + match: /\$[(.]/ + } + ] + }; + } + function typescript(hljs) { + const regex = hljs.regex; + const tsLanguage = javascript2(hljs); + const IDENT_RE$1 = IDENT_RE2; + const TYPES3 = [ + "any", + "void", + "number", + "boolean", + "string", + "object", + "never", + "symbol", + "bigint", + "unknown" + ]; + const NAMESPACE = { + begin: [ + /namespace/, + /\s+/, + hljs.IDENT_RE + ], + beginScope: { + 1: "keyword", + 3: "title.class" + } + }; + const INTERFACE = { + beginKeywords: "interface", + end: /\{/, + excludeEnd: true, + keywords: { + keyword: "interface extends", + built_in: TYPES3 + }, + contains: [tsLanguage.exports.CLASS_REFERENCE] + }; + const USE_STRICT = { + className: "meta", + relevance: 10, + begin: /^\s*['"]use strict['"]/ + }; + const TS_SPECIFIC_KEYWORDS = [ + "type", + "interface", + "public", + "private", + "protected", + "implements", + "declare", + "abstract", + "readonly", + "enum", + "override", + "satisfies" + ]; + const KEYWORDS$1 = { + $pattern: IDENT_RE2, + keyword: KEYWORDS2.concat(TS_SPECIFIC_KEYWORDS), + literal: LITERALS2, + built_in: BUILT_INS2.concat(TYPES3), + "variable.language": BUILT_IN_VARIABLES2 + }; + const DECORATOR = { + className: "meta", + begin: "@" + IDENT_RE$1 + }; + const swapMode = (mode, label, replacement) => { + const indx = mode.contains.findIndex((m2) => m2.label === label); + if (indx === -1) { + throw new Error("can not find mode to replace"); + } + mode.contains.splice(indx, 1, replacement); + }; + Object.assign(tsLanguage.keywords, KEYWORDS$1); + tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR); + const ATTRIBUTE_HIGHLIGHT = tsLanguage.contains.find((c) => c.scope === "attr"); + const OPTIONAL_KEY_OR_ARGUMENT = Object.assign({}, ATTRIBUTE_HIGHLIGHT, { match: regex.concat(IDENT_RE$1, regex.lookahead(/\s*\?:/)) }); + tsLanguage.exports.PARAMS_CONTAINS.push([ + tsLanguage.exports.CLASS_REFERENCE, + ATTRIBUTE_HIGHLIGHT, + OPTIONAL_KEY_OR_ARGUMENT + ]); + tsLanguage.contains = tsLanguage.contains.concat([ + DECORATOR, + NAMESPACE, + INTERFACE, + OPTIONAL_KEY_OR_ARGUMENT + ]); + swapMode(tsLanguage, "shebang", hljs.SHEBANG()); + swapMode(tsLanguage, "use_strict", USE_STRICT); + const functionDeclaration = tsLanguage.contains.find((m2) => m2.label === "func.def"); + functionDeclaration.relevance = 0; + Object.assign(tsLanguage, { + name: "TypeScript", + aliases: [ + "ts", + "tsx", + "mts", + "cts" + ] + }); + return tsLanguage; + } + + // node_modules/highlight.js/es/languages/sql.js + function sql(hljs) { + const regex = hljs.regex; + const COMMENT_MODE = hljs.COMMENT("--", "$"); + const STRING = { + scope: "string", + variants: [ + { + begin: /'/, + end: /'/, + contains: [{ match: /''/ }] + } + ] + }; + const QUOTED_IDENTIFIER = { + begin: /"/, + end: /"/, + contains: [{ match: /""/ }] + }; + const LITERALS3 = [ + "true", + "false", + "unknown" + ]; + const MULTI_WORD_TYPES = [ + "double precision", + "large object", + "with timezone", + "without timezone" + ]; + const TYPES3 = [ + "bigint", + "binary", + "blob", + "boolean", + "char", + "character", + "clob", + "date", + "dec", + "decfloat", + "decimal", + "float", + "int", + "integer", + "interval", + "nchar", + "nclob", + "national", + "numeric", + "real", + "row", + "smallint", + "time", + "timestamp", + "varchar", + "varying", + "varbinary" + ]; + const NON_RESERVED_WORDS = [ + "add", + "asc", + "collation", + "desc", + "final", + "first", + "last", + "view" + ]; + const RESERVED_WORDS = [ + "abs", + "acos", + "all", + "allocate", + "alter", + "and", + "any", + "are", + "array", + "array_agg", + "array_max_cardinality", + "as", + "asensitive", + "asin", + "asymmetric", + "at", + "atan", + "atomic", + "authorization", + "avg", + "begin", + "begin_frame", + "begin_partition", + "between", + "bigint", + "binary", + "blob", + "boolean", + "both", + "by", + "call", + "called", + "cardinality", + "cascaded", + "case", + "cast", + "ceil", + "ceiling", + "char", + "char_length", + "character", + "character_length", + "check", + "classifier", + "clob", + "close", + "coalesce", + "collate", + "collect", + "column", + "commit", + "condition", + "connect", + "constraint", + "contains", + "convert", + "copy", + "corr", + "corresponding", + "cos", + "cosh", + "count", + "covar_pop", + "covar_samp", + "create", + "cross", + "cube", + "cume_dist", + "current", + "current_catalog", + "current_date", + "current_default_transform_group", + "current_path", + "current_role", + "current_row", + "current_schema", + "current_time", + "current_timestamp", + "current_path", + "current_role", + "current_transform_group_for_type", + "current_user", + "cursor", + "cycle", + "date", + "day", + "deallocate", + "dec", + "decimal", + "decfloat", + "declare", + "default", + "define", + "delete", + "dense_rank", + "deref", + "describe", + "deterministic", + "disconnect", + "distinct", + "double", + "drop", + "dynamic", + "each", + "element", + "else", + "empty", + "end", + "end_frame", + "end_partition", + "end-exec", + "equals", + "escape", + "every", + "except", + "exec", + "execute", + "exists", + "exp", + "external", + "extract", + "false", + "fetch", + "filter", + "first_value", + "float", + "floor", + "for", + "foreign", + "frame_row", + "free", + "from", + "full", + "function", + "fusion", + "get", + "global", + "grant", + "group", + "grouping", + "groups", + "having", + "hold", + "hour", + "identity", + "in", + "indicator", + "initial", + "inner", + "inout", + "insensitive", + "insert", + "int", + "integer", + "intersect", + "intersection", + "interval", + "into", + "is", + "join", + "json_array", + "json_arrayagg", + "json_exists", + "json_object", + "json_objectagg", + "json_query", + "json_table", + "json_table_primitive", + "json_value", + "lag", + "language", + "large", + "last_value", + "lateral", + "lead", + "leading", + "left", + "like", + "like_regex", + "listagg", + "ln", + "local", + "localtime", + "localtimestamp", + "log", + "log10", + "lower", + "match", + "match_number", + "match_recognize", + "matches", + "max", + "member", + "merge", + "method", + "min", + "minute", + "mod", + "modifies", + "module", + "month", + "multiset", + "national", + "natural", + "nchar", + "nclob", + "new", + "no", + "none", + "normalize", + "not", + "nth_value", + "ntile", + "null", + "nullif", + "numeric", + "octet_length", + "occurrences_regex", + "of", + "offset", + "old", + "omit", + "on", + "one", + "only", + "open", + "or", + "order", + "out", + "outer", + "over", + "overlaps", + "overlay", + "parameter", + "partition", + "pattern", + "per", + "percent", + "percent_rank", + "percentile_cont", + "percentile_disc", + "period", + "portion", + "position", + "position_regex", + "power", + "precedes", + "precision", + "prepare", + "primary", + "procedure", + "ptf", + "range", + "rank", + "reads", + "real", + "recursive", + "ref", + "references", + "referencing", + "regr_avgx", + "regr_avgy", + "regr_count", + "regr_intercept", + "regr_r2", + "regr_slope", + "regr_sxx", + "regr_sxy", + "regr_syy", + "release", + "result", + "return", + "returns", + "revoke", + "right", + "rollback", + "rollup", + "row", + "row_number", + "rows", + "running", + "savepoint", + "scope", + "scroll", + "search", + "second", + "seek", + "select", + "sensitive", + "session_user", + "set", + "show", + "similar", + "sin", + "sinh", + "skip", + "smallint", + "some", + "specific", + "specifictype", + "sql", + "sqlexception", + "sqlstate", + "sqlwarning", + "sqrt", + "start", + "static", + "stddev_pop", + "stddev_samp", + "submultiset", + "subset", + "substring", + "substring_regex", + "succeeds", + "sum", + "symmetric", + "system", + "system_time", + "system_user", + "table", + "tablesample", + "tan", + "tanh", + "then", + "time", + "timestamp", + "timezone_hour", + "timezone_minute", + "to", + "trailing", + "translate", + "translate_regex", + "translation", + "treat", + "trigger", + "trim", + "trim_array", + "true", + "truncate", + "uescape", + "union", + "unique", + "unknown", + "unnest", + "update", + "upper", + "user", + "using", + "value", + "values", + "value_of", + "var_pop", + "var_samp", + "varbinary", + "varchar", + "varying", + "versioning", + "when", + "whenever", + "where", + "width_bucket", + "window", + "with", + "within", + "without", + "year" + ]; + const RESERVED_FUNCTIONS = [ + "abs", + "acos", + "array_agg", + "asin", + "atan", + "avg", + "cast", + "ceil", + "ceiling", + "coalesce", + "corr", + "cos", + "cosh", + "count", + "covar_pop", + "covar_samp", + "cume_dist", + "dense_rank", + "deref", + "element", + "exp", + "extract", + "first_value", + "floor", + "json_array", + "json_arrayagg", + "json_exists", + "json_object", + "json_objectagg", + "json_query", + "json_table", + "json_table_primitive", + "json_value", + "lag", + "last_value", + "lead", + "listagg", + "ln", + "log", + "log10", + "lower", + "max", + "min", + "mod", + "nth_value", + "ntile", + "nullif", + "percent_rank", + "percentile_cont", + "percentile_disc", + "position", + "position_regex", + "power", + "rank", + "regr_avgx", + "regr_avgy", + "regr_count", + "regr_intercept", + "regr_r2", + "regr_slope", + "regr_sxx", + "regr_sxy", + "regr_syy", + "row_number", + "sin", + "sinh", + "sqrt", + "stddev_pop", + "stddev_samp", + "substring", + "substring_regex", + "sum", + "tan", + "tanh", + "translate", + "translate_regex", + "treat", + "trim", + "trim_array", + "unnest", + "upper", + "value_of", + "var_pop", + "var_samp", + "width_bucket" + ]; + const POSSIBLE_WITHOUT_PARENS = [ + "current_catalog", + "current_date", + "current_default_transform_group", + "current_path", + "current_role", + "current_schema", + "current_transform_group_for_type", + "current_user", + "session_user", + "system_time", + "system_user", + "current_time", + "localtime", + "current_timestamp", + "localtimestamp" + ]; + const COMBOS = [ + "create table", + "insert into", + "primary key", + "foreign key", + "not null", + "alter table", + "add constraint", + "grouping sets", + "on overflow", + "character set", + "respect nulls", + "ignore nulls", + "nulls first", + "nulls last", + "depth first", + "breadth first" + ]; + const FUNCTIONS = RESERVED_FUNCTIONS; + const KEYWORDS3 = [ + ...RESERVED_WORDS, + ...NON_RESERVED_WORDS + ].filter((keyword) => { + return !RESERVED_FUNCTIONS.includes(keyword); + }); + const VARIABLE = { + scope: "variable", + match: /@[a-z0-9][a-z0-9_]*/ + }; + const OPERATOR = { + scope: "operator", + match: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/, + relevance: 0 + }; + const FUNCTION_CALL = { + match: regex.concat(/\b/, regex.either(...FUNCTIONS), /\s*\(/), + relevance: 0, + keywords: { built_in: FUNCTIONS } + }; + function kws_to_regex(list) { + return regex.concat(/\b/, regex.either(...list.map((kw) => { + return kw.replace(/\s+/, "\\s+"); + })), /\b/); + } + const MULTI_WORD_KEYWORDS = { + scope: "keyword", + match: kws_to_regex(COMBOS), + relevance: 0 + }; + function reduceRelevancy(list, { + exceptions, + when + } = {}) { + const qualifyFn = when; + exceptions = exceptions || []; + return list.map((item) => { + if (item.match(/\|\d+$/) || exceptions.includes(item)) { + return item; + } else if (qualifyFn(item)) { + return `${item}|0`; + } else { + return item; + } + }); + } + return { + name: "SQL", + case_insensitive: true, + illegal: /[{}]|<\//, + keywords: { + $pattern: /\b[\w\.]+/, + keyword: reduceRelevancy(KEYWORDS3, { when: (x2) => x2.length < 3 }), + literal: LITERALS3, + type: TYPES3, + built_in: POSSIBLE_WITHOUT_PARENS + }, + contains: [ + { + scope: "type", + match: kws_to_regex(MULTI_WORD_TYPES) + }, + MULTI_WORD_KEYWORDS, + FUNCTION_CALL, + VARIABLE, + STRING, + QUOTED_IDENTIFIER, + hljs.C_NUMBER_MODE, + hljs.C_BLOCK_COMMENT_MODE, + COMMENT_MODE, + OPERATOR + ] + }; + } + + // node_modules/highlight.js/es/languages/xml.js + function xml(hljs) { + const regex = hljs.regex; + const TAG_NAME_RE = regex.concat(/[\p{L}_]/u, regex.optional(/[\p{L}0-9_.-]*:/u), /[\p{L}0-9_.-]*/u); + const XML_IDENT_RE = /[\p{L}0-9._:-]+/u; + const XML_ENTITIES = { + className: "symbol", + begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/ + }; + const XML_META_KEYWORDS = { + begin: /\s/, + contains: [ + { + className: "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: "string" }); + const QUOTE_META_STRING_MODE = hljs.inherit(hljs.QUOTE_STRING_MODE, { className: "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, + unicodeRegex: 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", + end: /\?>/, + variants: [ + { + begin: /<\?xml/, + relevance: 10, + contains: [ + QUOTE_META_STRING_MODE + ] + }, + { + begin: /<\?[a-z][a-z0-9]+/ + } + ] + }, + { + className: "tag", + begin: /
' + escapeHtml2(line.slice(4)) + "
");
- } else if (/^## /.test(line)) {
- out.push('' + escapeHtml2(line.slice(3)) + "
");
- } else if (/^# /.test(line)) {
- out.push('' + escapeHtml2(line.slice(2)) + "
");
- } else if (/^- \[x\] /.test(line)) {
- out.push('' + escapeHtml2(line.slice(6)) + "
");
- } else if (/^- \[ \] /.test(line)) {
- out.push('' + escapeHtml2(line.slice(6)) + "
");
- } else if (/^> /.test(line)) {
- out.push('' + escapeHtml2(line.slice(2)) + "
");
- } else if (/^- /.test(line)) {
- out.push('' + escapeHtml2(line.slice(2)) + "
");
- } else if (line.trim() === "") {
- out.push(""); - } else { - out.push("
" + escapeHtml2(line) + "
");
- }
- }
- return out.join("");
+ return g.parse(text);
}
async function loadTab(loadingId, contentId, label, fetchFn, renderFn) {
var loading = document.getElementById(loadingId);
@@ -527,12 +7684,12 @@
var ws = ctx.workspace || "—";
var filesHtml = "";
if (ctx.bootstrap && ctx.bootstrap.length) {
- filesHtml = ctx.bootstrap.map(function(b) {
- var path = b.path ? escapeHtml2(b.path) : "—";
- var scope = b.scope === "global" ? "global" : "project";
- var found = b.path ? "var(--text)" : "var(--hint)";
+ filesHtml = ctx.bootstrap.map(function(b2) {
+ var path = b2.path ? escapeHtml2(b2.path) : "—";
+ var scope = b2.scope === "global" ? "global" : "project";
+ var found = b2.path ? "var(--text)" : "var(--hint)";
return `
- ${escapeHtml2(b.name)}
+ ${escapeHtml2(b2.name)}
${scope}
`;
@@ -1381,7 +8538,7 @@
var msg;
try {
msg = JSON.parse(e.data);
- } catch (_) {
+ } catch (_2) {
return;
}
if (msg.type === "init") {
@@ -1547,7 +8704,7 @@
var resp = await fetch(API_BASE + "/miniapp/api/research/" + taskId + "/doc/" + docId + "?initData=" + encodeURIComponent(initData));
var data = await resp.json();
body.dataset.loaded = "1";
- body.innerHTML = '' + esc(data.content) + ""; + body.innerHTML = '
' + g.parse(data.content) + "
";
} catch (e) {
body.innerHTML = 'Failed to load document.
';
}