@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/unrealscript-Cb8322pT.js

@@ -0,0 +1,71 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function p(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const a in r)
+        if (a !== "default" && !(a in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, a);
+          o && Object.defineProperty(e, a, o.get ? o : {
+            enumerable: !0,
+            get: () => r[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, s;
+function u() {
+  if (s) return i;
+  s = 1, i = e, e.displayName = "unrealscript", e.aliases = ["uc", "uscript"];
+  function e(t) {
+    t.languages.unrealscript = {
+      comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      category: {
+        pattern: /(\b(?:(?:autoexpand|hide|show)categories|var)\s*\()[^()]+(?=\))/,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "property"
+      },
+      metadata: {
+        pattern: /(\w\s*)<\s*\w+\s*=[^<>|=\r\n]+(?:\|\s*\w+\s*=[^<>|=\r\n]+)*>/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          property: /\b\w+(?=\s*=)/,
+          operator: /=/,
+          punctuation: /[<>|]/
+        }
+      },
+      macro: {
+        pattern: /`\w+/,
+        alias: "property"
+      },
+      "class-name": {
+        pattern: /(\b(?:class|enum|extends|interface|state(?:\(\))?|struct|within)\s+)\w+/,
+        lookbehind: !0
+      },
+      keyword: /\b(?:abstract|actor|array|auto|autoexpandcategories|bool|break|byte|case|class|classgroup|client|coerce|collapsecategories|config|const|continue|default|defaultproperties|delegate|dependson|deprecated|do|dontcollapsecategories|editconst|editinlinenew|else|enum|event|exec|export|extends|final|float|for|forcescriptorder|foreach|function|goto|guid|hidecategories|hidedropdown|if|ignores|implements|inherits|input|int|interface|iterator|latent|local|material|name|native|nativereplication|noexport|nontransient|noteditinlinenew|notplaceable|operator|optional|out|pawn|perobjectconfig|perobjectlocalized|placeable|postoperator|preoperator|private|protected|reliable|replication|return|server|showcategories|simulated|singular|state|static|string|struct|structdefault|structdefaultproperties|switch|texture|transient|travel|unreliable|until|var|vector|while|within)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      boolean: /\b(?:false|true)\b/,
+      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      // https://docs.unrealengine.com/udk/Three/UnrealScriptExpressions.html
+      operator: />>|<<|--|\+\+|\*\*|[-+*/~!=<>$@]=?|&&?|\|\|?|\^\^?|[?:%]|\b(?:ClockwiseFrom|Cross|Dot)\b/,
+      punctuation: /[()[\]{};,.]/
+    }, t.languages.uc = t.languages.uscript = t.languages.unrealscript;
+  }
+  return i;
+}
+var c = u();
+const d = /* @__PURE__ */ l(c), f = /* @__PURE__ */ p({
+  __proto__: null,
+  default: d
+}, [c]);
+export {
+  f as u
+};

package/dist/uorazor-CHv0VHYn.js

@@ -0,0 +1,81 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function d(e, a) {
+  for (var s = 0; s < a.length; s++) {
+    const t = a[s];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, r);
+          o && Object.defineProperty(e, r, o.get ? o : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var n, i;
+function m() {
+  if (i) return n;
+  i = 1, n = e, e.displayName = "uorazor", e.aliases = [];
+  function e(a) {
+    a.languages.uorazor = {
+      "comment-hash": {
+        pattern: /#.*/,
+        alias: "comment",
+        greedy: !0
+      },
+      "comment-slash": {
+        pattern: /\/\/.*/,
+        alias: "comment",
+        greedy: !0
+      },
+      string: {
+        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        inside: {
+          punctuation: /^['"]|['"]$/
+        },
+        greedy: !0
+      },
+      "source-layers": {
+        pattern: /\b(?:arms|backpack|blue|bracelet|cancel|clear|cloak|criminal|earrings|enemy|facialhair|friend|friendly|gloves|gray|grey|ground|hair|head|innerlegs|innertorso|innocent|lefthand|middletorso|murderer|neck|nonfriendly|onehandedsecondary|outerlegs|outertorso|pants|red|righthand|ring|self|shirt|shoes|talisman|waist)\b/i,
+        alias: "function"
+      },
+      "source-commands": {
+        pattern: /\b(?:alliance|attack|cast|clearall|clearignore|clearjournal|clearlist|clearsysmsg|createlist|createtimer|dclick|dclicktype|dclickvar|dress|dressconfig|drop|droprelloc|emote|getlabel|guild|gumpclose|gumpresponse|hotkey|ignore|lasttarget|lift|lifttype|menu|menuresponse|msg|org|organize|organizer|overhead|pause|poplist|potion|promptresponse|pushlist|removelist|removetimer|rename|restock|say|scav|scavenger|script|setability|setlasttarget|setskill|settimer|setvar|sysmsg|target|targetloc|targetrelloc|targettype|undress|unignore|unsetvar|useobject|useonce|useskill|usetype|virtue|wait|waitforgump|waitformenu|waitforprompt|waitforstat|waitforsysmsg|waitfortarget|walk|wfsysmsg|wft|whisper|yell)\b/,
+        alias: "function"
+      },
+      "tag-name": {
+        pattern: /(^\{%-?\s*)\w+/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      delimiter: {
+        pattern: /^\{[{%]-?|-?[%}]\}$/,
+        alias: "punctuation"
+      },
+      function: /\b(?:atlist|close|closest|count|counter|counttype|dead|dex|diffhits|diffmana|diffstam|diffweight|find|findbuff|finddebuff|findlayer|findtype|findtypelist|followers|gumpexists|hidden|hits|hp|hue|human|humanoid|ingump|inlist|insysmessage|insysmsg|int|invul|lhandempty|list|listexists|mana|maxhits|maxhp|maxmana|maxstam|maxweight|monster|mounted|name|next|noto|paralyzed|poisoned|position|prev|previous|queued|rand|random|rhandempty|skill|stam|str|targetexists|timer|timerexists|varexist|warmode|weight)\b/,
+      keyword: /\b(?:and|as|break|continue|else|elseif|endfor|endif|endwhile|for|if|loop|not|or|replay|stop|while)\b/,
+      boolean: /\b(?:false|null|true)\b/,
+      number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+      operator: [
+        {
+          pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
+          lookbehind: !0
+        },
+        /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/
+      ],
+      punctuation: /[()\[\]{}:.,]/
+    };
+  }
+  return n;
+}
+var l = m();
+const c = /* @__PURE__ */ u(l), f = /* @__PURE__ */ d({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  f as u
+};

package/dist/uri-ci9M926F.js

@@ -0,0 +1,116 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function p(e, r) {
+  for (var a = 0; a < r.length; a++) {
+    const t = r[a];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const i in t)
+        if (i !== "default" && !(i in e)) {
+          const n = Object.getOwnPropertyDescriptor(t, i);
+          n && Object.defineProperty(e, i, n.get ? n : {
+            enumerable: !0,
+            get: () => t[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var s, u;
+function l() {
+  if (u) return s;
+  u = 1, s = e, e.displayName = "uri", e.aliases = ["url"];
+  function e(r) {
+    r.languages.uri = {
+      scheme: {
+        pattern: /^[a-z][a-z0-9+.-]*:/im,
+        greedy: !0,
+        inside: {
+          "scheme-delimiter": /:$/
+        }
+      },
+      fragment: {
+        pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
+        inside: {
+          "fragment-delimiter": /^#/
+        }
+      },
+      query: {
+        pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
+        inside: {
+          "query-delimiter": {
+            pattern: /^\?/,
+            greedy: !0
+          },
+          "pair-delimiter": /[&;]/,
+          pair: {
+            pattern: /^[^=][\s\S]*/,
+            inside: {
+              key: /^[^=]+/,
+              value: {
+                pattern: /(^=)[\s\S]+/,
+                lookbehind: !0
+              }
+            }
+          }
+        }
+      },
+      authority: {
+        pattern: RegExp(
+          /^\/\//.source + // [ userinfo "@" ]
+          /(?:[\w\-.~!$&'()*+,;=%:]*@)?/.source + // host
+          ("(?:" + // IP-literal
+          /\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\.[\w\-.~!$&'()*+,;=]+)\]/.source + "|" + // IPv4address or registered name
+          /[\w\-.~!$&'()*+,;=%]*/.source + ")") + // [ ":" port ]
+          /(?::\d*)?/.source,
+          "m"
+        ),
+        inside: {
+          "authority-delimiter": /^\/\//,
+          "user-info-segment": {
+            pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
+            inside: {
+              "user-info-delimiter": /@$/,
+              "user-info": /^[\w\-.~!$&'()*+,;=%:]+/
+            }
+          },
+          "port-segment": {
+            pattern: /:\d*$/,
+            inside: {
+              "port-delimiter": /^:/,
+              port: /^\d+/
+            }
+          },
+          host: {
+            pattern: /[\s\S]+/,
+            inside: {
+              "ip-literal": {
+                pattern: /^\[[\s\S]+\]$/,
+                inside: {
+                  "ip-literal-delimiter": /^\[|\]$/,
+                  "ipv-future": /^v[\s\S]+/,
+                  "ipv6-address": /^[\s\S]+/
+                }
+              },
+              "ipv4-address": /^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
+            }
+          }
+        }
+      },
+      path: {
+        pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
+        inside: {
+          "path-separator": /\//
+        }
+      }
+    }, r.languages.url = r.languages.uri;
+  }
+  return s;
+}
+var o = l();
+const f = /* @__PURE__ */ d(o), m = /* @__PURE__ */ p({
+  __proto__: null,
+  default: f
+}, [o]);
+export {
+  m as u
+};

package/dist/v-DL4z_kNT.js

@@ -0,0 +1,106 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function c(n, a) {
+  for (var e = 0; e < a.length; e++) {
+    const t = a[e];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in n)) {
+          const i = Object.getOwnPropertyDescriptor(t, r);
+          i && Object.defineProperty(n, r, i.get ? i : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var o, s;
+function f() {
+  if (s) return o;
+  s = 1, o = n, n.displayName = "v", n.aliases = [];
+  function n(a) {
+    (function(e) {
+      var t = {
+        pattern: /[\s\S]+/,
+        inside: null
+      };
+      e.languages.v = e.languages.extend("clike", {
+        string: {
+          pattern: /r?(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+          alias: "quoted-string",
+          greedy: !0,
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[^{}]*\}|\w+(?:\.\w+(?:\([^\(\)]*\))?|\[[^\[\]]+\])*)/,
+              lookbehind: !0,
+              inside: {
+                "interpolation-variable": {
+                  pattern: /^\$\w[\s\S]*$/,
+                  alias: "variable"
+                },
+                "interpolation-punctuation": {
+                  pattern: /^\$\{|\}$/,
+                  alias: "punctuation"
+                },
+                "interpolation-expression": t
+              }
+            }
+          }
+        },
+        "class-name": {
+          pattern: /(\b(?:enum|interface|struct|type)\s+)(?:C\.)?\w+/,
+          lookbehind: !0
+        },
+        keyword: /(?:\b(?:__global|as|asm|assert|atomic|break|chan|const|continue|defer|else|embed|enum|fn|for|go(?:to)?|if|import|in|interface|is|lock|match|module|mut|none|or|pub|return|rlock|select|shared|sizeof|static|struct|type(?:of)?|union|unsafe)|\$(?:else|for|if)|#(?:flag|include))\b/,
+        number: /\b(?:0x[a-f\d]+(?:_[a-f\d]+)*|0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?)\b/i,
+        operator: /~|\?|[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\.?/,
+        builtin: /\b(?:any(?:_float|_int)?|bool|byte(?:ptr)?|charptr|f(?:32|64)|i(?:8|16|64|128|nt)|rune|size_t|string|u(?:16|32|64|128)|voidptr)\b/
+      }), t.inside = e.languages.v, e.languages.insertBefore("v", "string", {
+        char: {
+          pattern: /`(?:\\`|\\?[^`]{1,2})`/,
+          // using {1,2} instead of `u` flag for compatibility
+          alias: "rune"
+        }
+      }), e.languages.insertBefore("v", "operator", {
+        attribute: {
+          pattern: /(^[\t ]*)\[(?:deprecated|direct_array_access|flag|inline|live|ref_only|typedef|unsafe_fn|windows_stdcall)\]/m,
+          lookbehind: !0,
+          alias: "annotation",
+          inside: {
+            punctuation: /[\[\]]/,
+            keyword: /\w+/
+          }
+        },
+        generic: {
+          pattern: /<\w+>(?=\s*[\)\{])/,
+          inside: {
+            punctuation: /[<>]/,
+            "class-name": /\w+/
+          }
+        }
+      }), e.languages.insertBefore("v", "function", {
+        "generic-function": {
+          // e.g. foo<T>( ...
+          pattern: /\b\w+\s*<\w+>(?=\()/,
+          inside: {
+            function: /^\w+/,
+            generic: {
+              pattern: /<\w+>/,
+              inside: e.languages.v.generic.inside
+            }
+          }
+        }
+      });
+    })(a);
+  }
+  return o;
+}
+var u = f();
+const p = /* @__PURE__ */ l(u), g = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [u]);
+export {
+  g as v
+};

package/dist/vala-CPIzd5en.js

@@ -0,0 +1,113 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function c(t, e) {
+  for (var r = 0; r < e.length; r++) {
+    const a = e[r];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const n in a)
+        if (n !== "default" && !(n in t)) {
+          const i = Object.getOwnPropertyDescriptor(a, n);
+          i && Object.defineProperty(t, n, i.get ? i : {
+            enumerable: !0,
+            get: () => a[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var s, o;
+function d() {
+  if (o) return s;
+  o = 1, s = t, t.displayName = "vala", t.aliases = [];
+  function t(e) {
+    e.languages.vala = e.languages.extend("clike", {
+      // Classes copied from prism-csharp
+      "class-name": [
+        {
+          // (Foo bar, Bar baz)
+          pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=(?:\?\s+|\*?\s+\*?)\w)/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        {
+          // [Foo]
+          pattern: /(\[)[A-Z]\w*(?:\.\w+)*\b/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        {
+          // class Foo : Bar
+          pattern: /(\b(?:class|interface)\s+[A-Z]\w*(?:\.\w+)*\s*:\s*)[A-Z]\w*(?:\.\w+)*\b/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        {
+          // class Foo
+          pattern: /((?:\b(?:class|enum|interface|new|struct)\s+)|(?:catch\s+\())[A-Z]\w*(?:\.\w+)*\b/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\./
+          }
+        }
+      ],
+      keyword: /\b(?:abstract|as|assert|async|base|bool|break|case|catch|char|class|const|construct|continue|default|delegate|delete|do|double|dynamic|else|ensures|enum|errordomain|extern|finally|float|for|foreach|get|if|in|inline|int|int16|int32|int64|int8|interface|internal|is|lock|long|namespace|new|null|out|override|owned|params|private|protected|public|ref|requires|return|set|short|signal|sizeof|size_t|ssize_t|static|string|struct|switch|this|throw|throws|try|typeof|uchar|uint|uint16|uint32|uint64|uint8|ulong|unichar|unowned|ushort|using|value|var|virtual|void|volatile|weak|while|yield)\b/i,
+      function: /\b\w+(?=\s*\()/,
+      number: /(?:\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?:f|u?l?)?/i,
+      operator: /\+\+|--|&&|\|\||<<=?|>>=?|=>|->|~|[+\-*\/%&^|=!<>]=?|\?\??|\.\.\./,
+      punctuation: /[{}[\];(),.:]/,
+      constant: /\b[A-Z0-9_]+\b/
+    }), e.languages.insertBefore("vala", "string", {
+      "raw-string": {
+        pattern: /"""[\s\S]*?"""/,
+        greedy: !0,
+        alias: "string"
+      },
+      "template-string": {
+        pattern: /@"[\s\S]*?"/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /\$(?:\([^)]*\)|[a-zA-Z]\w*)/,
+            inside: {
+              delimiter: {
+                pattern: /^\$\(?|\)$/,
+                alias: "punctuation"
+              },
+              rest: e.languages.vala
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    }), e.languages.insertBefore("vala", "keyword", {
+      regex: {
+        pattern: /\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[imsx]{0,4}(?=\s*(?:$|[\r\n,.;})\]]))/,
+        greedy: !0,
+        inside: {
+          "regex-source": {
+            pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+            lookbehind: !0,
+            alias: "language-regex",
+            inside: e.languages.regex
+          },
+          "regex-delimiter": /^\//,
+          "regex-flags": /^[a-z]+$/
+        }
+      }
+    });
+  }
+  return s;
+}
+var l = d();
+const g = /* @__PURE__ */ u(l), f = /* @__PURE__ */ c({
+  __proto__: null,
+  default: g
+}, [l]);
+export {
+  f as v
+};

package/dist/vbnet-BoCvq106.js

@@ -0,0 +1,26 @@
+import { g as s } from "./index-Sj89RFCY.js";
+import { r as i } from "./vbnet-ClfmYufs.js";
+function c(r, a) {
+  for (var o = 0; o < a.length; o++) {
+    const e = a[o];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in r)) {
+          const n = Object.getOwnPropertyDescriptor(e, t);
+          n && Object.defineProperty(r, t, n.get ? n : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var f = i();
+const p = /* @__PURE__ */ s(f), g = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [f]);
+export {
+  g as v
+};

package/dist/vbnet-ClfmYufs.js

@@ -0,0 +1,36 @@
+import { r as S } from "./basic-CBrKUqQp.js";
+var R, O;
+function L() {
+  if (O) return R;
+  O = 1;
+  var N = S();
+  R = E, E.displayName = "vbnet", E.aliases = [];
+  function E(T) {
+    T.register(N), T.languages.vbnet = T.languages.extend("basic", {
+      comment: [
+        {
+          pattern: /(?:!|REM\b).+/i,
+          inside: {
+            keyword: /^REM/i
+          }
+        },
+        {
+          pattern: /(^|[^\\:])'.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      string: {
+        pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
+      punctuation: /[,;:(){}]/
+    });
+  }
+  return R;
+}
+export {
+  L as r
+};

package/dist/velocity-CBXhMUrK.js

@@ -0,0 +1,99 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function s(r, a) {
+  for (var t = 0; t < a.length; t++) {
+    const e = a[t];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const n in e)
+        if (n !== "default" && !(n in r)) {
+          const o = Object.getOwnPropertyDescriptor(e, n);
+          o && Object.defineProperty(r, n, o.get ? o : {
+            enumerable: !0,
+            get: () => e[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var i, u;
+function b() {
+  if (u) return i;
+  u = 1, i = r, r.displayName = "velocity", r.aliases = [];
+  function r(a) {
+    (function(t) {
+      t.languages.velocity = t.languages.extend("markup", {});
+      var e = {
+        variable: {
+          pattern: /(^|[^\\](?:\\\\)*)\$!?(?:[a-z][\w-]*(?:\([^)]*\))?(?:\.[a-z][\w-]*(?:\([^)]*\))?|\[[^\]]+\])*|\{[^}]+\})/i,
+          lookbehind: !0,
+          inside: {}
+          // See below
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: !0
+        },
+        number: /\b\d+\b/,
+        boolean: /\b(?:false|true)\b/,
+        operator: /[=!<>]=?|[+*/%-]|&&|\|\||\.\.|\b(?:eq|g[et]|l[et]|n(?:e|ot))\b/,
+        punctuation: /[(){}[\]:,.]/
+      };
+      e.variable.inside = {
+        string: e.string,
+        function: {
+          pattern: /([^\w-])[a-z][\w-]*(?=\()/,
+          lookbehind: !0
+        },
+        number: e.number,
+        boolean: e.boolean,
+        punctuation: e.punctuation
+      }, t.languages.insertBefore("velocity", "comment", {
+        unparsed: {
+          pattern: /(^|[^\\])#\[\[[\s\S]*?\]\]#/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            punctuation: /^#\[\[|\]\]#$/
+          }
+        },
+        "velocity-comment": [
+          {
+            pattern: /(^|[^\\])#\*[\s\S]*?\*#/,
+            lookbehind: !0,
+            greedy: !0,
+            alias: "comment"
+          },
+          {
+            pattern: /(^|[^\\])##.*/,
+            lookbehind: !0,
+            greedy: !0,
+            alias: "comment"
+          }
+        ],
+        directive: {
+          pattern: /(^|[^\\](?:\\\\)*)#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})(?:\s*\((?:[^()]|\([^()]*\))*\))?/i,
+          lookbehind: !0,
+          inside: {
+            keyword: {
+              pattern: /^#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})|\bin\b/,
+              inside: {
+                punctuation: /[{}]/
+              }
+            },
+            rest: e
+          }
+        },
+        variable: e.variable
+      }), t.languages.velocity.tag.inside["attr-value"].inside.rest = t.languages.velocity;
+    })(a);
+  }
+  return i;
+}
+var l = b();
+const d = /* @__PURE__ */ c(l), p = /* @__PURE__ */ s({
+  __proto__: null,
+  default: d
+}, [l]);
+export {
+  p as v
+};