n8n-editor-ui 1.119.1 → 1.120.1

package/dist/assets/xml-legacy-Cyrxa7r6.js

@@ -0,0 +1,1245 @@
+;
+(function () {
+  System.register([], function (_export, _context) {
+    "use strict";
+
+    var IDENT_RE$1, KEYWORDS$1, LITERALS$1, TYPES$1, ERROR_TYPES$1, BUILT_IN_GLOBALS$1, BUILT_IN_VARIABLES$1, BUILT_INS$1, IDENT_RE, KEYWORDS, LITERALS, TYPES, ERROR_TYPES, BUILT_IN_GLOBALS, BUILT_IN_VARIABLES, BUILT_INS;
+    //#region ../../../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/bash.js
+    /** @type LanguageFn */
+    function bash(hljs) {
+      const regex = hljs.regex;
+      const VAR = {};
+      const BRACED_VAR = {
+        begin: /\$\{/,
+        end: /\}/,
+        contains: ["self", {
+          begin: /:-/,
+          contains: [VAR]
+        }]
+      };
+      Object.assign(VAR, {
+        className: "variable",
+        variants: [{
+          begin: regex.concat(/\$[\w\d#@][\w\d_]*/, `(?![\\w\\d])(?![$])`)
+        }, BRACED_VAR]
+      });
+      const SUBST = {
+        className: "subst",
+        begin: /\$\(/,
+        end: /\)/,
+        contains: [hljs.BACKSLASH_ESCAPE]
+      };
+      const COMMENT = hljs.inherit(hljs.COMMENT(), {
+        match: [/(^|\s)/, /#.*$/],
+        scope: {
+          2: "comment"
+        }
+      });
+      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 = {
+        match: /\\"/
+      };
+      const APOS_STRING = {
+        className: "string",
+        begin: /'/,
+        end: /'/
+      };
+      const ESCAPED_APOS = {
+        match: /\\'/
+      };
+      const ARITHMETIC = {
+        begin: /\$?\(\(/,
+        end: /\)\)/,
+        contains: [{
+          begin: /\d+#[0-9a-f]+/,
+          className: "number"
+        }, hljs.NUMBER_MODE, VAR]
+      };
+      const KNOWN_SHEBANG = hljs.SHEBANG({
+        binary: `(${["fish", "bash", "zsh", "sh", "csh", "ksh", "tcsh", "dash", "scsh"].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
+      };
+      const KEYWORDS$2 = ["if", "then", "else", "elif", "fi", "time", "for", "while", "until", "in", "do", "done", "case", "esac", "coproc", "function", "select"];
+      const LITERALS$2 = ["true", "false"];
+      const PATH_MODE = {
+        match: /(\/[a-z._-]+)+/
+      };
+      const SHELL_BUILT_INS = ["break", "cd", "continue", "eval", "exec", "exit", "export", "getopts", "hash", "pwd", "readonly", "return", "shift", "test", "times", "trap", "umask", "unset"];
+      const BASH_BUILT_INS = ["alias", "bind", "builtin", "caller", "command", "declare", "echo", "enable", "help", "let", "local", "logout", "mapfile", "printf", "read", "readarray", "source", "sudo", "type", "typeset", "ulimit", "unalias"];
+      const 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"];
+      const GNU_CORE_UTILS = ["chcon", "chgrp", "chown", "chmod", "cp", "dd", "df", "dir", "dircolors", "ln", "ls", "mkdir", "mkfifo", "mknod", "mktemp", "mv", "realpath", "rm", "rmdir", "shred", "sync", "touch", "truncate", "vdir", "b2sum", "base32", "base64", "cat", "cksum", "comm", "csplit", "cut", "expand", "fmt", "fold", "head", "join", "md5sum", "nl", "numfmt", "od", "paste", "ptx", "pr", "sha1sum", "sha224sum", "sha256sum", "sha384sum", "sha512sum", "shuf", "sort", "split", "sum", "tac", "tail", "tr", "tsort", "unexpand", "uniq", "wc", "arch", "basename", "chroot", "date", "dirname", "du", "echo", "env", "expr", "factor", "groups", "hostid", "id", "link", "logname", "nice", "nohup", "nproc", "pathchk", "pinky", "printenv", "printf", "pwd", "readlink", "runcon", "seq", "sleep", "stat", "stdbuf", "stty", "tee", "test", "timeout", "tty", "uname", "unlink", "uptime", "users", "who", "whoami", "yes"];
+      return {
+        name: "Bash",
+        aliases: ["sh", "zsh"],
+        keywords: {
+          $pattern: /\b[a-z][a-z0-9._-]+\b/,
+          keyword: KEYWORDS$2,
+          literal: LITERALS$2,
+          built_in: [...SHELL_BUILT_INS, ...BASH_BUILT_INS, "set", "shopt", ...ZSH_BUILT_INS, ...GNU_CORE_UTILS]
+        },
+        contains: [KNOWN_SHEBANG, hljs.SHEBANG(), FUNCTION, ARITHMETIC, COMMENT, HERE_DOC, PATH_MODE, QUOTE_STRING, ESCAPED_QUOTE, APOS_STRING, ESCAPED_APOS, VAR]
+      };
+    }
+
+    //#endregion
+    //#region ../../../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/javascript.js
+
+    /** @type LanguageFn */
+    function javascript$1(hljs) {
+      const regex = hljs.regex;
+      /**
+      * Takes a string like "<Booger" and checks to see
+      * if we can find a matching "</Booger" later in the
+      * content.
+      * @param {RegExpMatchArray} match
+      * @param {{after:number}} param1
+      */
+      const hasClosingTag = (match, {
+        after
+      }) => {
+        const tag = "</" + match[0].slice(1);
+        return match.input.indexOf(tag, after) !== -1;
+      };
+      const IDENT_RE$1$1 = IDENT_RE$1;
+      const FRAGMENT = {
+        begin: "<>",
+        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 m;
+          const afterMatch = match.input.substring(afterMatchIndex);
+          if (m = afterMatch.match(/^\s*=/)) {
+            response.ignoreMatch();
+            return;
+          }
+          if (m = afterMatch.match(/^\s+extends\s+/)) {
+            if (m.index === 0) {
+              response.ignoreMatch();
+              return;
+            }
+          }
+        }
+      };
+      const KEYWORDS$1$1 = {
+        $pattern: IDENT_RE$1,
+        keyword: KEYWORDS$1,
+        literal: LITERALS$1,
+        built_in: BUILT_INS$1,
+        "variable.language": BUILT_IN_VARIABLES$1
+      };
+      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$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 COMMENT = {
+        className: "comment",
+        variants: [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$1 + "(?=\\s*(-)|$)",
+              endsParent: true,
+              relevance: 0
+            }, {
+              begin: /(?=[^\n])\s/,
+              relevance: 0
+            }]
+          }]
+        }), 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$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$1,
+        contains: ["self"].concat(SUBST_AND_COMMENTS)
+      }]);
+      const PARAMS = {
+        className: "params",
+        begin: /(\s*)\(/,
+        end: /\)/,
+        excludeBegin: true,
+        excludeEnd: true,
+        keywords: KEYWORDS$1$1,
+        contains: PARAMS_CONTAINS
+      };
+      const CLASS_OR_EXTENDS = {
+        variants: [{
+          match: [/class/, /\s+/, IDENT_RE$1$1, /\s+/, /extends/, /\s+/, regex.concat(IDENT_RE$1$1, "(", regex.concat(/\./, IDENT_RE$1$1), ")*")],
+          scope: {
+            1: "keyword",
+            3: "title.class",
+            5: "keyword",
+            7: "title.class.inherited"
+          }
+        }, {
+          match: [/class/, /\s+/, IDENT_RE$1$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$1, ...ERROR_TYPES$1]
+        }
+      };
+      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$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$1, "super", "import"].map(x => `${x}\\s*\\(`)), IDENT_RE$1$1, regex.lookahead(/\s*\(/)),
+        className: "title.function",
+        relevance: 0
+      };
+      const PROPERTY_ACCESS = {
+        begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1$1, /(?![0-9A-Za-z$_(])/))),
+        end: IDENT_RE$1$1,
+        excludeBegin: true,
+        keywords: "prototype",
+        className: "property",
+        relevance: 0
+      };
+      const GETTER_OR_SETTER = {
+        match: [/get|set/, /\s+/, IDENT_RE$1$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$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$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$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$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$1,
+            className: "title.function"
+          })]
+        }, {
+          match: /\.\.\./,
+          relevance: 0
+        }, PROPERTY_ACCESS, {
+          match: "\\$" + IDENT_RE$1$1,
+          relevance: 0
+        }, {
+          match: [/\bconstructor(?=\s*\()/],
+          className: {
+            1: "title.function"
+          },
+          contains: [PARAMS]
+        }, FUNCTION_CALL, UPPER_CASE_CONSTANT, CLASS_OR_EXTENDS, GETTER_OR_SETTER, {
+          match: /\$[(.]/
+        }]
+      };
+    }
+
+    //#endregion
+    //#region ../../../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/python.js
+    function python(hljs) {
+      const regex = hljs.regex;
+      const IDENT_RE$2 = /[\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 KEYWORDS$2 = {
+        $pattern: /[A-Za-z]\w+|__\w+__/,
+        keyword: RESERVED_WORDS,
+        built_in: ["__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"],
+        literal: ["__debug__", "Ellipsis", "False", "None", "NotImplemented", "True"],
+        type: ["Any", "Callable", "Coroutine", "Dict", "List", "Literal", "Generic", "Optional", "Sequence", "Set", "Tuple", "Type", "Union"]
+      };
+      const PROMPT = {
+        className: "meta",
+        begin: /^(>>>|\.\.\.) /
+      };
+      const SUBST = {
+        className: "subst",
+        begin: /\{/,
+        end: /\}/,
+        keywords: KEYWORDS$2,
+        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: KEYWORDS$2,
+        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: KEYWORDS$2,
+          contains: ["self", PROMPT, NUMBER, STRING, hljs.HASH_COMMENT_MODE]
+        }]
+      };
+      SUBST.contains = [STRING, NUMBER, PROMPT];
+      return {
+        name: "Python",
+        aliases: ["py", "gyp", "ipython"],
+        unicodeRegex: true,
+        keywords: KEYWORDS$2,
+        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_RE$2],
+          scope: {
+            1: "keyword",
+            3: "title.function"
+          },
+          contains: [PARAMS]
+        }, {
+          variants: [{
+            match: [/\bclass/, /\s+/, IDENT_RE$2, /\s*/, /\(\s*/, IDENT_RE$2, /\s*\)/]
+          }, {
+            match: [/\bclass/, /\s+/, IDENT_RE$2]
+          }],
+          scope: {
+            1: "keyword",
+            3: "title.class",
+            6: "title.class.inherited"
+          }
+        }, {
+          className: "meta",
+          begin: /^[\t ]*@/,
+          end: /(?=#)|$/,
+          contains: [NUMBER, PARAMS, STRING]
+        }]
+      };
+    }
+
+    //#endregion
+    //#region ../../../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/typescript.js
+
+    /** @type LanguageFn */
+    function javascript(hljs) {
+      const regex = hljs.regex;
+      /**
+      * Takes a string like "<Booger" and checks to see
+      * if we can find a matching "</Booger" later in the
+      * content.
+      * @param {RegExpMatchArray} match
+      * @param {{after:number}} param1
+      */
+      const hasClosingTag = (match, {
+        after
+      }) => {
+        const tag = "</" + match[0].slice(1);
+        return match.input.indexOf(tag, after) !== -1;
+      };
+      const IDENT_RE$1$1 = IDENT_RE;
+      const FRAGMENT = {
+        begin: "<>",
+        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 m;
+          const afterMatch = match.input.substring(afterMatchIndex);
+          if (m = afterMatch.match(/^\s*=/)) {
+            response.ignoreMatch();
+            return;
+          }
+          if (m = afterMatch.match(/^\s+extends\s+/)) {
+            if (m.index === 0) {
+              response.ignoreMatch();
+              return;
+            }
+          }
+        }
+      };
+      const KEYWORDS$1$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$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 COMMENT = {
+        className: "comment",
+        variants: [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$1 + "(?=\\s*(-)|$)",
+              endsParent: true,
+              relevance: 0
+            }, {
+              begin: /(?=[^\n])\s/,
+              relevance: 0
+            }]
+          }]
+        }), 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$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$1,
+        contains: ["self"].concat(SUBST_AND_COMMENTS)
+      }]);
+      const PARAMS = {
+        className: "params",
+        begin: /(\s*)\(/,
+        end: /\)/,
+        excludeBegin: true,
+        excludeEnd: true,
+        keywords: KEYWORDS$1$1,
+        contains: PARAMS_CONTAINS
+      };
+      const CLASS_OR_EXTENDS = {
+        variants: [{
+          match: [/class/, /\s+/, IDENT_RE$1$1, /\s+/, /extends/, /\s+/, regex.concat(IDENT_RE$1$1, "(", regex.concat(/\./, IDENT_RE$1$1), ")*")],
+          scope: {
+            1: "keyword",
+            3: "title.class",
+            5: "keyword",
+            7: "title.class.inherited"
+          }
+        }, {
+          match: [/class/, /\s+/, IDENT_RE$1$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$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(x => `${x}\\s*\\(`)), IDENT_RE$1$1, regex.lookahead(/\s*\(/)),
+        className: "title.function",
+        relevance: 0
+      };
+      const PROPERTY_ACCESS = {
+        begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1$1, /(?![0-9A-Za-z$_(])/))),
+        end: IDENT_RE$1$1,
+        excludeBegin: true,
+        keywords: "prototype",
+        className: "property",
+        relevance: 0
+      };
+      const GETTER_OR_SETTER = {
+        match: [/get|set/, /\s+/, IDENT_RE$1$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$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$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$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$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$1,
+            className: "title.function"
+          })]
+        }, {
+          match: /\.\.\./,
+          relevance: 0
+        }, PROPERTY_ACCESS, {
+          match: "\\$" + IDENT_RE$1$1,
+          relevance: 0
+        }, {
+          match: [/\bconstructor(?=\s*\()/],
+          className: {
+            1: "title.function"
+          },
+          contains: [PARAMS]
+        }, FUNCTION_CALL, UPPER_CASE_CONSTANT, CLASS_OR_EXTENDS, GETTER_OR_SETTER, {
+          match: /\$[(.]/
+        }]
+      };
+    }
+    /** @type LanguageFn */
+    function typescript(hljs) {
+      const regex = hljs.regex;
+      const tsLanguage = javascript(hljs);
+      const IDENT_RE$1$1 = IDENT_RE;
+      const TYPES$2 = ["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: TYPES$2
+        },
+        contains: [tsLanguage.exports.CLASS_REFERENCE]
+      };
+      const USE_STRICT = {
+        className: "meta",
+        relevance: 10,
+        begin: /^\s*['"]use strict['"]/
+      };
+      const KEYWORDS$1$1 = {
+        $pattern: IDENT_RE,
+        keyword: KEYWORDS.concat(["type", "interface", "public", "private", "protected", "implements", "declare", "abstract", "readonly", "enum", "override", "satisfies"]),
+        literal: LITERALS,
+        built_in: BUILT_INS.concat(TYPES$2),
+        "variable.language": BUILT_IN_VARIABLES
+      };
+      const DECORATOR = {
+        className: "meta",
+        begin: "@" + IDENT_RE$1$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);
+      };
+      Object.assign(tsLanguage.keywords, KEYWORDS$1$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$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(m => m.label === "func.def");
+      functionDeclaration.relevance = 0;
+      Object.assign(tsLanguage, {
+        name: "TypeScript",
+        aliases: ["ts", "tsx", "mts", "cts"]
+      });
+      return tsLanguage;
+    }
+
+    //#endregion
+    //#region ../../../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/xml.js
+    /** @type LanguageFn */
+    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: /</,
+        relevance: 0,
+        contains: [{
+          className: "attr",
+          begin: XML_IDENT_RE,
+          relevance: 0
+        }, {
+          begin: /=\s*/,
+          relevance: 0,
+          contains: [{
+            className: "string",
+            endsParent: true,
+            variants: [{
+              begin: /"/,
+              end: /"/,
+              contains: [XML_ENTITIES]
+            }, {
+              begin: /'/,
+              end: /'/,
+              contains: [XML_ENTITIES]
+            }, {
+              begin: /[^\s"'=<>`]+/
+            }]
+          }]
+        }]
+      };
+      return {
+        name: "HTML, XML",
+        aliases: ["html", "xhtml", "rss", "atom", "xjb", "xsd", "xsl", "plist", "wsf", "svg"],
+        case_insensitive: true,
+        unicodeRegex: true,
+        contains: [{
+          className: "meta",
+          begin: /<![a-z]/,
+          end: />/,
+          relevance: 10,
+          contains: [XML_META_KEYWORDS, QUOTE_META_STRING_MODE, APOS_META_STRING_MODE, XML_META_PAR_KEYWORDS, {
+            begin: /\[/,
+            end: /\]/,
+            contains: [{
+              className: "meta",
+              begin: /<![a-z]/,
+              end: />/,
+              contains: [XML_META_KEYWORDS, XML_META_PAR_KEYWORDS, QUOTE_META_STRING_MODE, APOS_META_STRING_MODE]
+            }]
+          }]
+        }, hljs.COMMENT(/<!--/, /-->/, {
+          relevance: 10
+        }), {
+          begin: /<!\[CDATA\[/,
+          end: /\]\]>/,
+          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: /<style(?=\s|>)/,
+          end: />/,
+          keywords: {
+            name: "style"
+          },
+          contains: [TAG_INTERNALS],
+          starts: {
+            end: /<\/style>/,
+            returnEnd: true,
+            subLanguage: ["css", "xml"]
+          }
+        }, {
+          className: "tag",
+          begin: /<script(?=\s|>)/,
+          end: />/,
+          keywords: {
+            name: "script"
+          },
+          contains: [TAG_INTERNALS],
+          starts: {
+            end: /<\/script>/,
+            returnEnd: true,
+            subLanguage: ["javascript", "handlebars", "xml"]
+          }
+        }, {
+          className: "tag",
+          begin: /<>|<\/>/
+        }, {
+          className: "tag",
+          begin: regex.concat(/</, regex.lookahead(regex.concat(TAG_NAME_RE, regex.either(/\/>/, />/, /\s/)))),
+          end: /\/?>/,
+          contains: [{
+            className: "name",
+            begin: TAG_NAME_RE,
+            relevance: 0,
+            starts: TAG_INTERNALS
+          }]
+        }, {
+          className: "tag",
+          begin: regex.concat(/<\//, regex.lookahead(regex.concat(TAG_NAME_RE, />/))),
+          contains: [{
+            className: "name",
+            begin: TAG_NAME_RE,
+            relevance: 0
+          }, {
+            begin: />/,
+            relevance: 0,
+            endsParent: true
+          }]
+        }]
+      };
+    }
+
+    //#endregion
+    _export({
+      a: bash,
+      i: javascript$1,
+      n: typescript,
+      r: python,
+      t: xml
+    });
+    return {
+      setters: [],
+      execute: function () {
+        IDENT_RE$1 = "[A-Za-z$_][0-9A-Za-z$_]*";
+        KEYWORDS$1 = ["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"];
+        LITERALS$1 = ["true", "false", "null", "undefined", "NaN", "Infinity"];
+        TYPES$1 = ["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"];
+        ERROR_TYPES$1 = ["Error", "EvalError", "InternalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"];
+        BUILT_IN_GLOBALS$1 = ["setInterval", "setTimeout", "clearInterval", "clearTimeout", "require", "exports", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape"];
+        BUILT_IN_VARIABLES$1 = ["arguments", "this", "super", "console", "window", "document", "localStorage", "sessionStorage", "module", "global"];
+        BUILT_INS$1 = [].concat(BUILT_IN_GLOBALS$1, TYPES$1, ERROR_TYPES$1);
+        IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+        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"];
+        LITERALS = ["true", "false", "null", "undefined", "NaN", "Infinity"];
+        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"];
+        ERROR_TYPES = ["Error", "EvalError", "InternalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"];
+        BUILT_IN_GLOBALS = ["setInterval", "setTimeout", "clearInterval", "clearTimeout", "require", "exports", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape"];
+        BUILT_IN_VARIABLES = ["arguments", "this", "super", "console", "window", "document", "localStorage", "sessionStorage", "module", "global"];
+        BUILT_INS = [].concat(BUILT_IN_GLOBALS, TYPES, ERROR_TYPES);
+      }
+    };
+  });
+})();