@glodon-aiot/react-components 3.3.0-beta.14 → 3.3.0-beta.17

package/dist/es/node_modules/refractor/lang/concurnas.mjs

@@ -0,0 +1,69 @@
+var a, t;
+function r() {
+  if (t)
+    return a;
+  t = 1, a = n, n.displayName = "concurnas", n.aliases = ["conc"];
+  function n(e) {
+    e.languages.concurnas = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      langext: {
+        pattern: /\b\w+\s*\|\|[\s\S]+?\|\|/,
+        greedy: !0,
+        inside: {
+          "class-name": /^\w+/,
+          string: {
+            pattern: /(^\s*\|\|)[\s\S]+(?=\|\|$)/,
+            lookbehind: !0
+          },
+          punctuation: /\|\|/
+        }
+      },
+      function: {
+        pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/,
+        lookbehind: !0
+      },
+      keyword: /\b(?:abstract|actor|also|annotation|assert|async|await|bool|boolean|break|byte|case|catch|changed|char|class|closed|constant|continue|def|default|del|double|elif|else|enum|every|extends|false|finally|float|for|from|global|gpudef|gpukernel|if|import|in|init|inject|int|lambda|local|long|loop|match|new|nodefault|null|of|onchange|open|out|override|package|parfor|parforsync|post|pre|private|protected|provide|provider|public|return|shared|short|single|size_t|sizeof|super|sync|this|throw|trait|trans|transient|true|try|typedef|unchecked|using|val|var|void|while|with)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: /\b0b[01][01_]*L?\b|\b0x(?:[\da-f_]*\.)?[\da-f_p+-]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfls]?/i,
+      punctuation: /[{}[\];(),.:]/,
+      operator: /<==|>==|=>|->|<-|<>|&==|&<>|\?:?|\.\?|\+\+|--|[-+*/=<>]=?|[!^~]|\b(?:and|as|band|bor|bxor|comp|is|isnot|mod|or)\b=?/,
+      annotation: {
+        pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
+        alias: "builtin"
+      }
+    }, e.languages.insertBefore("concurnas", "langext", {
+      "regex-literal": {
+        pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+            lookbehind: !0,
+            inside: e.languages.concurnas
+          },
+          regex: /[\s\S]+/
+        }
+      },
+      "string-literal": {
+        pattern: /(?:\B|\bs)("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+            lookbehind: !0,
+            inside: e.languages.concurnas
+          },
+          string: /[\s\S]+/
+        }
+      }
+    }), e.languages.conc = e.languages.concurnas;
+  }
+  return a;
+}
+export {
+  r as __require
+};

package/dist/es/node_modules/refractor/lang/coq.mjs

@@ -0,0 +1,52 @@
+var i, n;
+function s() {
+  if (n)
+    return i;
+  n = 1, i = t, t.displayName = "coq", t.aliases = [];
+  function t(a) {
+    (function(o) {
+      for (var e = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source, r = 0; r < 2; r++)
+        e = e.replace(/<self>/g, function() {
+          return e;
+        });
+      e = e.replace(/<self>/g, "[]"), o.languages.coq = {
+        comment: RegExp(e),
+        string: {
+          pattern: /"(?:[^"]|"")*"(?!")/,
+          greedy: !0
+        },
+        attribute: [{
+          pattern: RegExp(/#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(/<comment>/g, function() {
+            return e;
+          })),
+          greedy: !0,
+          alias: "attr-name",
+          inside: {
+            comment: RegExp(e),
+            string: {
+              pattern: /"(?:[^"]|"")*"(?!")/,
+              greedy: !0
+            },
+            operator: /=/,
+            punctuation: /^#\[|\]$|[,()]/
+          }
+        }, {
+          pattern: /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
+          alias: "attr-name"
+        }],
+        keyword: /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
+        number: /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
+        punct: {
+          pattern: /@\{|\{\||\[=|:>/,
+          alias: "punctuation"
+        },
+        operator: /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
+        punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
+      };
+    })(a);
+  }
+  return i;
+}
+export {
+  s as __require
+};

package/dist/es/node_modules/refractor/lang/cpp.mjs

@@ -0,0 +1,98 @@
+import { __require as c } from "./c.mjs";
+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 __require
+};

package/dist/es/node_modules/refractor/lang/crystal.mjs

@@ -0,0 +1,63 @@
+import { __require as s } from "./ruby.mjs";
+var a, n;
+function o() {
+  if (n)
+    return a;
+  n = 1;
+  var i = s();
+  a = t, t.displayName = "crystal", t.aliases = [];
+  function t(r) {
+    r.register(i), 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 a;
+}
+export {
+  o as __require
+};

package/dist/es/node_modules/refractor/lang/csharp.mjs

@@ -0,0 +1,277 @@
+var m, T;
+function Z() {
+  if (T)
+    return m;
+  T = 1, m = y, y.displayName = "csharp", y.aliases = ["dotnet", "cs"];
+  function y(q) {
+    (function(t) {
+      function r(n, u) {
+        return n.replace(/<<(\d+)>>/g, function(d, W) {
+          return "(?:" + u[+W] + ")";
+        });
+      }
+      function e(n, u, d) {
+        return RegExp(r(n, u), d || "");
+      }
+      function l(n, u) {
+        for (var d = 0; d < u; d++)
+          n = n.replace(/<<self>>/g, function() {
+            return "(?:" + n + ")";
+          });
+        return n.replace(/<<self>>/g, "[^\\s\\S]");
+      }
+      var s = {
+        // 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 p(n) {
+        return "\\b(?:" + n.trim().replace(/ /g, "|") + ")\\b";
+      }
+      var w = p(s.typeDeclaration), g = RegExp(p(s.type + " " + s.typeDeclaration + " " + s.contextual + " " + s.other)), z = p(s.typeDeclaration + " " + s.contextual + " " + s.other), j = p(s.type + " " + s.typeDeclaration + " " + s.other), h = l(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2), b = l(/\((?:[^()]|<<self>>)*\)/.source, 2), o = /@?\b[A-Za-z_]\w*\b/.source, f = r(/<<0>>(?:\s*<<1>>)?/.source, [o, h]), i = r(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [z, f]), v = /\[\s*(?:,\s*)*\]/.source, A = r(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [i, v]), N = r(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [h, b, v]), O = r(/\(<<0>>+(?:,<<0>>+)+\)/.source, [N]), c = r(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [O, i, v]), a = {
+        keyword: g,
+        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, f]),
+          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, j, o]),
+          inside: a
+        }],
+        keyword: g,
+        // 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, [b]),
+          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, h]),
+          inside: {
+            function: e(/^<<0>>/.source, [o]),
+            generic: {
+              pattern: RegExp(h),
+              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, f, o, c, g.source, b, /\bnew\s*\(\s*\)/.source]),
+          lookbehind: !0,
+          inside: {
+            "record-arguments": {
+              pattern: e(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [f, b]),
+              lookbehind: !0,
+              greedy: !0,
+              inside: t.languages.csharp
+            },
+            keyword: g,
+            "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(n, u) {
+        return {
+          interpolation: {
+            pattern: e(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [n]),
+            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;
+    })(q);
+  }
+  return m;
+}
+export {
+  Z as __require
+};

package/dist/es/node_modules/refractor/lang/cshtml.mjs

@@ -0,0 +1,104 @@
+import { __require as k } from "./csharp.mjs";
+var l, p;
+function q() {
+  if (p)
+    return l;
+  p = 1;
+  var h = k();
+  l = c, c.displayName = "cshtml", c.aliases = ["razor"];
+  function c(i) {
+    i.register(h), function(r) {
+      var d = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source, m = /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source + "|" + /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
+      function a(o, b) {
+        for (var g = 0; g < b; g++)
+          o = o.replace(/<self>/g, function() {
+            return "(?:" + o + ")";
+          });
+        return o.replace(/<self>/g, "[^\\s\\S]").replace(/<str>/g, "(?:" + m + ")").replace(/<comment>/g, "(?:" + d + ")");
+      }
+      var s = a(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2), f = a(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2), e = a(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2), v = a(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2), t = /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/.source, u = /(?!\d)[^\s>\/=$<%]+/.source + t + /\s*\/?>/.source, w = /\B@?/.source + "(?:" + /<([a-zA-Z][\w:]*)/.source + t + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
+      // eslint-disable-next-line regexp/strict
+      /<\/?(?!\1\b)/.source + u + "|" + // nested start tag
+      a(
+        // eslint-disable-next-line regexp/strict
+        /<\1/.source + t + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
+        // eslint-disable-next-line regexp/strict
+        /<\/?(?!\1\b)/.source + u + "|<self>") + ")*" + // eslint-disable-next-line regexp/strict
+        /<\/\1\s*>/.source,
+        2
+      )) + ")*" + // eslint-disable-next-line regexp/strict
+      /<\/\1\s*>/.source + "|" + /</.source + u + ")";
+      r.languages.cshtml = r.languages.extend("markup", {});
+      var y = r.languages.insertBefore("csharp", "string", {
+        html: {
+          pattern: RegExp(w),
+          greedy: !0,
+          inside: r.languages.cshtml
+        }
+      }, {
+        csharp: r.languages.extend("csharp", {})
+      }), n = {
+        pattern: /\S[\s\S]*/,
+        alias: "language-csharp",
+        inside: y
+      };
+      r.languages.insertBefore("cshtml", "prolog", {
+        "razor-comment": {
+          pattern: /@\*[\s\S]*?\*@/,
+          greedy: !0,
+          alias: "comment"
+        },
+        block: {
+          pattern: RegExp(/(^|[^@])@/.source + "(?:" + [
+            // @{ ... }
+            e,
+            // @code{ ... }
+            /(?:code|functions)\s*/.source + e,
+            // @for (...) { ... }
+            /(?:for|foreach|lock|switch|using|while)\s*/.source + s + /\s*/.source + e,
+            // @do { ... } while (...);
+            /do\s*/.source + e + /\s*while\s*/.source + s + /(?:\s*;)?/.source,
+            // @try { ... } catch (...) { ... } finally { ... }
+            /try\s*/.source + e + /\s*catch\s*/.source + s + /\s*/.source + e + /\s*finally\s*/.source + e,
+            // @if (...) {...} else if (...) {...} else {...}
+            /if\s*/.source + s + /\s*/.source + e + "(?:" + /\s*else/.source + "(?:" + /\s+if\s*/.source + s + ")?" + /\s*/.source + e + ")*"
+          ].join("|") + ")"),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            keyword: /^@\w*/,
+            csharp: n
+          }
+        },
+        directive: {
+          pattern: /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            keyword: /^@\w+/,
+            csharp: n
+          }
+        },
+        value: {
+          pattern: RegExp(/(^|[^@])@/.source + /(?:await\b\s*)?/.source + "(?:" + /\w+\b/.source + "|" + s + ")(?:" + /[?!]?\.\w+\b/.source + "|" + s + "|" + f + "|" + v + s + ")*"),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "variable",
+          inside: {
+            keyword: /^@/,
+            csharp: n
+          }
+        },
+        "delegate-operator": {
+          pattern: /(^|[^@])@(?=<)/,
+          lookbehind: !0,
+          alias: "operator"
+        }
+      }), r.languages.razor = r.languages.cshtml;
+    }(i);
+  }
+  return l;
+}
+export {
+  q as __require
+};