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

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

@@ -1,69 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,277 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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
-};