@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/graphql-b5aI1fau.js

@@ -0,0 +1,154 @@
+import { g as Z } from "./index-Sj89RFCY.js";
+function $(i, s) {
+  for (var p = 0; p < s.length; p++) {
+    const n = s[p];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const a in n)
+        if (a !== "default" && !(a in i)) {
+          const t = Object.getOwnPropertyDescriptor(n, a);
+          t && Object.defineProperty(i, a, t.get ? t : {
+            enumerable: !0,
+            get: () => n[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(i, Symbol.toStringTag, { value: "Module" }));
+}
+var h, k;
+function j() {
+  if (k) return h;
+  k = 1, h = i, i.displayName = "graphql", i.aliases = [];
+  function i(s) {
+    s.languages.graphql = {
+      comment: /#.*/,
+      description: {
+        pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
+        greedy: !0,
+        alias: "string",
+        inside: {
+          "language-markdown": {
+            pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
+            lookbehind: !0,
+            inside: s.languages.markdown
+          }
+        }
+      },
+      string: {
+        pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
+        greedy: !0
+      },
+      number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      boolean: /\b(?:false|true)\b/,
+      variable: /\$[a-z_]\w*/i,
+      directive: {
+        pattern: /@[a-z_]\w*/i,
+        alias: "function"
+      },
+      "attr-name": {
+        pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
+        greedy: !0
+      },
+      "atom-input": {
+        pattern: /\b[A-Z]\w*Input\b/,
+        alias: "class-name"
+      },
+      scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+      constant: /\b[A-Z][A-Z_\d]*\b/,
+      "class-name": {
+        pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+        lookbehind: !0
+      },
+      fragment: {
+        pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
+        lookbehind: !0,
+        alias: "function"
+      },
+      "definition-mutation": {
+        pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
+        lookbehind: !0,
+        alias: "function"
+      },
+      "definition-query": {
+        pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
+        lookbehind: !0,
+        alias: "function"
+      },
+      keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+      operator: /[!=|&]|\.{3}/,
+      "property-query": /\w+(?=\s*\()/,
+      object: /\w+(?=\s*\{)/,
+      punctuation: /[!(){}\[\]:=,]/,
+      property: /\w+/
+    }, s.hooks.add("after-tokenize", function(n) {
+      if (n.language !== "graphql")
+        return;
+      var a = n.tokens.filter(function(r) {
+        return typeof r != "string" && r.type !== "comment" && r.type !== "scalar";
+      }), t = 0;
+      function l(r) {
+        return a[t + r];
+      }
+      function v(r, o) {
+        o = o || 0;
+        for (var e = 0; e < r.length; e++) {
+          var u = l(e + o);
+          if (!u || u.type !== r[e])
+            return !1;
+        }
+        return !0;
+      }
+      function q(r, o) {
+        for (var e = 1, u = t; u < a.length; u++) {
+          var A = a[u], m = A.content;
+          if (A.type === "punctuation" && typeof m == "string") {
+            if (r.test(m))
+              e++;
+            else if (o.test(m) && (e--, e === 0))
+              return u;
+          }
+        }
+        return -1;
+      }
+      function f(r, o) {
+        var e = r.alias;
+        e ? Array.isArray(e) || (r.alias = e = [e]) : r.alias = e = [], e.push(o);
+      }
+      for (; t < a.length; ) {
+        var w = a[t++];
+        if (w.type === "keyword" && w.content === "mutation") {
+          var c = [];
+          if (v(["definition-mutation", "punctuation"]) && l(1).content === "(") {
+            t += 2;
+            var g = q(/^\($/, /^\)$/);
+            if (g === -1)
+              continue;
+            for (; t < g; t++) {
+              var b = l(0);
+              b.type === "variable" && (f(b, "variable-input"), c.push(b.content));
+            }
+            t = g + 1;
+          }
+          if (v(["punctuation", "property-query"]) && l(0).content === "{" && (t++, f(l(0), "property-mutation"), c.length > 0)) {
+            var _ = q(/^\{$/, /^\}$/);
+            if (_ === -1)
+              continue;
+            for (var d = t; d < _; d++) {
+              var y = a[d];
+              y.type === "variable" && c.indexOf(y.content) >= 0 && f(y, "variable-input");
+            }
+          }
+        }
+      }
+    });
+  }
+  return h;
+}
+var z = j();
+const x = /* @__PURE__ */ Z(z), I = /* @__PURE__ */ $({
+  __proto__: null,
+  default: x
+}, [z]);
+export {
+  I as g
+};

package/dist/groovy-C4Zi8h0f.js

@@ -0,0 +1,82 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function c(n, t) {
+  for (var e = 0; e < t.length; e++) {
+    const o = t[e];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const r in o)
+        if (r !== "default" && !(r in n)) {
+          const a = Object.getOwnPropertyDescriptor(o, r);
+          a && Object.defineProperty(n, r, a.get ? a : {
+            enumerable: !0,
+            get: () => o[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var i, s;
+function l() {
+  if (s) return i;
+  s = 1, i = n, n.displayName = "groovy", n.aliases = [];
+  function n(t) {
+    t.languages.groovy = t.languages.extend("clike", {
+      string: [
+        {
+          // https://groovy-lang.org/syntax.html#_dollar_slashy_string
+          pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+          greedy: !0
+        },
+        {
+          // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
+          // simple division (see JS regex), so find a fix maybe?
+          pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: !0
+        }
+      ],
+      keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
+      number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+        lookbehind: !0
+      },
+      punctuation: /\.+|[{}[\];(),:$]/
+    }), t.languages.insertBefore("groovy", "string", {
+      shebang: {
+        pattern: /#!.+/,
+        alias: "comment"
+      }
+    }), t.languages.insertBefore("groovy", "punctuation", {
+      "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
+    }), t.languages.insertBefore("groovy", "function", {
+      annotation: {
+        pattern: /(^|[^.])@\w+/,
+        lookbehind: !0,
+        alias: "punctuation"
+      }
+    }), t.hooks.add("wrap", function(e) {
+      if (e.language === "groovy" && e.type === "string") {
+        var o = e.content.value[0];
+        if (o != "'") {
+          var r = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
+          o === "$" && (r = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/), e.content.value = e.content.value.replace(/&lt;/g, "<").replace(/&amp;/g, "&"), e.content = t.highlight(e.content.value, {
+            expression: {
+              pattern: r,
+              lookbehind: !0,
+              inside: t.languages.groovy
+            }
+          }), e.classes.push(o === "/" ? "regex" : "gstring");
+        }
+      }
+    });
+  }
+  return i;
+}
+var g = l();
+const p = /* @__PURE__ */ u(g), d = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [g]);
+export {
+  d as g
+};

package/dist/haml-B9jL77OH.js

@@ -0,0 +1,172 @@
+import { g as c } from "./index-Sj89RFCY.js";
+import { r as f } from "./ruby-BQlisu6i.js";
+function b(l, n) {
+  for (var a = 0; a < n.length; a++) {
+    const e = n[a];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const r in e)
+        if (r !== "default" && !(r in l)) {
+          const i = Object.getOwnPropertyDescriptor(e, r);
+          i && Object.defineProperty(l, r, i.get ? i : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(l, Symbol.toStringTag, { value: "Module" }));
+}
+var u, g;
+function m() {
+  if (g) return u;
+  g = 1;
+  var l = f();
+  u = n, n.displayName = "haml", n.aliases = [];
+  function n(a) {
+    a.register(l), function(e) {
+      e.languages.haml = {
+        // Multiline stuff should appear before the rest
+        "multiline-comment": {
+          pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
+          lookbehind: !0,
+          alias: "comment"
+        },
+        "multiline-code": [
+          {
+            pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
+            lookbehind: !0,
+            inside: e.languages.ruby
+          },
+          {
+            pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
+            lookbehind: !0,
+            inside: e.languages.ruby
+          }
+        ],
+        // See at the end of the file for known filters
+        filter: {
+          pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
+          lookbehind: !0,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "symbol"
+            }
+          }
+        },
+        markup: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
+          lookbehind: !0,
+          inside: e.languages.markup
+        },
+        doctype: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
+          lookbehind: !0
+        },
+        tag: {
+          // Allows for one nested group of braces
+          pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
+          lookbehind: !0,
+          inside: {
+            attributes: [
+              {
+                // Lookbehind tries to prevent interpolations from breaking it all
+                // Allows for one nested group of braces
+                pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
+                lookbehind: !0,
+                inside: e.languages.ruby
+              },
+              {
+                pattern: /\([^)]+\)/,
+                inside: {
+                  "attr-value": {
+                    pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
+                    lookbehind: !0
+                  },
+                  "attr-name": /[\w:-]+(?=\s*!?=|\s*[,)])/,
+                  punctuation: /[=(),]/
+                }
+              },
+              {
+                pattern: /\[[^\]]+\]/,
+                inside: e.languages.ruby
+              }
+            ],
+            punctuation: /[<>]/
+          }
+        },
+        code: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        },
+        // Interpolations in plain text
+        interpolation: {
+          pattern: /#\{[^}]+\}/,
+          inside: {
+            delimiter: {
+              pattern: /^#\{|\}$/,
+              alias: "punctuation"
+            },
+            ruby: {
+              pattern: /[\s\S]+/,
+              inside: e.languages.ruby
+            }
+          }
+        },
+        punctuation: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
+          lookbehind: !0
+        }
+      };
+      for (var r = "((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+", i = [
+        "css",
+        {
+          filter: "coffee",
+          language: "coffeescript"
+        },
+        "erb",
+        "javascript",
+        "less",
+        "markdown",
+        "ruby",
+        "scss",
+        "textile"
+      ], s = {}, o = 0, d = i.length; o < d; o++) {
+        var t = i[o];
+        t = typeof t == "string" ? {
+          filter: t,
+          language: t
+        } : t, e.languages[t.language] && (s["filter-" + t.filter] = {
+          pattern: RegExp(
+            r.replace("{{filter_name}}", function() {
+              return t.filter;
+            })
+          ),
+          lookbehind: !0,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "symbol"
+            },
+            text: {
+              pattern: /[\s\S]+/,
+              alias: [t.language, "language-" + t.language],
+              inside: e.languages[t.language]
+            }
+          }
+        });
+      }
+      e.languages.insertBefore("haml", "filter", s);
+    }(a);
+  }
+  return u;
+}
+var p = m();
+const h = /* @__PURE__ */ c(p), v = /* @__PURE__ */ b({
+  __proto__: null,
+  default: h
+}, [p]);
+export {
+  v as h
+};

package/dist/handlebars-BWszzUxR.js

@@ -0,0 +1,74 @@
+import { g as i } from "./index-Sj89RFCY.js";
+import { r as d } from "./markup-templating-CVTxtFGH.js";
+function b(n, r) {
+  for (var t = 0; t < r.length; t++) {
+    const e = r[t];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const a in e)
+        if (a !== "default" && !(a in n)) {
+          const s = Object.getOwnPropertyDescriptor(e, a);
+          s && Object.defineProperty(n, a, s.get ? s : {
+            enumerable: !0,
+            get: () => e[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var o, l;
+function g() {
+  if (l) return o;
+  l = 1;
+  var n = d();
+  o = r, r.displayName = "handlebars", r.aliases = ["hbs"];
+  function r(t) {
+    t.register(n), function(e) {
+      e.languages.handlebars = {
+        comment: /\{\{![\s\S]*?\}\}/,
+        delimiter: {
+          pattern: /^\{\{\{?|\}\}\}?$/,
+          alias: "punctuation"
+        },
+        string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+        boolean: /\b(?:false|true)\b/,
+        block: {
+          pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        brackets: {
+          pattern: /\[[^\]]+\]/,
+          inside: {
+            punctuation: /\[|\]/,
+            variable: /[\s\S]+/
+          }
+        },
+        punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+        variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
+      }, e.hooks.add("before-tokenize", function(a) {
+        var s = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;
+        e.languages["markup-templating"].buildPlaceholders(
+          a,
+          "handlebars",
+          s
+        );
+      }), e.hooks.add("after-tokenize", function(a) {
+        e.languages["markup-templating"].tokenizePlaceholders(
+          a,
+          "handlebars"
+        );
+      }), e.languages.hbs = e.languages.handlebars;
+    }(t);
+  }
+  return o;
+}
+var u = g();
+const p = /* @__PURE__ */ i(u), h = /* @__PURE__ */ b({
+  __proto__: null,
+  default: p
+}, [u]);
+export {
+  h
+};

package/dist/haskell-BrIvnyGx.js

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

package/dist/haskell-DR6jYji5.js

@@ -0,0 +1,75 @@
+var t, i;
+function r() {
+  if (i) return t;
+  i = 1, t = e, e.displayName = "haskell", e.aliases = ["hs"];
+  function e(a) {
+    a.languages.haskell = {
+      comment: {
+        pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
+        lookbehind: !0
+      },
+      char: {
+        pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
+        alias: "string"
+      },
+      string: {
+        pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
+        greedy: !0
+      },
+      keyword: /\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
+      "import-statement": {
+        // The imported or hidden names are not included in this import
+        // statement. This is because we want to highlight those exactly like
+        // we do for the names in the program.
+        pattern: /(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+        lookbehind: !0,
+        inside: {
+          keyword: /\b(?:as|hiding|import|qualified)\b/,
+          punctuation: /\./
+        }
+      },
+      // These are builtin variables only. Constructors are highlighted later as a constant.
+      builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
+      // decimal integers and floating point numbers | octal integers | hexadecimal integers
+      number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
+      operator: [
+        {
+          // infix operator
+          pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
+          greedy: !0
+        },
+        {
+          // function composition
+          pattern: /(\s)\.(?=\s)/,
+          lookbehind: !0
+        },
+        // Most of this is needed because of the meaning of a single '.'.
+        // If it stands alone freely, it is the function composition.
+        // It may also be a separator between a module name and an identifier => no
+        // operator. If it comes together with other special characters it is an
+        // operator too.
+        //
+        // This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
+        /[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
+      ],
+      // In Haskell, nearly everything is a variable, do not highlight these.
+      hvariable: {
+        pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      constant: {
+        pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      punctuation: /[{}[\];(),.:]/
+    }, a.languages.hs = a.languages.haskell;
+  }
+  return t;
+}
+export {
+  r
+};

package/dist/haxe-DUpmVd5P.js

@@ -0,0 +1,105 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function p(t, e) {
+  for (var n = 0; n < e.length; n++) {
+    const a = e[n];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const r in a)
+        if (r !== "default" && !(r in t)) {
+          const i = Object.getOwnPropertyDescriptor(a, r);
+          i && Object.defineProperty(t, r, i.get ? i : {
+            enumerable: !0,
+            get: () => a[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var s, o;
+function g() {
+  if (o) return s;
+  o = 1, s = t, t.displayName = "haxe", t.aliases = [];
+  function t(e) {
+    e.languages.haxe = e.languages.extend("clike", {
+      string: {
+        // Strings can be multi-line
+        pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+        greedy: !0
+      },
+      "class-name": [
+        {
+          pattern: /(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
+          lookbehind: !0
+        },
+        // based on naming convention
+        /\b[A-Z]\w*/
+      ],
+      // The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
+      keyword: /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
+      function: {
+        pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
+        greedy: !0
+      },
+      operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
+    }), e.languages.insertBefore("haxe", "string", {
+      "string-interpolation": {
+        pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
+            lookbehind: !0,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^\$\{?|\}$/,
+                alias: "punctuation"
+              },
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: e.languages.haxe
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    }), e.languages.insertBefore("haxe", "class-name", {
+      regex: {
+        pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
+        greedy: !0,
+        inside: {
+          "regex-flags": /\b[a-z]+$/,
+          "regex-source": {
+            pattern: /^(~\/)[\s\S]+(?=\/$)/,
+            lookbehind: !0,
+            alias: "language-regex",
+            inside: e.languages.regex
+          },
+          "regex-delimiter": /^~\/|\/$/
+        }
+      }
+    }), e.languages.insertBefore("haxe", "keyword", {
+      preprocessor: {
+        pattern: /#(?:else|elseif|end|if)\b.*/,
+        alias: "property"
+      },
+      metadata: {
+        pattern: /@:?[\w.]+/,
+        alias: "symbol"
+      },
+      reification: {
+        pattern: /\$(?:\w+|(?=\{))/,
+        alias: "important"
+      }
+    });
+  }
+  return s;
+}
+var l = g();
+const c = /* @__PURE__ */ u(l), f = /* @__PURE__ */ p({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  f as h
+};