@glodon-aiot/agent-cli-ui 0.0.0-20251106104234

package/dist/es/node_modules/refractor/lang/shell-session.mjs

@@ -0,0 +1,69 @@
+import { __require as t } from "./bash.mjs";
+var r, a;
+function l() {
+  if (a)
+    return r;
+  a = 1;
+  var o = t();
+  r = e, e.displayName = "shellSession", e.aliases = [];
+  function e(n) {
+    n.register(o), function(s) {
+      var u = [
+        // normal string
+        /"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source,
+        /'[^']*'/.source,
+        /\$'(?:[^'\\]|\\[\s\S])*'/.source,
+        // here doc
+        // 2 capturing groups
+        /<<-?\s*(["']?)(\w+)\1\s[\s\S]*?[\r\n]\2/.source
+      ].join("|");
+      s.languages["shell-session"] = {
+        command: {
+          pattern: RegExp(
+            // user info
+            /^/.source + "(?:" + // <user> ":" ( <path> )?
+            (/[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+(?::[^\0-\x1F$#%*?"<>:;|]+)?/.source + "|" + // <path>
+            // Since the path pattern is quite general, we will require it to start with a special character to
+            // prevent false positives.
+            /[/~.][^\0-\x1F$#%*?"<>@:;|]*/.source) + ")?" + // shell symbol
+            /[$#%](?=\s)/.source + // bash command
+            /(?:[^\\\r\n \t'"<$]|[ \t](?:(?!#)|#.*$)|\\(?:[^\r]|\r\n?)|\$(?!')|<(?!<)|<<str>>)+/.source.replace(/<<str>>/g, function() {
+              return u;
+            }),
+            "m"
+          ),
+          greedy: !0,
+          inside: {
+            info: {
+              // foo@bar:~/files$ exit
+              // foo@bar$ exit
+              // ~/files$ exit
+              pattern: /^[^#$%]+/,
+              alias: "punctuation",
+              inside: {
+                user: /^[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+/,
+                punctuation: /:/,
+                path: /[\s\S]+/
+              }
+            },
+            bash: {
+              pattern: /(^[$#%]\s*)\S[\s\S]*/,
+              lookbehind: !0,
+              alias: "language-bash",
+              inside: s.languages.bash
+            },
+            "shell-symbol": {
+              pattern: /^[$#%]/,
+              alias: "important"
+            }
+          }
+        },
+        output: /.(?:.*(?:[\r\n]|.$))*/
+      }, s.languages["sh-session"] = s.languages.shellsession = s.languages["shell-session"];
+    }(n);
+  }
+  return r;
+}
+export {
+  l as __require
+};

package/dist/es/node_modules/refractor/lang/smali.mjs

@@ -0,0 +1,84 @@
+var t, n;
+function a() {
+  if (n)
+    return t;
+  n = 1, t = e, e.displayName = "smali", e.aliases = [];
+  function e(r) {
+    r.languages.smali = {
+      comment: /#.*/,
+      string: {
+        pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(^|[^L])L(?:(?:\w+|`[^`\r\n]*`)\/)*(?:[\w$]+|`[^`\r\n]*`)(?=\s*;)/,
+        lookbehind: !0,
+        inside: {
+          "class-name": {
+            pattern: /(^L|\/)(?:[\w$]+|`[^`\r\n]*`)$/,
+            lookbehind: !0
+          },
+          namespace: {
+            pattern: /^(L)(?:(?:\w+|`[^`\r\n]*`)\/)+/,
+            lookbehind: !0,
+            inside: {
+              punctuation: /\//
+            }
+          },
+          builtin: /^L/
+        }
+      },
+      builtin: [{
+        // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types
+        pattern: /([();\[])[BCDFIJSVZ]+/,
+        lookbehind: !0
+      }, {
+        // e.g. .field mWifiOnUid:I
+        pattern: /([\w$>]:)[BCDFIJSVZ]/,
+        lookbehind: !0
+      }],
+      keyword: [{
+        pattern: /(\.end\s+)[\w-]+/,
+        lookbehind: !0
+      }, {
+        pattern: /(^|[^\w.-])\.(?!\d)[\w-]+/,
+        lookbehind: !0
+      }, {
+        pattern: /(^|[^\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\w.-])/,
+        lookbehind: !0
+      }],
+      function: {
+        pattern: /(^|[^\w.-])(?:\w+|<[\w$-]+>)(?=\()/,
+        lookbehind: !0
+      },
+      field: {
+        pattern: /[\w$]+(?=:)/,
+        alias: "variable"
+      },
+      register: {
+        pattern: /(^|[^\w.-])[vp]\d(?![\w.-])/,
+        lookbehind: !0,
+        alias: "variable"
+      },
+      boolean: {
+        pattern: /(^|[^\w.-])(?:false|true)(?![\w.-])/,
+        lookbehind: !0
+      },
+      number: {
+        pattern: /(^|[^/\w.-])-?(?:NAN|INFINITY|0x(?:[\dA-F]+(?:\.[\dA-F]*)?|\.[\dA-F]+)(?:p[+-]?[\dA-F]+)?|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)[dflst]?(?![\w.-])/i,
+        lookbehind: !0
+      },
+      label: {
+        pattern: /(:)\w+/,
+        lookbehind: !0,
+        alias: "property"
+      },
+      operator: /->|\.\.|[\[=]/,
+      punctuation: /[{}(),;:]/
+    };
+  }
+  return t;
+}
+export {
+  a as __require
+};

package/dist/es/node_modules/refractor/lang/smalltalk.mjs

@@ -0,0 +1,47 @@
+var a, r;
+function l() {
+  if (r)
+    return a;
+  r = 1, a = e, e.displayName = "smalltalk", e.aliases = [];
+  function e(t) {
+    t.languages.smalltalk = {
+      comment: {
+        pattern: /"(?:""|[^"])*"/,
+        greedy: !0
+      },
+      char: {
+        pattern: /\$./,
+        greedy: !0
+      },
+      string: {
+        pattern: /'(?:''|[^'])*'/,
+        greedy: !0
+      },
+      symbol: /#[\da-z]+|#(?:-|([+\/\\*~<>=@%|&?!])\1?)|#(?=\()/i,
+      "block-arguments": {
+        pattern: /(\[\s*):[^\[|]*\|/,
+        lookbehind: !0,
+        inside: {
+          variable: /:[\da-z]+/i,
+          punctuation: /\|/
+        }
+      },
+      "temporary-variables": {
+        pattern: /\|[^|]+\|/,
+        inside: {
+          variable: /[\da-z]+/i,
+          punctuation: /\|/
+        }
+      },
+      keyword: /\b(?:new|nil|self|super)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: [/\d+r-?[\dA-Z]+(?:\.[\dA-Z]+)?(?:e-?\d+)?/, /\b\d+(?:\.\d+)?(?:e-?\d+)?/],
+      operator: /[<=]=?|:=|~[~=]|\/\/?|\\\\|>[>=]?|[!^+\-*&|,@]/,
+      punctuation: /[.;:?\[\](){}]/
+    };
+  }
+  return a;
+}
+export {
+  l as __require
+};

package/dist/es/node_modules/refractor/lang/smarty.mjs

@@ -0,0 +1,106 @@
+import { __require as y } from "./markup-templating.mjs";
+var n, o;
+function m() {
+  if (o)
+    return n;
+  o = 1;
+  var u = y();
+  n = t, t.displayName = "smarty", t.aliases = [];
+  function t(i) {
+    i.register(u), function(e) {
+      e.languages.smarty = {
+        comment: {
+          pattern: /^\{\*[\s\S]*?\*\}/,
+          greedy: !0
+        },
+        "embedded-php": {
+          pattern: /^\{php\}[\s\S]*?\{\/php\}/,
+          greedy: !0,
+          inside: {
+            smarty: {
+              pattern: /^\{php\}|\{\/php\}$/,
+              inside: null
+              // see below
+            },
+            php: {
+              pattern: /[\s\S]+/,
+              alias: "language-php",
+              inside: e.languages.php
+            }
+          }
+        },
+        string: [{
+          pattern: /"(?:\\.|[^"\\\r\n])*"/,
+          greedy: !0,
+          inside: {
+            interpolation: {
+              pattern: /\{[^{}]*\}|`[^`]*`/,
+              inside: {
+                "interpolation-punctuation": {
+                  pattern: /^[{`]|[`}]$/,
+                  alias: "punctuation"
+                },
+                expression: {
+                  pattern: /[\s\S]+/,
+                  inside: null
+                  // see below
+                }
+              }
+            },
+            variable: /\$\w+/
+          }
+        }, {
+          pattern: /'(?:\\.|[^'\\\r\n])*'/,
+          greedy: !0
+        }],
+        keyword: {
+          pattern: /(^\{\/?)[a-z_]\w*\b(?!\()/i,
+          lookbehind: !0,
+          greedy: !0
+        },
+        delimiter: {
+          pattern: /^\{\/?|\}$/,
+          greedy: !0,
+          alias: "punctuation"
+        },
+        number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+        variable: [/\$(?!\d)\w+/, /#(?!\d)\w+#/, {
+          pattern: /(\.|->|\w\s*=)(?!\d)\w+\b(?!\()/,
+          lookbehind: !0
+        }, {
+          pattern: /(\[)(?!\d)\w+(?=\])/,
+          lookbehind: !0
+        }],
+        function: {
+          pattern: /(\|\s*)@?[a-z_]\w*|\b[a-z_]\w*(?=\()/i,
+          lookbehind: !0
+        },
+        "attr-name": /\b[a-z_]\w*(?=\s*=)/i,
+        boolean: /\b(?:false|no|off|on|true|yes)\b/,
+        punctuation: /[\[\](){}.,:`]|->/,
+        operator: [/[+\-*\/%]|==?=?|[!<>]=?|&&|\|\|?/, /\bis\s+(?:not\s+)?(?:div|even|odd)(?:\s+by)?\b/, /\b(?:and|eq|gt?e|gt|lt?e|lt|mod|neq?|not|or)\b/]
+      }, e.languages.smarty["embedded-php"].inside.smarty.inside = e.languages.smarty, e.languages.smarty.string[0].inside.interpolation.inside.expression.inside = e.languages.smarty;
+      var p = /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/, d = RegExp(
+        // comments
+        /\{\*[\s\S]*?\*\}/.source + "|" + // php tags
+        /\{php\}[\s\S]*?\{\/php\}/.source + "|" + // smarty blocks
+        /\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>)*\})*\})*\}/.source.replace(/<str>/g, function() {
+          return p.source;
+        }),
+        "g"
+      );
+      e.hooks.add("before-tokenize", function(r) {
+        var l = "{literal}", g = "{/literal}", a = !1;
+        e.languages["markup-templating"].buildPlaceholders(r, "smarty", d, function(s) {
+          return s === g && (a = !1), a ? !1 : (s === l && (a = !0), !0);
+        });
+      }), e.hooks.add("after-tokenize", function(r) {
+        e.languages["markup-templating"].tokenizePlaceholders(r, "smarty");
+      });
+    }(i);
+  }
+  return n;
+}
+export {
+  m as __require
+};

package/dist/es/node_modules/refractor/lang/sml.mjs

@@ -0,0 +1,64 @@
+var t, r;
+function u() {
+  if (r)
+    return t;
+  r = 1, t = n, n.displayName = "sml", n.aliases = ["smlnj"];
+  function n(s) {
+    (function(e) {
+      var a = /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i;
+      e.languages.sml = {
+        // allow one level of nesting
+        comment: /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
+        string: {
+          pattern: /#?"(?:[^"\\]|\\.)*"/,
+          greedy: !0
+        },
+        "class-name": [{
+          // This is only an approximation since the real grammar is context-free
+          //
+          // Why the main loop so complex?
+          // The main loop is approximately the same as /(?:\s*(?:[*,]|->)\s*<TERMINAL>)*/ which is, obviously, a lot
+          // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be
+          // followed by a long identifier.
+          pattern: RegExp(/((?:^|[^:]):\s*)<TERMINAL>(?:\s*(?:(?:\*|->)\s*<TERMINAL>|,\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\s+<LONG-ID>)))*/.source.replace(/<NOT-LAST>/g, function() {
+            return /\s*(?:[*,]|->)/.source;
+          }).replace(/<TERMINAL>/g, function() {
+            return /(?:'[\w']*|<LONG-ID>|\((?:[^()]|\([^()]*\))*\)|\{(?:[^{}]|\{[^{}]*\})*\})(?:\s+<LONG-ID>)*/.source;
+          }).replace(/<LONG-ID>/g, function() {
+            return /(?!<KEYWORD>)[a-z\d_][\w'.]*/.source;
+          }).replace(/<KEYWORD>/g, function() {
+            return a.source;
+          }), "i"),
+          lookbehind: !0,
+          greedy: !0,
+          inside: null
+          // see below
+        }, {
+          pattern: /((?:^|[^\w'])(?:datatype|exception|functor|signature|structure|type)\s+)[a-z_][\w'.]*/i,
+          lookbehind: !0
+        }],
+        function: {
+          pattern: /((?:^|[^\w'])fun\s+)[a-z_][\w'.]*/i,
+          lookbehind: !0
+        },
+        keyword: a,
+        variable: {
+          pattern: /(^|[^\w'])'[\w']*/,
+          lookbehind: !0
+        },
+        number: /~?\b(?:\d+(?:\.\d+)?(?:e~?\d+)?|0x[\da-f]+)\b/i,
+        word: {
+          pattern: /\b0w(?:\d+|x[\da-f]+)\b/i,
+          alias: "constant"
+        },
+        boolean: /\b(?:false|true)\b/i,
+        operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
+        punctuation: /[(){}\[\].:,;]/
+      }, e.languages.sml["class-name"][0].inside = e.languages.sml, e.languages.smlnj = e.languages.sml;
+    })(s);
+  }
+  return t;
+}
+export {
+  u as __require
+};

package/dist/es/node_modules/refractor/lang/solidity.mjs

@@ -0,0 +1,28 @@
+var i, r;
+function a() {
+  if (r)
+    return i;
+  r = 1, i = t, t.displayName = "solidity", t.aliases = ["sol"];
+  function t(e) {
+    e.languages.solidity = e.languages.extend("clike", {
+      "class-name": {
+        pattern: /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
+        lookbehind: !0
+      },
+      keyword: /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
+      operator: /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
+    }), e.languages.insertBefore("solidity", "keyword", {
+      builtin: /\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/
+    }), e.languages.insertBefore("solidity", "number", {
+      version: {
+        pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
+        lookbehind: !0,
+        alias: "number"
+      }
+    }), e.languages.sol = e.languages.solidity;
+  }
+  return i;
+}
+export {
+  a as __require
+};

package/dist/es/node_modules/refractor/lang/solution-file.mjs

@@ -0,0 +1,58 @@
+var i, r;
+function o() {
+  if (r)
+    return i;
+  r = 1, i = e, e.displayName = "solutionFile", e.aliases = [];
+  function e(a) {
+    (function(n) {
+      var t = {
+        // https://en.wikipedia.org/wiki/Universally_unique_identifier#Format
+        pattern: /\{[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\}/i,
+        alias: "constant",
+        inside: {
+          punctuation: /[{}]/
+        }
+      };
+      n.languages["solution-file"] = {
+        comment: {
+          pattern: /#.*/,
+          greedy: !0
+        },
+        string: {
+          pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+          greedy: !0,
+          inside: {
+            guid: t
+          }
+        },
+        object: {
+          // Foo
+          //   Bar("abs") = 9
+          //   EndBar
+          //   Prop = TRUE
+          // EndFoo
+          pattern: /^([ \t]*)(?:([A-Z]\w*)\b(?=.*(?:\r\n?|\n)(?:\1[ \t].*(?:\r\n?|\n))*\1End\2(?=[ \t]*$))|End[A-Z]\w*(?=[ \t]*$))/m,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "keyword"
+        },
+        property: {
+          pattern: /^([ \t]*)(?!\s)[^\r\n"#=()]*[^\s"#=()](?=\s*=)/m,
+          lookbehind: !0,
+          inside: {
+            guid: t
+          }
+        },
+        guid: t,
+        number: /\b\d+(?:\.\d+)*\b/,
+        boolean: /\b(?:FALSE|TRUE)\b/,
+        operator: /=/,
+        punctuation: /[(),]/
+      }, n.languages.sln = n.languages["solution-file"];
+    })(a);
+  }
+  return i;
+}
+export {
+  o as __require
+};

package/dist/es/node_modules/refractor/lang/soy.mjs

@@ -0,0 +1,77 @@
+import { __require as m } from "./markup-templating.mjs";
+var n, u;
+function g() {
+  if (u)
+    return n;
+  u = 1;
+  var p = m();
+  n = a, a.displayName = "soy", a.aliases = [];
+  function a(l) {
+    l.register(p), function(e) {
+      var i = /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, o = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-F]+\b/;
+      e.languages.soy = {
+        comment: [/\/\*[\s\S]*?\*\//, {
+          pattern: /(\s)\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }],
+        "command-arg": {
+          pattern: /(\{+\/?\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\s+)\.?[\w.]+/,
+          lookbehind: !0,
+          alias: "string",
+          inside: {
+            punctuation: /\./
+          }
+        },
+        parameter: {
+          pattern: /(\{+\/?\s*@?param\??\s+)\.?[\w.]+/,
+          lookbehind: !0,
+          alias: "variable"
+        },
+        keyword: [{
+          pattern: /(\{+\/?[^\S\r\n]*)(?:\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\??|rb|sp|switch|template|xid)/,
+          lookbehind: !0
+        }, /\b(?:any|as|attributes|bool|css|float|html|in|int|js|list|map|null|number|string|uri)\b/],
+        delimiter: {
+          pattern: /^\{+\/?|\/?\}+$/,
+          alias: "punctuation"
+        },
+        property: /\w+(?==)/,
+        variable: {
+          pattern: /\$[^\W\d]\w*(?:\??(?:\.\w+|\[[^\]]+\]))*/,
+          inside: {
+            string: {
+              pattern: i,
+              greedy: !0
+            },
+            number: o,
+            punctuation: /[\[\].?]/
+          }
+        },
+        string: {
+          pattern: i,
+          greedy: !0
+        },
+        function: [/\w+(?=\()/, {
+          pattern: /(\|[^\S\r\n]*)\w+/,
+          lookbehind: !0
+        }],
+        boolean: /\b(?:false|true)\b/,
+        number: o,
+        operator: /\?:?|<=?|>=?|==?|!=|[+*/%-]|\b(?:and|not|or)\b/,
+        punctuation: /[{}()\[\]|.,:]/
+      }, e.hooks.add("before-tokenize", function(t) {
+        var d = /\{\{.+?\}\}|\{.+?\}|\s\/\/.*|\/\*[\s\S]*?\*\//g, b = "{literal}", c = "{/literal}", r = !1;
+        e.languages["markup-templating"].buildPlaceholders(t, "soy", d, function(s) {
+          return s === c && (r = !1), r ? !1 : (s === b && (r = !0), !0);
+        });
+      }), e.hooks.add("after-tokenize", function(t) {
+        e.languages["markup-templating"].tokenizePlaceholders(t, "soy");
+      });
+    }(l);
+  }
+  return n;
+}
+export {
+  g as __require
+};

package/dist/es/node_modules/refractor/lang/sparql.mjs

@@ -0,0 +1,24 @@
+import { __require as e } from "./turtle.mjs";
+var A, R;
+function N() {
+  if (R)
+    return A;
+  R = 1;
+  var T = e();
+  A = S, S.displayName = "sparql", S.aliases = ["rq"];
+  function S(E) {
+    E.register(T), E.languages.sparql = E.languages.extend("turtle", {
+      boolean: /\b(?:false|true)\b/i,
+      variable: {
+        pattern: /[?$]\w+/,
+        greedy: !0
+      }
+    }), E.languages.insertBefore("sparql", "punctuation", {
+      keyword: [/\b(?:A|ADD|ALL|AS|ASC|ASK|BNODE|BY|CLEAR|CONSTRUCT|COPY|CREATE|DATA|DEFAULT|DELETE|DESC|DESCRIBE|DISTINCT|DROP|EXISTS|FILTER|FROM|GROUP|HAVING|INSERT|INTO|LIMIT|LOAD|MINUS|MOVE|NAMED|NOT|NOW|OFFSET|OPTIONAL|ORDER|RAND|REDUCED|SELECT|SEPARATOR|SERVICE|SILENT|STRUUID|UNION|USING|UUID|VALUES|WHERE)\b/i, /\b(?:ABS|AVG|BIND|BOUND|CEIL|COALESCE|CONCAT|CONTAINS|COUNT|DATATYPE|DAY|ENCODE_FOR_URI|FLOOR|GROUP_CONCAT|HOURS|IF|IRI|isBLANK|isIRI|isLITERAL|isNUMERIC|isURI|LANG|LANGMATCHES|LCASE|MAX|MD5|MIN|MINUTES|MONTH|REGEX|REPLACE|ROUND|sameTerm|SAMPLE|SECONDS|SHA1|SHA256|SHA384|SHA512|STR|STRAFTER|STRBEFORE|STRDT|STRENDS|STRLANG|STRLEN|STRSTARTS|SUBSTR|SUM|TIMEZONE|TZ|UCASE|URI|YEAR)\b(?=\s*\()/i, /\b(?:BASE|GRAPH|PREFIX)\b/i]
+    }), E.languages.rq = E.languages.sparql;
+  }
+  return A;
+}
+export {
+  N as __require
+};

package/dist/es/node_modules/refractor/lang/splunk-spl.mjs

@@ -0,0 +1,36 @@
+var t, a;
+function o() {
+  if (a)
+    return t;
+  a = 1, t = e, e.displayName = "splunkSpl", e.aliases = [];
+  function e(r) {
+    r.languages["splunk-spl"] = {
+      comment: /`comment\("(?:\\.|[^\\"])*"\)`/,
+      string: {
+        pattern: /"(?:\\.|[^\\"])*"/,
+        greedy: !0
+      },
+      // https://docs.splunk.com/Documentation/Splunk/7.3.0/SearchReference/ListOfSearchCommands
+      keyword: /\b(?:abstract|accum|addcoltotals|addinfo|addtotals|analyzefields|anomalies|anomalousvalue|anomalydetection|append|appendcols|appendcsv|appendlookup|appendpipe|arules|associate|audit|autoregress|bin|bucket|bucketdir|chart|cluster|cofilter|collect|concurrency|contingency|convert|correlate|datamodel|dbinspect|dedup|delete|delta|diff|erex|eval|eventcount|eventstats|extract|fieldformat|fields|fieldsummary|filldown|fillnull|findtypes|folderize|foreach|format|from|gauge|gentimes|geom|geomfilter|geostats|head|highlight|history|iconify|input|inputcsv|inputlookup|iplocation|join|kmeans|kv|kvform|loadjob|localize|localop|lookup|makecontinuous|makemv|makeresults|map|mcollect|metadata|metasearch|meventcollect|mstats|multikv|multisearch|mvcombine|mvexpand|nomv|outlier|outputcsv|outputlookup|outputtext|overlap|pivot|predict|rangemap|rare|regex|relevancy|reltime|rename|replace|rest|return|reverse|rex|rtorder|run|savedsearch|script|scrub|search|searchtxn|selfjoin|sendemail|set|setfields|sichart|sirare|sistats|sitimechart|sitop|sort|spath|stats|strcat|streamstats|table|tags|tail|timechart|timewrap|top|transaction|transpose|trendline|tscollect|tstats|typeahead|typelearner|typer|union|uniq|untable|where|x11|xmlkv|xmlunescape|xpath|xyseries)\b/i,
+      "operator-word": {
+        pattern: /\b(?:and|as|by|not|or|xor)\b/i,
+        alias: "operator"
+      },
+      function: /\b\w+(?=\s*\()/,
+      property: /\b\w+(?=\s*=(?!=))/,
+      date: {
+        // MM/DD/YYYY(:HH:MM:SS)?
+        pattern: /\b\d{1,2}\/\d{1,2}\/\d{1,4}(?:(?::\d{1,2}){3})?\b/,
+        alias: "number"
+      },
+      number: /\b\d+(?:\.\d+)?\b/,
+      boolean: /\b(?:f|false|t|true)\b/i,
+      operator: /[<>=]=?|[-+*/%|]/,
+      punctuation: /[()[\],]/
+    };
+  }
+  return t;
+}
+export {
+  o as __require
+};