@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/cpp-Bh1PKWEj.js

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

package/dist/cpp-C0j-5811.js

@@ -0,0 +1,115 @@
+import { r as c } from "./c-b2c4WJSm.js";
+var n, s;
+function p() {
+  if (s) return n;
+  s = 1;
+  var o = c();
+  n = t, t.displayName = "cpp", t.aliases = [];
+  function t(a) {
+    a.register(o), function(e) {
+      var r = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, i = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
+        /<keyword>/g,
+        function() {
+          return r.source;
+        }
+      );
+      e.languages.cpp = e.languages.extend("c", {
+        "class-name": [
+          {
+            pattern: RegExp(
+              /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
+                /<keyword>/g,
+                function() {
+                  return r.source;
+                }
+              )
+            ),
+            lookbehind: !0
+          },
+          // This is intended to capture the class name of method implementations like:
+          //   void foo::bar() const {}
+          // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+          // it starts with an uppercase letter. This approximation should give decent results.
+          /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
+          // This will capture the class name before destructors like:
+          //   Foo::~Foo() {}
+          /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
+          // This also intends to capture the class name of method implementations but here the class has template
+          // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+          /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+        ],
+        keyword: r,
+        number: {
+          pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
+          greedy: !0
+        },
+        operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+        boolean: /\b(?:false|true)\b/
+      }), e.languages.insertBefore("cpp", "string", {
+        module: {
+          // https://en.cppreference.com/w/cpp/language/modules
+          pattern: RegExp(
+            /(\b(?:import|module)\s+)/.source + "(?:" + // header-name
+            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + // module name or partition or both
+            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
+              /<mod-name>/g,
+              function() {
+                return i;
+              }
+            ) + ")"
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            string: /^[<"][\s\S]+/,
+            operator: /:/,
+            punctuation: /\./
+          }
+        },
+        "raw-string": {
+          pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+          alias: "string",
+          greedy: !0
+        }
+      }), e.languages.insertBefore("cpp", "keyword", {
+        "generic-function": {
+          pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+          inside: {
+            function: /^\w+/,
+            generic: {
+              pattern: /<[\s\S]+/,
+              alias: "class-name",
+              inside: e.languages.cpp
+            }
+          }
+        }
+      }), e.languages.insertBefore("cpp", "operator", {
+        "double-colon": {
+          pattern: /::/,
+          alias: "punctuation"
+        }
+      }), e.languages.insertBefore("cpp", "class-name", {
+        // the base clause is an optional list of parent classes
+        // https://en.cppreference.com/w/cpp/language/class
+        "base-clause": {
+          pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: e.languages.extend("cpp", {})
+        }
+      }), e.languages.insertBefore(
+        "inside",
+        "double-colon",
+        {
+          // All untokenized words that are not namespaces should be class names
+          "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
+        },
+        e.languages.cpp["base-clause"]
+      );
+    }(a);
+  }
+  return n;
+}
+export {
+  p as r
+};

package/dist/crystal-ByWjq0Om.js

@@ -0,0 +1,87 @@
+import { g as l } from "./index-Sj89RFCY.js";
+import { r as c } from "./ruby-BQlisu6i.js";
+function d(a, t) {
+  for (var r = 0; r < t.length; r++) {
+    const e = t[r];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const n in e)
+        if (n !== "default" && !(n in a)) {
+          const s = Object.getOwnPropertyDescriptor(e, n);
+          s && Object.defineProperty(a, n, s.get ? s : {
+            enumerable: !0,
+            get: () => e[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var i, o;
+function f() {
+  if (o) return i;
+  o = 1;
+  var a = c();
+  i = t, t.displayName = "crystal", t.aliases = [];
+  function t(r) {
+    r.register(a), function(e) {
+      e.languages.crystal = e.languages.extend("ruby", {
+        keyword: [
+          /\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/,
+          {
+            pattern: /(\.\s*)(?:is_a|responds_to)\?/,
+            lookbehind: !0
+          }
+        ],
+        number: /\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,
+        operator: [/->/, e.languages.ruby.operator],
+        punctuation: /[(){}[\].,;\\]/
+      }), e.languages.insertBefore("crystal", "string-literal", {
+        attribute: {
+          pattern: /@\[.*?\]/,
+          inside: {
+            delimiter: {
+              pattern: /^@\[|\]$/,
+              alias: "punctuation"
+            },
+            attribute: {
+              pattern: /^(\s*)\w+/,
+              lookbehind: !0,
+              alias: "class-name"
+            },
+            args: {
+              pattern: /\S(?:[\s\S]*\S)?/,
+              inside: e.languages.crystal
+            }
+          }
+        },
+        expansion: {
+          pattern: /\{(?:\{.*?\}|%.*?%)\}/,
+          inside: {
+            content: {
+              pattern: /^(\{.)[\s\S]+(?=.\}$)/,
+              lookbehind: !0,
+              inside: e.languages.crystal
+            },
+            delimiter: {
+              pattern: /^\{[\{%]|[\}%]\}$/,
+              alias: "operator"
+            }
+          }
+        },
+        char: {
+          pattern: /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,
+          greedy: !0
+        }
+      });
+    }(r);
+  }
+  return i;
+}
+var u = f();
+const p = /* @__PURE__ */ l(u), g = /* @__PURE__ */ d({
+  __proto__: null,
+  default: p
+}, [u]);
+export {
+  g as c
+};

package/dist/csharp-BmDeN1AH.js

@@ -0,0 +1,388 @@
+var m, T;
+function Z() {
+  if (T) return m;
+  T = 1, m = y, y.displayName = "csharp", y.aliases = ["dotnet", "cs"];
+  function y(z) {
+    (function(t) {
+      function r(s, u) {
+        return s.replace(/<<(\d+)>>/g, function(f, W) {
+          return "(?:" + u[+W] + ")";
+        });
+      }
+      function e(s, u, f) {
+        return RegExp(r(s, u), "");
+      }
+      function l(s, u) {
+        for (var f = 0; f < u; f++)
+          s = s.replace(/<<self>>/g, function() {
+            return "(?:" + s + ")";
+          });
+        return s.replace(/<<self>>/g, "[^\\s\\S]");
+      }
+      var n = {
+        // keywords which represent a return or variable type
+        type: "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+        // keywords which are used to declare a type
+        typeDeclaration: "class enum interface record struct",
+        // contextual keywords
+        // ("var" and "dynamic" are missing because they are used like types)
+        contextual: "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
+        // all other keywords
+        other: "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield"
+      };
+      function d(s) {
+        return "\\b(?:" + s.trim().replace(/ /g, "|") + ")\\b";
+      }
+      var w = d(
+        n.typeDeclaration
+      ), p = RegExp(
+        d(
+          n.type + " " + n.typeDeclaration + " " + n.contextual + " " + n.other
+        )
+      ), j = d(
+        n.typeDeclaration + " " + n.contextual + " " + n.other
+      ), q = d(
+        n.type + " " + n.typeDeclaration + " " + n.other
+      ), g = l(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2), h = l(/\((?:[^()]|<<self>>)*\)/.source, 2), o = /@?\b[A-Za-z_]\w*\b/.source, b = r(/<<0>>(?:\s*<<1>>)?/.source, [o, g]), i = r(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [
+        j,
+        b
+      ]), v = /\[\s*(?:,\s*)*\]/.source, A = r(
+        /<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source,
+        [i, v]
+      ), N = r(
+        /[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,
+        [g, h, v]
+      ), O = r(/\(<<0>>+(?:,<<0>>+)+\)/.source, [N]), c = r(
+        /(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source,
+        [O, i, v]
+      ), a = {
+        keyword: p,
+        punctuation: /[<>()?,.:[\]]/
+      }, x = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source, E = /"(?:\\.|[^\\"\r\n])*"/.source, F = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
+      t.languages.csharp = t.languages.extend("clike", {
+        string: [
+          {
+            pattern: e(/(^|[^$\\])<<0>>/.source, [F]),
+            lookbehind: !0,
+            greedy: !0
+          },
+          {
+            pattern: e(/(^|[^@$\\])<<0>>/.source, [E]),
+            lookbehind: !0,
+            greedy: !0
+          }
+        ],
+        "class-name": [
+          {
+            // Using static
+            // using static System.Math;
+            pattern: e(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [
+              i
+            ]),
+            lookbehind: !0,
+            inside: a
+          },
+          {
+            // Using alias (type)
+            // using Project = PC.MyCompany.Project;
+            pattern: e(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
+              o,
+              c
+            ]),
+            lookbehind: !0,
+            inside: a
+          },
+          {
+            // Using alias (alias)
+            // using Project = PC.MyCompany.Project;
+            pattern: e(/(\busing\s+)<<0>>(?=\s*=)/.source, [o]),
+            lookbehind: !0
+          },
+          {
+            // Type declarations
+            // class Foo<A, B>
+            // interface Foo<out A, B>
+            pattern: e(/(\b<<0>>\s+)<<1>>/.source, [
+              w,
+              b
+            ]),
+            lookbehind: !0,
+            inside: a
+          },
+          {
+            // Single catch exception declaration
+            // catch(Foo)
+            // (things like catch(Foo e) is covered by variable declaration)
+            pattern: e(/(\bcatch\s*\(\s*)<<0>>/.source, [i]),
+            lookbehind: !0,
+            inside: a
+          },
+          {
+            // Name of the type parameter of generic constraints
+            // where Foo : class
+            pattern: e(/(\bwhere\s+)<<0>>/.source, [o]),
+            lookbehind: !0
+          },
+          {
+            // Casts and checks via as and is.
+            // as Foo<A>, is Bar<B>
+            // (things like if(a is Foo b) is covered by variable declaration)
+            pattern: e(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [
+              A
+            ]),
+            lookbehind: !0,
+            inside: a
+          },
+          {
+            // Variable, field and parameter declaration
+            // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
+            pattern: e(
+              /\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source,
+              [c, q, o]
+            ),
+            inside: a
+          }
+        ],
+        keyword: p,
+        // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
+        number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+        operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+        punctuation: /\?\.?|::|[{}[\];(),.:]/
+      }), t.languages.insertBefore("csharp", "number", {
+        range: {
+          pattern: /\.\./,
+          alias: "operator"
+        }
+      }), t.languages.insertBefore("csharp", "punctuation", {
+        "named-parameter": {
+          pattern: e(/([(,]\s*)<<0>>(?=\s*:)/.source, [o]),
+          lookbehind: !0,
+          alias: "punctuation"
+        }
+      }), t.languages.insertBefore("csharp", "class-name", {
+        namespace: {
+          // namespace Foo.Bar {}
+          // using Foo.Bar;
+          pattern: e(
+            /(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,
+            [o]
+          ),
+          lookbehind: !0,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        "type-expression": {
+          // default(Foo), typeof(Foo<Bar>), sizeof(int)
+          pattern: e(
+            /(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source,
+            [h]
+          ),
+          lookbehind: !0,
+          alias: "class-name",
+          inside: a
+        },
+        "return-type": {
+          // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+          // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+          // int Foo => 0; int Foo { get; set } = 0;
+          pattern: e(
+            /<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,
+            [c, i]
+          ),
+          inside: a,
+          alias: "class-name"
+        },
+        "constructor-invocation": {
+          // new List<Foo<Bar[]>> { }
+          pattern: e(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [c]),
+          lookbehind: !0,
+          inside: a,
+          alias: "class-name"
+        },
+        /*'explicit-implementation': {
+        // int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+        pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
+        inside: classNameInside,
+        alias: 'class-name'
+        },*/
+        "generic-method": {
+          // foo<Bar>()
+          pattern: e(/<<0>>\s*<<1>>(?=\s*\()/.source, [o, g]),
+          inside: {
+            function: e(/^<<0>>/.source, [o]),
+            generic: {
+              pattern: RegExp(g),
+              alias: "class-name",
+              inside: a
+            }
+          }
+        },
+        "type-list": {
+          // The list of types inherited or of generic constraints
+          // class Foo<F> : Bar, IList<FooBar>
+          // where F : Bar, IList<int>
+          pattern: e(
+            /\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source,
+            [
+              w,
+              b,
+              o,
+              c,
+              p.source,
+              h,
+              /\bnew\s*\(\s*\)/.source
+            ]
+          ),
+          lookbehind: !0,
+          inside: {
+            "record-arguments": {
+              pattern: e(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [
+                b,
+                h
+              ]),
+              lookbehind: !0,
+              greedy: !0,
+              inside: t.languages.csharp
+            },
+            keyword: p,
+            "class-name": {
+              pattern: RegExp(c),
+              greedy: !0,
+              inside: a
+            },
+            punctuation: /[,()]/
+          }
+        },
+        preprocessor: {
+          pattern: /(^[\t ]*)#.*/m,
+          lookbehind: !0,
+          alias: "property",
+          inside: {
+            // highlight preprocessor directives as keywords
+            directive: {
+              pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+              lookbehind: !0,
+              alias: "keyword"
+            }
+          }
+        }
+      });
+      var R = E + "|" + x, S = r(
+        /\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,
+        [R]
+      ), $ = l(
+        r(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+          S
+        ]),
+        2
+      ), _ = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source, U = r(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
+        i,
+        $
+      ]);
+      t.languages.insertBefore("csharp", "class-name", {
+        attribute: {
+          // Attributes
+          // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
+          pattern: e(
+            /((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source,
+            [_, U]
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            target: {
+              pattern: e(/^<<0>>(?=\s*:)/.source, [_]),
+              alias: "keyword"
+            },
+            "attribute-arguments": {
+              pattern: e(/\(<<0>>*\)/.source, [$]),
+              inside: t.languages.csharp
+            },
+            "class-name": {
+              pattern: RegExp(i),
+              inside: {
+                punctuation: /\./
+              }
+            },
+            punctuation: /[:,]/
+          }
+        }
+      });
+      var k = /:[^}\r\n]+/.source, I = l(
+        r(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+          S
+        ]),
+        2
+      ), B = r(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+        I,
+        k
+      ]), C = l(
+        r(
+          /[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source,
+          [R]
+        ),
+        2
+      ), D = r(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+        C,
+        k
+      ]);
+      function K(s, u) {
+        return {
+          interpolation: {
+            pattern: e(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [s]),
+            lookbehind: !0,
+            inside: {
+              "format-string": {
+                pattern: e(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
+                  u,
+                  k
+                ]),
+                lookbehind: !0,
+                inside: {
+                  punctuation: /^:/
+                }
+              },
+              punctuation: /^\{|\}$/,
+              expression: {
+                pattern: /[\s\S]+/,
+                alias: "language-csharp",
+                inside: t.languages.csharp
+              }
+            }
+          },
+          string: /[\s\S]+/
+        };
+      }
+      t.languages.insertBefore("csharp", "string", {
+        "interpolation-string": [
+          {
+            pattern: e(
+              /(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source,
+              [B]
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            inside: K(B, I)
+          },
+          {
+            pattern: e(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [
+              D
+            ]),
+            lookbehind: !0,
+            greedy: !0,
+            inside: K(D, C)
+          }
+        ],
+        char: {
+          pattern: RegExp(x),
+          greedy: !0
+        }
+      }), t.languages.dotnet = t.languages.cs = t.languages.csharp;
+    })(z);
+  }
+  return m;
+}
+export {
+  Z as r
+};

package/dist/csharp-C-RIlwgF.js

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