sulibao-mini/components/agent-ui/wd-markdown/utils/hljs_javascript.min.js

export default (() => {
  {
    let I = "[A-Za-z$_][0-9A-Za-z$_]*",
      x = ["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"],
      O = ["true", "false", "null", "undefined", "NaN", "Infinity"],
      C = ["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"],
      M = ["Error", "EvalError", "InternalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"],
      T = ["setInterval", "setTimeout", "clearInterval", "clearTimeout", "require", "exports", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape"],
      B = ["arguments", "this", "super", "console", "window", "document", "localStorage", "sessionStorage", "module", "global"],
      $ = [].concat(T, C, M);
    return e => {
      const n = e.regex,
        a = I,
        t = /<[A-Za-z0-9\\._:-]+/,
        s = /\/[A-Za-z0-9\\._:-]+>|\/>/,
        r = (e, n) => {
          var a,
            t,
            s = e[0].length + e.index,
            r = e.input[s];
          ("<" === r || "," === r || (">" === r && ([r, a] = [e, {
            after: s
          }.after], t = "</" + r[0].slice(1), -1 === r.input.indexOf(t, a)) && n.ignoreMatch(), (r = e.input.substring(s)).match(/^\s*=/)) || (t = r.match(/^\s+extends\s+/)) && 0 === t.index) && n.ignoreMatch();
        },
        c = {
          $pattern: I,
          keyword: x,
          literal: O,
          built_in: $,
          "variable.language": B
        },
        i = "[0-9](_?[0-9])*",
        o = `\\.(${i})`,
        l = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",
        b = {
          className: "number",
          variants: [{
            begin: `(\\b(${l})((${o})|\\.)?|(${o}))[eE][+-]?(${i})\\b`
          }, {
            begin: `\\b(${l})\\b((${o})\\b|\\.)?|(${o})\\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
        },
        d = {
          className: "subst",
          begin: "\\$\\{",
          end: "\\}",
          keywords: c,
          contains: []
        },
        g = {
          begin: "html`",
          end: "",
          starts: {
            end: "`",
            returnEnd: !1,
            contains: [e.BACKSLASH_ESCAPE, d],
            subLanguage: "xml"
          }
        },
        u = {
          begin: "css`",
          end: "",
          starts: {
            end: "`",
            returnEnd: !1,
            contains: [e.BACKSLASH_ESCAPE, d],
            subLanguage: "css"
          }
        },
        m = {
          begin: "gql`",
          end: "",
          starts: {
            end: "`",
            returnEnd: !1,
            contains: [e.BACKSLASH_ESCAPE, d],
            subLanguage: "graphql"
          }
        },
        E = {
          className: "string",
          begin: "`",
          end: "`",
          contains: [e.BACKSLASH_ESCAPE, d]
        },
        A = {
          className: "comment",
          variants: [e.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
            relevance: 0,
            contains: [{
              begin: "(?=@[A-Za-z]+)",
              relevance: 0,
              contains: [{
                className: "doctag",
                begin: "@[A-Za-z]+"
              }, {
                className: "type",
                begin: "\\{",
                end: "\\}",
                excludeEnd: !0,
                excludeBegin: !0,
                relevance: 0
              }, {
                className: "variable",
                begin: a + "(?=\\s*(-)|$)",
                endsParent: !0,
                relevance: 0
              }, {
                begin: /(?=[^\n])\s/,
                relevance: 0
              }]
            }]
          }), e.C_BLOCK_COMMENT_MODE, e.C_LINE_COMMENT_MODE]
        },
        y = [e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, g, u, m, E, {
          match: /\$\d+/
        }, b];
      d.contains = y.concat({
        begin: /\{/,
        end: /\}/,
        keywords: c,
        contains: ["self"].concat(y)
      });
      var N = [].concat(A, d.contains),
        N = N.concat([{
          begin: /\(/,
          end: /\)/,
          keywords: c,
          contains: ["self"].concat(N)
        }]),
        _ = {
          className: "params",
          begin: /\(/,
          end: /\)/,
          excludeBegin: !0,
          excludeEnd: !0,
          keywords: c,
          contains: N
        },
        h = {
          variants: [{
            match: [/class/, /\s+/, a, /\s+/, /extends/, /\s+/, n.concat(a, "(", n.concat(/\./, a), ")*")],
            scope: {
              1: "keyword",
              3: "title.class",
              5: "keyword",
              7: "title.class.inherited"
            }
          }, {
            match: [/class/, /\s+/, a],
            scope: {
              1: "keyword",
              3: "title.class"
            }
          }]
        },
        f = {
          relevance: 0,
          match: n.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: {
            _: [...C, ...M]
          }
        },
        S = {
          variants: [{
            match: [/function/, /\s+/, a, /(?=\s*\()/]
          }, {
            match: [/function/, /\s*(?=\()/]
          }],
          className: {
            1: "keyword",
            3: "title.function"
          },
          label: "func.def",
          contains: [_],
          illegal: /%/
        },
        v = {
          match: n.concat(/\b/, (v = [...T, "super", "import"], n.concat("(?!", v.join("|"), ")")), a, n.lookahead(/\(/)),
          className: "title.function",
          relevance: 0
        },
        p = {
          begin: n.concat(/\./, n.lookahead(n.concat(a, /(?![0-9A-Za-z$_(])/))),
          end: a,
          excludeBegin: !0,
          keywords: "prototype",
          className: "property",
          relevance: 0
        },
        w = {
          match: [/get|set/, /\s+/, a, /(?=\()/],
          className: {
            1: "keyword",
            3: "title.function"
          },
          contains: [{
            begin: /\(\)/
          }, _]
        },
        R = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>",
        k = {
          match: [/const|var|let/, /\s+/, a, /\s*/, /=\s*/, /(async\s*)?/, n.lookahead(R)],
          keywords: "async",
          className: {
            1: "keyword",
            3: "title.function"
          },
          contains: [_]
        };
      return {
        name: "JavaScript",
        aliases: ["js", "jsx", "mjs", "cjs"],
        keywords: c,
        exports: {
          PARAMS_CONTAINS: N,
          CLASS_REFERENCE: f
        },
        illegal: /#(?![$_A-z])/,
        contains: [e.SHEBANG({
          label: "shebang",
          binary: "node",
          relevance: 5
        }), {
          label: "use_strict",
          className: "meta",
          relevance: 10,
          begin: /^\s*['"]use (strict|asm)['"]/
        }, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, g, u, m, E, A, {
          match: /\$\d+/
        }, b, f, {
          className: "attr",
          begin: a + n.lookahead(":"),
          relevance: 0
        }, k, {
          begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
          keywords: "return throw case",
          relevance: 0,
          contains: [A, e.REGEXP_MODE, {
            className: "function",
            begin: R,
            returnBegin: !0,
            end: "\\s*=>",
            contains: [{
              className: "params",
              variants: [{
                begin: e.UNDERSCORE_IDENT_RE,
                relevance: 0
              }, {
                className: null,
                begin: /\(\s*\)/,
                skip: !0
              }, {
                begin: /\(/,
                end: /\)/,
                excludeBegin: !0,
                excludeEnd: !0,
                keywords: c,
                contains: N
              }]
            }]
          }, {
            begin: /,/,
            relevance: 0
          }, {
            match: /\s+/,
            relevance: 0
          }, {
            variants: [{
              begin: "<>",
              end: "</>"
            }, {
              match: /<[A-Za-z0-9\\._:-]+\s*\/>/
            }, {
              begin: t,
              "on:begin": r,
              end: s
            }],
            subLanguage: "xml",
            contains: [{
              begin: t,
              end: s,
              skip: !0,
              contains: ["self"]
            }]
          }]
        }, S, {
          beginKeywords: "while if switch catch for"
        }, {
          begin: "\\b(?!function)" + e.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
          returnBegin: !0,
          label: "func.def",
          contains: [_, e.inherit(e.TITLE_MODE, {
            begin: a,
            className: "title.function"
          })]
        }, {
          match: /\.\.\./,
          relevance: 0
        }, p, {
          match: "\\$" + a,
          relevance: 0
        }, {
          match: [/\bconstructor(?=\s*\()/],
          className: {
            1: "title.function"
          },
          contains: [_]
        }, v, {
          relevance: 0,
          match: /\b[A-Z][A-Z_0-9]+\b/,
          className: "variable.constant"
        }, h, w, {
          match: /\$[(.]/
        }]
      };
    };
  }
});