@kg-ui/kg-ui-plus 0.0.1 → 0.0.3

package/dist/es/node_modules/.pnpm/highlight.js@11.9.0/node_modules/highlight.js/es/languages/erlang.mjs

@@ -0,0 +1,176 @@
+function erlang(hljs) {
+  const BASIC_ATOM_RE = "[a-z'][a-zA-Z0-9_']*";
+  const FUNCTION_NAME_RE = "(" + BASIC_ATOM_RE + ":" + BASIC_ATOM_RE + "|" + BASIC_ATOM_RE + ")";
+  const ERLANG_RESERVED = {
+    keyword: "after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if let not of orelse|10 query receive rem try when xor",
+    literal: "false true"
+  };
+  const COMMENT = hljs.COMMENT("%", "$");
+  const NUMBER = {
+    className: "number",
+    begin: "\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",
+    relevance: 0
+  };
+  const NAMED_FUN = { begin: "fun\\s+" + BASIC_ATOM_RE + "/\\d+" };
+  const FUNCTION_CALL = {
+    begin: FUNCTION_NAME_RE + "\\(",
+    end: "\\)",
+    returnBegin: true,
+    relevance: 0,
+    contains: [
+      {
+        begin: FUNCTION_NAME_RE,
+        relevance: 0
+      },
+      {
+        begin: "\\(",
+        end: "\\)",
+        endsWithParent: true,
+        returnEnd: true,
+        relevance: 0
+        // "contains" defined later
+      }
+    ]
+  };
+  const TUPLE = {
+    begin: /\{/,
+    end: /\}/,
+    relevance: 0
+    // "contains" defined later
+  };
+  const VAR1 = {
+    begin: "\\b_([A-Z][A-Za-z0-9_]*)?",
+    relevance: 0
+  };
+  const VAR2 = {
+    begin: "[A-Z][a-zA-Z0-9_]*",
+    relevance: 0
+  };
+  const RECORD_ACCESS = {
+    begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+    relevance: 0,
+    returnBegin: true,
+    contains: [
+      {
+        begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+        relevance: 0
+      },
+      {
+        begin: /\{/,
+        end: /\}/,
+        relevance: 0
+        // "contains" defined later
+      }
+    ]
+  };
+  const BLOCK_STATEMENTS = {
+    beginKeywords: "fun receive if try case",
+    end: "end",
+    keywords: ERLANG_RESERVED
+  };
+  BLOCK_STATEMENTS.contains = [
+    COMMENT,
+    NAMED_FUN,
+    hljs.inherit(hljs.APOS_STRING_MODE, { className: "" }),
+    BLOCK_STATEMENTS,
+    FUNCTION_CALL,
+    hljs.QUOTE_STRING_MODE,
+    NUMBER,
+    TUPLE,
+    VAR1,
+    VAR2,
+    RECORD_ACCESS
+  ];
+  const BASIC_MODES = [
+    COMMENT,
+    NAMED_FUN,
+    BLOCK_STATEMENTS,
+    FUNCTION_CALL,
+    hljs.QUOTE_STRING_MODE,
+    NUMBER,
+    TUPLE,
+    VAR1,
+    VAR2,
+    RECORD_ACCESS
+  ];
+  FUNCTION_CALL.contains[1].contains = BASIC_MODES;
+  TUPLE.contains = BASIC_MODES;
+  RECORD_ACCESS.contains[1].contains = BASIC_MODES;
+  const DIRECTIVES = [
+    "-module",
+    "-record",
+    "-undef",
+    "-export",
+    "-ifdef",
+    "-ifndef",
+    "-author",
+    "-copyright",
+    "-doc",
+    "-vsn",
+    "-import",
+    "-include",
+    "-include_lib",
+    "-compile",
+    "-define",
+    "-else",
+    "-endif",
+    "-file",
+    "-behaviour",
+    "-behavior",
+    "-spec"
+  ];
+  const PARAMS = {
+    className: "params",
+    begin: "\\(",
+    end: "\\)",
+    contains: BASIC_MODES
+  };
+  return {
+    name: "Erlang",
+    aliases: ["erl"],
+    keywords: ERLANG_RESERVED,
+    illegal: "(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))",
+    contains: [
+      {
+        className: "function",
+        begin: "^" + BASIC_ATOM_RE + "\\s*\\(",
+        end: "->",
+        returnBegin: true,
+        illegal: "\\(|#|//|/\\*|\\\\|:|;",
+        contains: [
+          PARAMS,
+          hljs.inherit(hljs.TITLE_MODE, { begin: BASIC_ATOM_RE })
+        ],
+        starts: {
+          end: ";|\\.",
+          keywords: ERLANG_RESERVED,
+          contains: BASIC_MODES
+        }
+      },
+      COMMENT,
+      {
+        begin: "^-",
+        end: "\\.",
+        relevance: 0,
+        excludeEnd: true,
+        returnBegin: true,
+        keywords: {
+          $pattern: "-" + hljs.IDENT_RE,
+          keyword: DIRECTIVES.map((x) => `${x}|1.5`).join(" ")
+        },
+        contains: [PARAMS]
+      },
+      NUMBER,
+      hljs.QUOTE_STRING_MODE,
+      RECORD_ACCESS,
+      VAR1,
+      VAR2,
+      TUPLE,
+      { begin: /\.$/ }
+      // relevance booster
+    ]
+  };
+}
+export {
+  erlang as default
+};

package/dist/es/node_modules/.pnpm/highlight.js@11.9.0/node_modules/highlight.js/es/languages/go.mjs

@@ -0,0 +1,135 @@
+function go(hljs) {
+  const LITERALS = [
+    "true",
+    "false",
+    "iota",
+    "nil"
+  ];
+  const BUILT_INS = [
+    "append",
+    "cap",
+    "close",
+    "complex",
+    "copy",
+    "imag",
+    "len",
+    "make",
+    "new",
+    "panic",
+    "print",
+    "println",
+    "real",
+    "recover",
+    "delete"
+  ];
+  const TYPES = [
+    "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 KEYWORDS = {
+    keyword: KWS,
+    type: TYPES,
+    literal: LITERALS,
+    built_in: BUILT_INS
+  };
+  return {
+    name: "Go",
+    aliases: ["golang"],
+    keywords: KEYWORDS,
+    illegal: "</",
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        className: "string",
+        variants: [
+          hljs.QUOTE_STRING_MODE,
+          hljs.APOS_STRING_MODE,
+          {
+            begin: "`",
+            end: "`"
+          }
+        ]
+      },
+      {
+        className: "number",
+        variants: [
+          {
+            begin: hljs.C_NUMBER_RE + "[i]",
+            relevance: 1
+          },
+          hljs.C_NUMBER_MODE
+        ]
+      },
+      {
+        begin: /:=/
+        // relevance booster
+      },
+      {
+        className: "function",
+        beginKeywords: "func",
+        end: "\\s*(\\{|$)",
+        excludeEnd: true,
+        contains: [
+          hljs.TITLE_MODE,
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            endsParent: true,
+            keywords: KEYWORDS,
+            illegal: /["']/
+          }
+        ]
+      }
+    ]
+  };
+}
+export {
+  go as default
+};

package/dist/es/node_modules/.pnpm/highlight.js@11.9.0/node_modules/highlight.js/es/languages/http.mjs

@@ -0,0 +1,89 @@
+function http(hljs) {
+  const regex = hljs.regex;
+  const VERSION = "HTTP/([32]|1\\.[01])";
+  const HEADER_NAME = /[A-Za-z][A-Za-z0-9-]*/;
+  const HEADER = {
+    className: "attribute",
+    begin: regex.concat("^", HEADER_NAME, "(?=\\:\\s)"),
+    starts: { contains: [
+      {
+        className: "punctuation",
+        begin: /: /,
+        relevance: 0,
+        starts: {
+          end: "$",
+          relevance: 0
+        }
+      }
+    ] }
+  };
+  const HEADERS_AND_BODY = [
+    HEADER,
+    {
+      begin: "\\n\\n",
+      starts: {
+        subLanguage: [],
+        endsWithParent: true
+      }
+    }
+  ];
+  return {
+    name: "HTTP",
+    aliases: ["https"],
+    illegal: /\S/,
+    contains: [
+      // response
+      {
+        begin: "^(?=" + VERSION + " \\d{3})",
+        end: /$/,
+        contains: [
+          {
+            className: "meta",
+            begin: VERSION
+          },
+          {
+            className: "number",
+            begin: "\\b\\d{3}\\b"
+          }
+        ],
+        starts: {
+          end: /\b\B/,
+          illegal: /\S/,
+          contains: HEADERS_AND_BODY
+        }
+      },
+      // request
+      {
+        begin: "(?=^[A-Z]+ (.*?) " + VERSION + "$)",
+        end: /$/,
+        contains: [
+          {
+            className: "string",
+            begin: " ",
+            end: " ",
+            excludeBegin: true,
+            excludeEnd: true
+          },
+          {
+            className: "meta",
+            begin: VERSION
+          },
+          {
+            className: "keyword",
+            begin: "[A-Z]+"
+          }
+        ],
+        starts: {
+          end: /\b\B/,
+          illegal: /\S/,
+          contains: HEADERS_AND_BODY
+        }
+      },
+      // to allow headers to work even without a preamble
+      hljs.inherit(HEADER, { relevance: 0 })
+    ]
+  };
+}
+export {
+  http as default
+};

package/dist/es/node_modules/.pnpm/highlight.js@11.9.0/node_modules/highlight.js/es/languages/java.mjs

@@ -0,0 +1,254 @@
+var decimalDigits = "[0-9](_*[0-9])*";
+var frac = `\\.(${decimalDigits})`;
+var hexDigits = "[0-9a-fA-F](_*[0-9a-fA-F])*";
+var NUMERIC = {
+  className: "number",
+  variants: [
+    // DecimalFloatingPointLiteral
+    // including ExponentPart
+    { begin: `(\\b(${decimalDigits})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})[fFdD]?\\b` },
+    // excluding ExponentPart
+    { begin: `\\b(${decimalDigits})((${frac})[fFdD]?\\b|\\.([fFdD]\\b)?)` },
+    { begin: `(${frac})[fFdD]?\\b` },
+    { begin: `\\b(${decimalDigits})[fFdD]\\b` },
+    // HexadecimalFloatingPointLiteral
+    { begin: `\\b0[xX]((${hexDigits})\\.?|(${hexDigits})?\\.(${hexDigits}))[pP][+-]?(${decimalDigits})[fFdD]?\\b` },
+    // DecimalIntegerLiteral
+    { begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b" },
+    // HexIntegerLiteral
+    { begin: `\\b0[xX](${hexDigits})[lL]?\\b` },
+    // OctalIntegerLiteral
+    { begin: "\\b0(_*[0-7])*[lL]?\\b" },
+    // BinaryIntegerLiteral
+    { begin: "\\b0[bB][01](_*[01])*[lL]?\\b" }
+  ],
+  relevance: 0
+};
+function recurRegex(re, substitution, depth) {
+  if (depth === -1)
+    return "";
+  return re.replace(substitution, (_) => {
+    return recurRegex(re, substitution, depth - 1);
+  });
+}
+function java(hljs) {
+  const regex = hljs.regex;
+  const JAVA_IDENT_RE = "[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*";
+  const GENERIC_IDENT_RE = JAVA_IDENT_RE + recurRegex("(?:<" + JAVA_IDENT_RE + "~~~(?:\\s*,\\s*" + JAVA_IDENT_RE + "~~~)*>)?", /~~~/g, 2);
+  const MAIN_KEYWORDS = [
+    "synchronized",
+    "abstract",
+    "private",
+    "var",
+    "static",
+    "if",
+    "const ",
+    "for",
+    "while",
+    "strictfp",
+    "finally",
+    "protected",
+    "import",
+    "native",
+    "final",
+    "void",
+    "enum",
+    "else",
+    "break",
+    "transient",
+    "catch",
+    "instanceof",
+    "volatile",
+    "case",
+    "assert",
+    "package",
+    "default",
+    "public",
+    "try",
+    "switch",
+    "continue",
+    "throws",
+    "protected",
+    "public",
+    "private",
+    "module",
+    "requires",
+    "exports",
+    "do",
+    "sealed",
+    "yield",
+    "permits"
+  ];
+  const BUILT_INS = [
+    "super",
+    "this"
+  ];
+  const LITERALS = [
+    "false",
+    "true",
+    "null"
+  ];
+  const TYPES = [
+    "char",
+    "boolean",
+    "long",
+    "float",
+    "int",
+    "byte",
+    "short",
+    "double"
+  ];
+  const KEYWORDS = {
+    keyword: MAIN_KEYWORDS,
+    literal: LITERALS,
+    type: TYPES,
+    built_in: BUILT_INS
+  };
+  const ANNOTATION = {
+    className: "meta",
+    begin: "@" + JAVA_IDENT_RE,
+    contains: [
+      {
+        begin: /\(/,
+        end: /\)/,
+        contains: ["self"]
+        // allow nested () inside our annotation
+      }
+    ]
+  };
+  const PARAMS = {
+    className: "params",
+    begin: /\(/,
+    end: /\)/,
+    keywords: KEYWORDS,
+    relevance: 0,
+    contains: [hljs.C_BLOCK_COMMENT_MODE],
+    endsParent: true
+  };
+  return {
+    name: "Java",
+    aliases: ["jsp"],
+    keywords: KEYWORDS,
+    illegal: /<\/|#/,
+    contains: [
+      hljs.COMMENT(
+        "/\\*\\*",
+        "\\*/",
+        {
+          relevance: 0,
+          contains: [
+            {
+              // eat up @'s in emails to prevent them to be recognized as doctags
+              begin: /\w+@/,
+              relevance: 0
+            },
+            {
+              className: "doctag",
+              begin: "@[A-Za-z]+"
+            }
+          ]
+        }
+      ),
+      // relevance boost
+      {
+        begin: /import java\.[a-z]+\./,
+        keywords: "import",
+        relevance: 2
+      },
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        begin: /"""/,
+        end: /"""/,
+        className: "string",
+        contains: [hljs.BACKSLASH_ESCAPE]
+      },
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        match: [
+          /\b(?:class|interface|enum|extends|implements|new)/,
+          /\s+/,
+          JAVA_IDENT_RE
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        // Exceptions for hyphenated keywords
+        match: /non-sealed/,
+        scope: "keyword"
+      },
+      {
+        begin: [
+          regex.concat(/(?!else)/, JAVA_IDENT_RE),
+          /\s+/,
+          JAVA_IDENT_RE,
+          /\s+/,
+          /=(?!=)/
+        ],
+        className: {
+          1: "type",
+          3: "variable",
+          5: "operator"
+        }
+      },
+      {
+        begin: [
+          /record/,
+          /\s+/,
+          JAVA_IDENT_RE
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        },
+        contains: [
+          PARAMS,
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        // Expression keywords prevent 'keyword Name(...)' from being
+        // recognized as a function definition
+        beginKeywords: "new throw return else",
+        relevance: 0
+      },
+      {
+        begin: [
+          "(?:" + GENERIC_IDENT_RE + "\\s+)",
+          hljs.UNDERSCORE_IDENT_RE,
+          /\s*(?=\()/
+        ],
+        className: { 2: "title.function" },
+        keywords: KEYWORDS,
+        contains: [
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            keywords: KEYWORDS,
+            relevance: 0,
+            contains: [
+              ANNOTATION,
+              hljs.APOS_STRING_MODE,
+              hljs.QUOTE_STRING_MODE,
+              NUMERIC,
+              hljs.C_BLOCK_COMMENT_MODE
+            ]
+          },
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      NUMERIC,
+      ANNOTATION
+    ]
+  };
+}
+export {
+  java as default
+};