@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/python-C9JXUpy2.js

@@ -0,0 +1,94 @@
+import { g as p } from "./index-Sj89RFCY.js";
+function u(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 i, s;
+function d() {
+  if (s) return i;
+  s = 1, i = t, t.displayName = "python", t.aliases = ["py"];
+  function t(e) {
+    e.languages.python = {
+      comment: {
+        pattern: /(^|[^\\])#.*/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      "string-interpolation": {
+        pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+            pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+            lookbehind: !0,
+            inside: {
+              "format-spec": {
+                pattern: /(:)[^:(){}]+(?=\}$)/,
+                lookbehind: !0
+              },
+              "conversion-option": {
+                pattern: /![sra](?=[:}]$)/,
+                alias: "punctuation"
+              },
+              rest: null
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      "triple-quoted-string": {
+        pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+        greedy: !0,
+        alias: "string"
+      },
+      string: {
+        pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+        greedy: !0
+      },
+      function: {
+        pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+        lookbehind: !0
+      },
+      "class-name": {
+        pattern: /(\bclass\s+)\w+/i,
+        lookbehind: !0
+      },
+      decorator: {
+        pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+        lookbehind: !0,
+        alias: ["annotation", "punctuation"],
+        inside: {
+          punctuation: /\./
+        }
+      },
+      keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+      builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+      boolean: /\b(?:False|None|True)\b/,
+      number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+      operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+      punctuation: /[{}[\];(),.:]/
+    }, e.languages.python["string-interpolation"].inside.interpolation.inside.rest = e.languages.python, e.languages.py = e.languages.python;
+  }
+  return i;
+}
+var l = d();
+const c = /* @__PURE__ */ p(l), y = /* @__PURE__ */ u({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  y as p
+};

package/dist/q-Ct9Ut4C4.js

@@ -0,0 +1,83 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function u(e, s) {
+  for (var a = 0; a < s.length; a++) {
+    const r = s[a];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const n = Object.getOwnPropertyDescriptor(r, t);
+          n && Object.defineProperty(e, t, n.get ? n : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var d, i;
+function c() {
+  if (i) return d;
+  i = 1, d = e, e.displayName = "q", e.aliases = [];
+  function e(s) {
+    s.languages.q = {
+      string: /"(?:\\.|[^"\\\r\n])*"/,
+      comment: [
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // When / is following a space (or a right parenthesis, bracket, or brace), it is ignored with the rest of the line.
+        {
+          pattern: /([\t )\]}])\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.
+        // A / on a line by itself begins a multiline comment which is terminated by the next \ on a line by itself.
+        // If a / is not matched by a \, the multiline comment is unterminated and continues to end of file.
+        // The / and \ must be the first char on the line, but may be followed by any amount of whitespace.
+        {
+          pattern: /(^|\r?\n|\r)\/[\t ]*(?:(?:\r?\n|\r)(?:.*(?:\r?\n|\r(?!\n)))*?(?:\\(?=[\t ]*(?:\r?\n|\r))|$)|\S.*)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // A \ on a line by itself with no preceding matching / will comment to end of file.
+        {
+          pattern: /^\\[\t ]*(?:\r?\n|\r)[\s\S]+/m,
+          greedy: !0
+        },
+        {
+          pattern: /^#!.+/m,
+          greedy: !0
+        }
+      ],
+      symbol: /`(?::\S+|[\w.]*)/,
+      datetime: {
+        pattern: /0N[mdzuvt]|0W[dtz]|\d{4}\.\d\d(?:m|\.\d\d(?:T(?:\d\d(?::\d\d(?::\d\d(?:[.:]\d\d\d)?)?)?)?)?[dz]?)|\d\d:\d\d(?::\d\d(?:[.:]\d\d\d)?)?[uvt]?/,
+        alias: "number"
+      },
+      // The negative look-ahead prevents bad highlighting
+      // of verbs 0: and 1:
+      number: /\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\da-fA-F]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?[hjfeb]?)/,
+      keyword: /\\\w+\b|\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\b/,
+      adverb: {
+        pattern: /['\/\\]:?|\beach\b/,
+        alias: "function"
+      },
+      verb: {
+        pattern: /(?:\B\.\B|\b[01]:|<[=>]?|>=?|[:+\-*%,!?~=|$&#@^]):?|\b_\b:?/,
+        alias: "operator"
+      },
+      punctuation: /[(){}\[\];.]/
+    };
+  }
+  return d;
+}
+var o = c();
+const m = /* @__PURE__ */ l(o), v = /* @__PURE__ */ u({
+  __proto__: null,
+  default: m
+}, [o]);
+export {
+  v as q
+};

package/dist/qml-DubjWeE3.js

@@ -0,0 +1,103 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function l(r, o) {
+  for (var t = 0; t < o.length; t++) {
+    const n = o[t];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const a in n)
+        if (a !== "default" && !(a in r)) {
+          const e = Object.getOwnPropertyDescriptor(n, a);
+          e && Object.defineProperty(r, a, e.get ? e : {
+            enumerable: !0,
+            get: () => n[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var s, p;
+function g() {
+  if (p) return s;
+  p = 1, s = r, r.displayName = "qml", r.aliases = [];
+  function r(o) {
+    (function(t) {
+      for (var n = /"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*'/.source, a = /\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))*\*\//.source, e = /(?:[^\\()[\]{}"'/]|<string>|\/(?![*/])|<comment>|\(<expr>*\)|\[<expr>*\]|\{<expr>*\}|\\[\s\S])/.source.replace(/<string>/g, function() {
+        return n;
+      }).replace(/<comment>/g, function() {
+        return a;
+      }), u = 0; u < 2; u++)
+        e = e.replace(/<expr>/g, function() {
+          return e;
+        });
+      e = e.replace(/<expr>/g, "[^\\s\\S]"), t.languages.qml = {
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: !0
+        },
+        "javascript-function": {
+          pattern: RegExp(
+            /((?:^|;)[ \t]*)function\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*\(<js>*\)\s*\{<js>*\}/.source.replace(
+              /<js>/g,
+              function() {
+                return e;
+              }
+            ),
+            "m"
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "language-javascript",
+          inside: t.languages.javascript
+        },
+        "class-name": {
+          pattern: /((?:^|[:;])[ \t]*)(?!\d)\w+(?=[ \t]*\{|[ \t]+on\b)/m,
+          lookbehind: !0
+        },
+        property: [
+          {
+            pattern: /((?:^|[;{])[ \t]*)(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+            lookbehind: !0
+          },
+          {
+            pattern: /((?:^|[;{])[ \t]*)property[ \t]+(?!\d)\w+(?:\.\w+)*[ \t]+(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+            lookbehind: !0,
+            inside: {
+              keyword: /^property/,
+              property: /\w+(?:\.\w+)*/
+            }
+          }
+        ],
+        "javascript-expression": {
+          pattern: RegExp(
+            /(:[ \t]*)(?![\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(
+              /<js>/g,
+              function() {
+                return e;
+              }
+            ),
+            "m"
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "language-javascript",
+          inside: t.languages.javascript
+        },
+        string: {
+          pattern: /"(?:\\.|[^\\"\r\n])*"/,
+          greedy: !0
+        },
+        keyword: /\b(?:as|import|on)\b/,
+        punctuation: /[{}[\]:;,]/
+      };
+    })(o);
+  }
+  return s;
+}
+var i = g();
+const m = /* @__PURE__ */ c(i), f = /* @__PURE__ */ l({
+  __proto__: null,
+  default: m
+}, [i]);
+export {
+  f as q
+};

package/dist/qore-CDjxpVlT.js

@@ -0,0 +1,53 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function d(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const o in r)
+        if (o !== "default" && !(o in e)) {
+          const a = Object.getOwnPropertyDescriptor(r, o);
+          a && Object.defineProperty(e, o, a.get ? a : {
+            enumerable: !0,
+            get: () => r[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, s;
+function f() {
+  if (s) return i;
+  s = 1, i = e, e.displayName = "qore", e.aliases = [];
+  function e(t) {
+    t.languages.qore = t.languages.extend("clike", {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
+        lookbehind: !0
+      },
+      // Overridden to allow unescaped multi-line strings
+      string: {
+        pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+        greedy: !0
+      },
+      keyword: /\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\b/,
+      boolean: /\b(?:false|true)\b/i,
+      function: /\$?\b(?!\d)\w+(?=\()/,
+      number: /\b(?:0b[01]+|0x(?:[\da-f]*\.)?[\da-fp\-]+|(?:\d+(?:\.\d+)?|\.\d+)(?:e\d+)?[df]|(?:\d+(?:\.\d+)?|\.\d+))\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
+        lookbehind: !0
+      },
+      variable: /\$(?!\d)\w+\b/
+    });
+  }
+  return i;
+}
+var l = f();
+const u = /* @__PURE__ */ c(l), p = /* @__PURE__ */ d({
+  __proto__: null,
+  default: u
+}, [l]);
+export {
+  p as q
+};

package/dist/qsharp-Dyr5mrma.js

@@ -0,0 +1,128 @@
+import { g as m } from "./index-Sj89RFCY.js";
+function k(a, o) {
+  for (var n = 0; n < o.length; n++) {
+    const t = o[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const e in t)
+        if (e !== "default" && !(e in a)) {
+          const s = Object.getOwnPropertyDescriptor(t, e);
+          s && Object.defineProperty(a, e, s.get ? s : {
+            enumerable: !0,
+            get: () => t[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var l, h;
+function x() {
+  if (h) return l;
+  h = 1, l = a, a.displayName = "qsharp", a.aliases = ["qs"];
+  function a(o) {
+    (function(n) {
+      function t(r, i) {
+        return r.replace(/<<(\d+)>>/g, function(u, w) {
+          return "(?:" + i[+w] + ")";
+        });
+      }
+      function e(r, i, u) {
+        return RegExp(t(r, i), "");
+      }
+      function s(r, i) {
+        for (var u = 0; u < i; u++)
+          r = r.replace(/<<self>>/g, function() {
+            return "(?:" + r + ")";
+          });
+        return r.replace(/<<self>>/g, "[^\\s\\S]");
+      }
+      var p = {
+        // keywords which represent a return or variable type
+        type: "Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero",
+        // all other keywords
+        other: "Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within"
+      };
+      function q(r) {
+        return "\\b(?:" + r.trim().replace(/ /g, "|") + ")\\b";
+      }
+      var g = RegExp(
+        q(p.type + " " + p.other)
+      ), v = /\b[A-Za-z_]\w*\b/.source, c = t(/<<0>>(?:\s*\.\s*<<0>>)*/.source, [v]), d = {
+        keyword: g,
+        punctuation: /[<>()?,.:[\]]/
+      }, f = /"(?:\\.|[^\\"])*"/.source;
+      n.languages.qsharp = n.languages.extend("clike", {
+        comment: /\/\/.*/,
+        string: [
+          {
+            pattern: e(/(^|[^$\\])<<0>>/.source, [f]),
+            lookbehind: !0,
+            greedy: !0
+          }
+        ],
+        "class-name": [
+          {
+            // open Microsoft.Quantum.Canon;
+            // open Microsoft.Quantum.Canon as CN;
+            pattern: e(/(\b(?:as|open)\s+)<<0>>(?=\s*(?:;|as\b))/.source, [
+              c
+            ]),
+            lookbehind: !0,
+            inside: d
+          },
+          {
+            // namespace Quantum.App1;
+            pattern: e(/(\bnamespace\s+)<<0>>(?=\s*\{)/.source, [c]),
+            lookbehind: !0,
+            inside: d
+          }
+        ],
+        keyword: g,
+        number: /(?:\b0(?:x[\da-f]+|b[01]+|o[0-7]+)|(?:\B\.\d+|\b\d+(?:\.\d*)?)(?:e[-+]?\d+)?)l?\b/i,
+        operator: /\band=|\bor=|\band\b|\bnot\b|\bor\b|<[-=]|[-=]>|>>>=?|<<<=?|\^\^\^=?|\|\|\|=?|&&&=?|w\/=?|~~~|[*\/+\-^=!%]=?/,
+        punctuation: /::|[{}[\];(),.:]/
+      }), n.languages.insertBefore("qsharp", "number", {
+        range: {
+          pattern: /\.\./,
+          alias: "operator"
+        }
+      });
+      var b = s(
+        t(/\{(?:[^"{}]|<<0>>|<<self>>)*\}/.source, [f]),
+        2
+      );
+      n.languages.insertBefore("qsharp", "string", {
+        "interpolation-string": {
+          pattern: e(/\$"(?:\\.|<<0>>|[^\\"{])*"/.source, [b]),
+          greedy: !0,
+          inside: {
+            interpolation: {
+              pattern: e(/((?:^|[^\\])(?:\\\\)*)<<0>>/.source, [
+                b
+              ]),
+              lookbehind: !0,
+              inside: {
+                punctuation: /^\{|\}$/,
+                expression: {
+                  pattern: /[\s\S]+/,
+                  alias: "language-qsharp",
+                  inside: n.languages.qsharp
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      });
+    })(o), o.languages.qs = o.languages.qsharp;
+  }
+  return l;
+}
+var y = x();
+const j = /* @__PURE__ */ m(y), _ = /* @__PURE__ */ k({
+  __proto__: null,
+  default: j
+}, [y]);
+export {
+  _ as q
+};

package/dist/r-B4F2KUJL.js

@@ -0,0 +1,55 @@
+import { g as f } from "./index-Sj89RFCY.js";
+function u(e, o) {
+  for (var a = 0; a < o.length; a++) {
+    const r = o[a];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const n = Object.getOwnPropertyDescriptor(r, t);
+          n && Object.defineProperty(e, t, n.get ? n : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, s;
+function c() {
+  if (s) return i;
+  s = 1, i = e, e.displayName = "r", e.aliases = [];
+  function e(o) {
+    o.languages.r = {
+      comment: /#.*/,
+      string: {
+        pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      "percent-operator": {
+        // Includes user-defined operators
+        // and %%, %*%, %/%, %in%, %o%, %x%
+        pattern: /%[^%\s]*%/,
+        alias: "operator"
+      },
+      boolean: /\b(?:FALSE|TRUE)\b/,
+      ellipsis: /\.\.(?:\.|\d+)/,
+      number: [
+        /\b(?:Inf|NaN)\b/,
+        /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/
+      ],
+      keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+      operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
+      punctuation: /[(){}\[\],;]/
+    };
+  }
+  return i;
+}
+var p = c();
+const l = /* @__PURE__ */ f(p), d = /* @__PURE__ */ u({
+  __proto__: null,
+  default: l
+}, [p]);
+export {
+  d as r
+};

package/dist/racket-D5k9UW-t.js

@@ -0,0 +1,50 @@
+import { g as u } from "./index-Sj89RFCY.js";
+import { r as l } from "./scheme-B-TWMKN_.js";
+function f(t, r) {
+  for (var e = 0; e < r.length; e++) {
+    const a = r[e];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const n in a)
+        if (n !== "default" && !(n in t)) {
+          const o = Object.getOwnPropertyDescriptor(a, n);
+          o && Object.defineProperty(t, n, o.get ? o : {
+            enumerable: !0,
+            get: () => a[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var c, s;
+function i() {
+  if (s) return c;
+  s = 1;
+  var t = l();
+  c = r, r.displayName = "racket", r.aliases = ["rkt"];
+  function r(e) {
+    e.register(t), e.languages.racket = e.languages.extend("scheme", {
+      "lambda-parameter": {
+        // the racket lambda syntax is a lot more complex, so we won't even attempt to capture it.
+        // this will just prevent false positives of the `function` pattern
+        pattern: /([(\[]lambda\s+[(\[])[^()\[\]'\s]+/,
+        lookbehind: !0
+      }
+    }), e.languages.insertBefore("racket", "string", {
+      lang: {
+        pattern: /^#lang.+/m,
+        greedy: !0,
+        alias: "keyword"
+      }
+    }), e.languages.rkt = e.languages.racket;
+  }
+  return c;
+}
+var g = i();
+const k = /* @__PURE__ */ u(g), m = /* @__PURE__ */ f({
+  __proto__: null,
+  default: k
+}, [g]);
+export {
+  m as r
+};

package/dist/reason-Cs82zJO7.js

@@ -0,0 +1,54 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function u(e, r) {
+  for (var a = 0; a < r.length; a++) {
+    const t = r[a];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const n in t)
+        if (n !== "default" && !(n in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, n);
+          o && Object.defineProperty(e, n, o.get ? o : {
+            enumerable: !0,
+            get: () => t[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var s, l;
+function f() {
+  if (l) return s;
+  l = 1, s = e, e.displayName = "reason", e.aliases = [];
+  function e(r) {
+    r.languages.reason = r.languages.extend("clike", {
+      string: {
+        pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
+        greedy: !0
+      },
+      // 'class-name' must be matched *after* 'constructor' defined below
+      "class-name": /\b[A-Z]\w*/,
+      keyword: /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/,
+      operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/
+    }), r.languages.insertBefore("reason", "class-name", {
+      char: {
+        pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/,
+        greedy: !0
+      },
+      // Negative look-ahead prevents from matching things like String.capitalize
+      constructor: /\b[A-Z]\w*\b(?!\s*\.)/,
+      label: {
+        pattern: /\b[a-z]\w*(?=::)/,
+        alias: "symbol"
+      }
+    }), delete r.languages.reason.function;
+  }
+  return s;
+}
+var i = f();
+const d = /* @__PURE__ */ c(i), p = /* @__PURE__ */ u({
+  __proto__: null,
+  default: d
+}, [i]);
+export {
+  p as r
+};