@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/false-B2gdCewG.js

@@ -0,0 +1,60 @@
+import { g as i } from "./index-Sj89RFCY.js";
+function u(e, n) {
+  for (var r = 0; r < n.length; r++) {
+    const t = n[r];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const a in t)
+        if (a !== "default" && !(a in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, a);
+          o && Object.defineProperty(e, a, o.get ? o : {
+            enumerable: !0,
+            get: () => t[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var s, l;
+function c() {
+  if (l) return s;
+  l = 1, s = e, e.displayName = "$false", e.aliases = [];
+  function e(n) {
+    (function(r) {
+      r.languages.false = {
+        comment: {
+          pattern: /\{[^}]*\}/
+        },
+        string: {
+          pattern: /"[^"]*"/,
+          greedy: !0
+        },
+        "character-code": {
+          pattern: /'(?:[^\r]|\r\n?)/,
+          alias: "number"
+        },
+        "assembler-code": {
+          pattern: /\d+`/,
+          alias: "important"
+        },
+        number: /\d+/,
+        operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
+        punctuation: /\[|\]/,
+        variable: /[a-z]/,
+        "non-standard": {
+          pattern: /[()<BDO®]/,
+          alias: "bold"
+        }
+      };
+    })(n);
+  }
+  return s;
+}
+var f = c();
+const p = /* @__PURE__ */ i(f), g = /* @__PURE__ */ u({
+  __proto__: null,
+  default: p
+}, [f]);
+export {
+  g as _
+};

package/dist/firestore-security-rules-xige90gq.js

@@ -0,0 +1,67 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function c(e, r) {
+  for (var i = 0; i < r.length; i++) {
+    const t = r[i];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const u in t)
+        if (u !== "default" && !(u in e)) {
+          const s = Object.getOwnPropertyDescriptor(t, u);
+          s && Object.defineProperty(e, u, s.get ? s : {
+            enumerable: !0,
+            get: () => t[u]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, n;
+function f() {
+  if (n) return o;
+  n = 1, o = e, e.displayName = "firestoreSecurityRules", e.aliases = [];
+  function e(r) {
+    r.languages["firestore-security-rules"] = r.languages.extend(
+      "clike",
+      {
+        comment: /\/\/.*/,
+        keyword: /\b(?:allow|function|if|match|null|return|rules_version|service)\b/,
+        operator: /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/
+      }
+    ), delete r.languages["firestore-security-rules"]["class-name"], r.languages.insertBefore("firestore-security-rules", "keyword", {
+      path: {
+        pattern: /(^|[\s(),])(?:\/(?:[\w\xA0-\uFFFF]+|\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)))+/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          variable: {
+            pattern: /\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)/,
+            inside: {
+              operator: /=/,
+              keyword: /\*\*/,
+              punctuation: /[.$(){}]/
+            }
+          },
+          punctuation: /\//
+        }
+      },
+      method: {
+        // to make the pattern shorter, the actual method names are omitted
+        pattern: /(\ballow\s+)[a-z]+(?:\s*,\s*[a-z]+)*(?=\s*[:;])/,
+        lookbehind: !0,
+        alias: "builtin",
+        inside: {
+          punctuation: /,/
+        }
+      }
+    });
+  }
+  return o;
+}
+var a = f();
+const y = /* @__PURE__ */ l(a), p = /* @__PURE__ */ c({
+  __proto__: null,
+  default: y
+}, [a]);
+export {
+  p as f
+};

package/dist/flow-bpD4sbhm.js

@@ -0,0 +1,57 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function g(a, r) {
+  for (var e = 0; e < r.length; e++) {
+    const t = r[e];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const o in t)
+        if (o !== "default" && !(o in a)) {
+          const n = Object.getOwnPropertyDescriptor(t, o);
+          n && Object.defineProperty(a, o, n.get ? n : {
+            enumerable: !0,
+            get: () => t[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var l, u;
+function i() {
+  if (u) return l;
+  u = 1, l = a, a.displayName = "flow", a.aliases = [];
+  function a(r) {
+    (function(e) {
+      e.languages.flow = e.languages.extend("javascript", {}), e.languages.insertBefore("flow", "keyword", {
+        type: [
+          {
+            pattern: /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|any|mixed|null|void)\b/,
+            alias: "tag"
+          }
+        ]
+      }), e.languages.flow["function-variable"].pattern = /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i, delete e.languages.flow.parameter, e.languages.insertBefore("flow", "operator", {
+        "flow-punctuation": {
+          pattern: /\{\||\|\}/,
+          alias: "punctuation"
+        }
+      }), Array.isArray(e.languages.flow.keyword) || (e.languages.flow.keyword = [e.languages.flow.keyword]), e.languages.flow.keyword.unshift(
+        {
+          pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/,
+          lookbehind: !0
+        }
+      );
+    })(r);
+  }
+  return l;
+}
+var f = i();
+const p = /* @__PURE__ */ s(f), c = /* @__PURE__ */ g({
+  __proto__: null,
+  default: p
+}, [f]);
+export {
+  c as f
+};

package/dist/fortran-B4crZzNk.js

@@ -0,0 +1,73 @@
+import { g as A } from "./index-Sj89RFCY.js";
+function O(E, t) {
+  for (var n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const e in r)
+        if (e !== "default" && !(e in E)) {
+          const o = Object.getOwnPropertyDescriptor(r, e);
+          o && Object.defineProperty(E, e, o.get ? o : {
+            enumerable: !0,
+            get: () => r[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(E, Symbol.toStringTag, { value: "Module" }));
+}
+var T, N;
+function a() {
+  if (N) return T;
+  N = 1, T = E, E.displayName = "fortran", E.aliases = [];
+  function E(t) {
+    t.languages.fortran = {
+      "quoted-number": {
+        pattern: /[BOZ](['"])[A-F0-9]+\1/i,
+        alias: "number"
+      },
+      string: {
+        pattern: /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
+        inside: {
+          comment: {
+            pattern: /(&(?:\r\n?|\n)\s*)!.*/,
+            lookbehind: !0
+          }
+        }
+      },
+      comment: {
+        pattern: /!.*/,
+        greedy: !0
+      },
+      boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
+      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
+      keyword: [
+        // Types
+        /\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i,
+        // END statements
+        /\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i,
+        // Statements
+        /\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i,
+        // Others
+        /\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
+      ],
+      operator: [
+        /\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
+        {
+          // Use lookbehind to prevent confusion with (/ /)
+          pattern: /(^|(?!\().)\/(?!\))/,
+          lookbehind: !0
+        }
+      ],
+      punctuation: /\(\/|\/\)|[(),;:&]/
+    };
+  }
+  return T;
+}
+var L = a();
+const I = /* @__PURE__ */ A(L), i = /* @__PURE__ */ O({
+  __proto__: null,
+  default: I
+}, [L]);
+export {
+  i as f
+};

package/dist/fsharp-BnvVN9HC.js

@@ -0,0 +1,105 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function p(t, e) {
+  for (var a = 0; a < e.length; a++) {
+    const r = e[a];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const n in r)
+        if (n !== "default" && !(n in t)) {
+          const o = Object.getOwnPropertyDescriptor(r, n);
+          o && Object.defineProperty(t, n, o.get ? o : {
+            enumerable: !0,
+            get: () => r[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var s, i;
+function d() {
+  if (i) return s;
+  i = 1, s = t, t.displayName = "fsharp", t.aliases = [];
+  function t(e) {
+    e.languages.fsharp = e.languages.extend("clike", {
+      comment: [
+        {
+          pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      string: {
+        pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\b(?:exception|inherit|interface|new|of|type)\s+|\w\s*:\s*|\s:\??>\s*)[.\w]+\b(?:\s*(?:->|\*)\s*[.\w]+\b)*(?!\s*[:.])/,
+        lookbehind: !0,
+        inside: {
+          operator: /->|\*/,
+          punctuation: /\./
+        }
+      },
+      keyword: /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/,
+      number: [
+        /\b0x[\da-fA-F]+(?:LF|lf|un)?\b/,
+        /\b0b[01]+(?:uy|y)?\b/,
+        /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
+        /\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
+      ],
+      operator: /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
+    }), e.languages.insertBefore("fsharp", "keyword", {
+      preprocessor: {
+        pattern: /(^[\t ]*)#.*/m,
+        lookbehind: !0,
+        alias: "property",
+        inside: {
+          directive: {
+            pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/,
+            lookbehind: !0,
+            alias: "keyword"
+          }
+        }
+      }
+    }), e.languages.insertBefore("fsharp", "punctuation", {
+      "computation-expression": {
+        pattern: /\b[_a-z]\w*(?=\s*\{)/i,
+        alias: "keyword"
+      }
+    }), e.languages.insertBefore("fsharp", "string", {
+      annotation: {
+        pattern: /\[<.+?>\]/,
+        greedy: !0,
+        inside: {
+          punctuation: /^\[<|>\]$/,
+          "class-name": {
+            pattern: /^\w+$|(^|;\s*)[A-Z]\w*(?=\()/,
+            lookbehind: !0
+          },
+          "annotation-content": {
+            pattern: /[\s\S]+/,
+            inside: e.languages.fsharp
+          }
+        }
+      },
+      char: {
+        pattern: /'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
+        greedy: !0
+      }
+    });
+  }
+  return s;
+}
+var l = d();
+const c = /* @__PURE__ */ u(l), b = /* @__PURE__ */ p({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  b as f
+};

package/dist/ftl-BoWDVp6s.js

@@ -0,0 +1,146 @@
+import { g as f } from "./index-Sj89RFCY.js";
+import { r as g } from "./markup-templating-CVTxtFGH.js";
+function d(o, r) {
+  for (var n = 0; n < r.length; n++) {
+    const t = r[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const e in t)
+        if (e !== "default" && !(e in o)) {
+          const a = Object.getOwnPropertyDescriptor(t, e);
+          a && Object.defineProperty(o, e, a.get ? a : {
+            enumerable: !0,
+            get: () => t[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(o, Symbol.toStringTag, { value: "Module" }));
+}
+var u, p;
+function b() {
+  if (p) return u;
+  p = 1;
+  var o = g();
+  u = r, r.displayName = "ftl", r.aliases = [];
+  function r(n) {
+    n.register(o), function(t) {
+      for (var e = /[^<()"']|\((?:<expr>)*\)|<(?!#--)|<#--(?:[^-]|-(?!->))*-->|"(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'/.source, a = 0; a < 2; a++)
+        e = e.replace(/<expr>/g, function() {
+          return e;
+        });
+      e = e.replace(/<expr>/g, /[^\s\S]/.source);
+      var i = {
+        comment: /<#--[\s\S]*?-->/,
+        string: [
+          {
+            // raw string
+            pattern: /\br("|')(?:(?!\1)[^\\]|\\.)*\1/,
+            greedy: !0
+          },
+          {
+            pattern: RegExp(
+              /("|')(?:(?!\1|\$\{)[^\\]|\\.|\$\{(?:(?!\})(?:<expr>))*\})*\1/.source.replace(
+                /<expr>/g,
+                function() {
+                  return e;
+                }
+              )
+            ),
+            greedy: !0,
+            inside: {
+              interpolation: {
+                pattern: RegExp(
+                  /((?:^|[^\\])(?:\\\\)*)\$\{(?:(?!\})(?:<expr>))*\}/.source.replace(
+                    /<expr>/g,
+                    function() {
+                      return e;
+                    }
+                  )
+                ),
+                lookbehind: !0,
+                inside: {
+                  "interpolation-punctuation": {
+                    pattern: /^\$\{|\}$/,
+                    alias: "punctuation"
+                  },
+                  rest: null
+                }
+              }
+            }
+          }
+        ],
+        keyword: /\b(?:as)\b/,
+        boolean: /\b(?:false|true)\b/,
+        "builtin-function": {
+          pattern: /((?:^|[^?])\?\s*)\w+/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        function: /\b\w+(?=\s*\()/,
+        number: /\b\d+(?:\.\d+)?\b/,
+        operator: /\.\.[<*!]?|->|--|\+\+|&&|\|\||\?{1,2}|[-+*/%!=<>]=?|\b(?:gt|gte|lt|lte)\b/,
+        punctuation: /[,;.:()[\]{}]/
+      };
+      i.string[1].inside.interpolation.inside.rest = i, t.languages.ftl = {
+        "ftl-comment": {
+          // the pattern is shortened to be more efficient
+          pattern: /^<#--[\s\S]*/,
+          alias: "comment"
+        },
+        "ftl-directive": {
+          pattern: /^<[\s\S]+>$/,
+          inside: {
+            directive: {
+              pattern: /(^<\/?)[#@][a-z]\w*/i,
+              lookbehind: !0,
+              alias: "keyword"
+            },
+            punctuation: /^<\/?|\/?>$/,
+            content: {
+              pattern: /\s*\S[\s\S]*/,
+              alias: "ftl",
+              inside: i
+            }
+          }
+        },
+        "ftl-interpolation": {
+          pattern: /^\$\{[\s\S]*\}$/,
+          inside: {
+            punctuation: /^\$\{|\}$/,
+            content: {
+              pattern: /\s*\S[\s\S]*/,
+              alias: "ftl",
+              inside: i
+            }
+          }
+        }
+      }, t.hooks.add("before-tokenize", function(l) {
+        var c = RegExp(
+          /<#--[\s\S]*?-->|<\/?[#@][a-zA-Z](?:<expr>)*?>|\$\{(?:<expr>)*?\}/.source.replace(
+            /<expr>/g,
+            function() {
+              return e;
+            }
+          ),
+          "gi"
+        );
+        t.languages["markup-templating"].buildPlaceholders(
+          l,
+          "ftl",
+          c
+        );
+      }), t.hooks.add("after-tokenize", function(l) {
+        t.languages["markup-templating"].tokenizePlaceholders(l, "ftl");
+      });
+    }(n);
+  }
+  return u;
+}
+var s = b();
+const m = /* @__PURE__ */ f(s), $ = /* @__PURE__ */ d({
+  __proto__: null,
+  default: m
+}, [s]);
+export {
+  $ as f
+};

package/dist/gap-DxJ82BxA.js

@@ -0,0 +1,78 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function l(e, t) {
+  for (var a = 0; a < t.length; a++) {
+    const n = t[a];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const r in n)
+        if (r !== "default" && !(r in e)) {
+          const o = Object.getOwnPropertyDescriptor(n, r);
+          o && Object.defineProperty(e, r, o.get ? o : {
+            enumerable: !0,
+            get: () => n[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, u;
+function d() {
+  if (u) return i;
+  u = 1, i = e, e.displayName = "gap", e.aliases = [];
+  function e(t) {
+    t.languages.gap = {
+      shell: {
+        pattern: /^gap>[\s\S]*?(?=^gap>|$(?![\s\S]))/m,
+        greedy: !0,
+        inside: {
+          gap: {
+            pattern: /^(gap>).+(?:(?:\r(?:\n|(?!\n))|\n)>.*)*/,
+            lookbehind: !0,
+            inside: null
+            // see below
+          },
+          punctuation: /^gap>/
+        }
+      },
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      string: {
+        pattern: /(^|[^\\'"])(?:'(?:[^\r\n\\']|\\.){1,10}'|"(?:[^\r\n\\"]|\\.)*"(?!")|"""[\s\S]*?""")/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          continuation: {
+            pattern: /([\r\n])>/,
+            lookbehind: !0,
+            alias: "punctuation"
+          }
+        }
+      },
+      keyword: /\b(?:Assert|Info|IsBound|QUIT|TryNextMethod|Unbind|and|atomic|break|continue|do|elif|else|end|fi|for|function|if|in|local|mod|not|od|or|quit|readonly|readwrite|rec|repeat|return|then|until|while)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      number: {
+        pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+        lookbehind: !0
+      },
+      continuation: {
+        pattern: /([\r\n])>/,
+        lookbehind: !0,
+        alias: "punctuation"
+      },
+      operator: /->|[-+*/^~=!]|<>|[<>]=?|:=|\.\./,
+      punctuation: /[()[\]{},;.:]/
+    }, t.languages.gap.shell.inside.gap.inside = t.languages.gap;
+  }
+  return i;
+}
+var p = d();
+const g = /* @__PURE__ */ s(p), f = /* @__PURE__ */ l({
+  __proto__: null,
+  default: g
+}, [p]);
+export {
+  f as g
+};

package/dist/gcode-u6kBGAFD.js

@@ -0,0 +1,49 @@
+import { g } from "./index-Sj89RFCY.js";
+function i(e, o) {
+  for (var n = 0; n < o.length; n++) {
+    const r = o[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const a = Object.getOwnPropertyDescriptor(r, t);
+          a && Object.defineProperty(e, t, a.get ? a : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var c, d;
+function s() {
+  if (d) return c;
+  d = 1, c = e, e.displayName = "gcode", e.aliases = [];
+  function e(o) {
+    o.languages.gcode = {
+      comment: /;.*|\B\(.*?\)\B/,
+      string: {
+        pattern: /"(?:""|[^"])*"/,
+        greedy: !0
+      },
+      keyword: /\b[GM]\d+(?:\.\d+)?\b/,
+      property: /\b[A-Z]/,
+      checksum: {
+        pattern: /(\*)\d+/,
+        lookbehind: !0,
+        alias: "number"
+      },
+      // T0:0:0
+      punctuation: /[:*]/
+    };
+  }
+  return c;
+}
+var u = s();
+const f = /* @__PURE__ */ g(u), l = /* @__PURE__ */ i({
+  __proto__: null,
+  default: f
+}, [u]);
+export {
+  l as g
+};

package/dist/gdscript-DvuFm0WL.js

@@ -0,0 +1,60 @@
+import { g as p } from "./index-Sj89RFCY.js";
+function d(e, s) {
+  for (var a = 0; a < s.length; a++) {
+    const t = s[a];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const n = Object.getOwnPropertyDescriptor(t, r);
+          n && Object.defineProperty(e, r, n.get ? n : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, i;
+function l() {
+  if (i) return o;
+  i = 1, o = e, e.displayName = "gdscript", e.aliases = [];
+  function e(s) {
+    s.languages.gdscript = {
+      comment: /#.*/,
+      string: {
+        pattern: /@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/,
+        greedy: !0
+      },
+      "class-name": {
+        // class_name Foo, extends Bar, class InnerClass
+        // export(int) var baz, export(int, 0) var i
+        // as Node
+        // const FOO: int = 9, var bar: bool = true
+        // func add(reference: Item, amount: int) -> Item:
+        pattern: /(^(?:class|class_name|extends)[ \t]+|^export\([ \t]*|\bas[ \t]+|(?:\b(?:const|var)[ \t]|[,(])[ \t]*\w+[ \t]*:[ \t]*|->[ \t]*)[a-zA-Z_]\w*/m,
+        lookbehind: !0
+      },
+      keyword: /\b(?:and|as|assert|break|breakpoint|class|class_name|const|continue|elif|else|enum|export|extends|for|func|if|in|is|master|mastersync|match|not|null|onready|or|pass|preload|puppet|puppetsync|remote|remotesync|return|self|setget|signal|static|tool|var|while|yield)\b/,
+      function: /\b[a-z_]\w*(?=[ \t]*\()/i,
+      variable: /\$\w+/,
+      number: [
+        /\b0b[01_]+\b|\b0x[\da-fA-F_]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.[\d_]+)(?:e[+-]?[\d_]+)?\b/,
+        /\b(?:INF|NAN|PI|TAU)\b/
+      ],
+      constant: /\b[A-Z][A-Z_\d]*\b/,
+      boolean: /\b(?:false|true)\b/,
+      operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/,
+      punctuation: /[.:,;()[\]{}]/
+    };
+  }
+  return o;
+}
+var c = l();
+const u = /* @__PURE__ */ p(c), f = /* @__PURE__ */ d({
+  __proto__: null,
+  default: u
+}, [c]);
+export {
+  f as g
+};