@fluidattacks/design 8.0.0 → 8.2.0

package/dist/node_modules/refractor/lang/bash.js

@@ -0,0 +1,226 @@
+o.displayName = "bash";
+o.aliases = ["sh", "shell"];
+function o(i) {
+  (function(e) {
+    var a = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", r = {
+      pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+      lookbehind: !0,
+      alias: "punctuation",
+      // this looks reasonably well in all themes
+      inside: null
+      // see below
+    }, t = {
+      bash: r,
+      environment: {
+        pattern: RegExp("\\$" + a),
+        alias: "constant"
+      },
+      variable: [
+        // [0]: Arithmetic Environment
+        {
+          pattern: /\$?\(\([\s\S]+?\)\)/,
+          greedy: !0,
+          inside: {
+            // If there is a $ sign at the beginning highlight $(( and )) as variable
+            variable: [
+              {
+                pattern: /(^\$\(\([\s\S]+)\)\)/,
+                lookbehind: !0
+              },
+              /^\$\(\(/
+            ],
+            number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+            // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+            operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+            // If there is no $ sign at the beginning highlight (( and )) as punctuation
+            punctuation: /\(\(?|\)\)?|,|;/
+          }
+        },
+        // [1]: Command Substitution
+        {
+          pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+          greedy: !0,
+          inside: {
+            variable: /^\$\(|^`|\)$|`$/
+          }
+        },
+        // [2]: Brace expansion
+        {
+          pattern: /\$\{[^}]+\}/,
+          greedy: !0,
+          inside: {
+            operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+            punctuation: /[\[\]]/,
+            environment: {
+              pattern: RegExp("(\\{)" + a),
+              lookbehind: !0,
+              alias: "constant"
+            }
+          }
+        },
+        /\$(?:\w+|[#?*!@$])/
+      ],
+      // Escape sequences from echo and printf's manuals, and escaped quotes.
+      entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+    };
+    e.languages.bash = {
+      shebang: {
+        pattern: /^#!\s*\/.*/,
+        alias: "important"
+      },
+      comment: {
+        pattern: /(^|[^"{\\$])#.*/,
+        lookbehind: !0
+      },
+      "function-name": [
+        // a) function foo {
+        // b) foo() {
+        // c) function foo() {
+        // but not “foo {”
+        {
+          // a) and c)
+          pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        {
+          // b)
+          pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+          alias: "function"
+        }
+      ],
+      // Highlight variable names as variables in for and select beginnings.
+      "for-or-select": {
+        pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+        alias: "variable",
+        lookbehind: !0
+      },
+      // Highlight variable names as variables in the left-hand part
+      // of assignments (“=” and “+=”).
+      "assign-left": {
+        pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
+        inside: {
+          environment: {
+            pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + a),
+            lookbehind: !0,
+            alias: "constant"
+          }
+        },
+        alias: "variable",
+        lookbehind: !0
+      },
+      // Highlight parameter names as variables
+      parameter: {
+        pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
+        alias: "variable",
+        lookbehind: !0
+      },
+      string: [
+        // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+        {
+          pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: t
+        },
+        // Here-document with quotes around the tag
+        // → No expansion (so no “inside”).
+        {
+          pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            bash: r
+          }
+        },
+        // “Normal” string
+        {
+          // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+          pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: t
+        },
+        {
+          // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+          pattern: /(^|[^$\\])'[^']*'/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+          pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+          greedy: !0,
+          inside: {
+            entity: t.entity
+          }
+        }
+      ],
+      environment: {
+        pattern: RegExp("\\$?" + a),
+        alias: "constant"
+      },
+      variable: t.variable,
+      function: {
+        pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+        lookbehind: !0
+      },
+      keyword: {
+        pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+        lookbehind: !0
+      },
+      // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+      builtin: {
+        pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+        lookbehind: !0,
+        // Alias added to make those easier to distinguish from strings.
+        alias: "class-name"
+      },
+      boolean: {
+        pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+        lookbehind: !0
+      },
+      "file-descriptor": {
+        pattern: /\B&\d\b/,
+        alias: "important"
+      },
+      operator: {
+        // Lots of redirections here, but not just that.
+        pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+        inside: {
+          "file-descriptor": {
+            pattern: /^\d/,
+            alias: "important"
+          }
+        }
+      },
+      punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+      number: {
+        pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+        lookbehind: !0
+      }
+    }, r.inside = e.languages.bash;
+    for (var s = [
+      "comment",
+      "function-name",
+      "for-or-select",
+      "assign-left",
+      "parameter",
+      "string",
+      "environment",
+      "function",
+      "keyword",
+      "builtin",
+      "boolean",
+      "file-descriptor",
+      "operator",
+      "punctuation",
+      "number"
+    ], l = t.variable[1].inside, n = 0; n < s.length; n++)
+      l[s[n]] = e.languages.bash[s[n]];
+    e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
+  })(i);
+}
+export {
+  o as default
+};

package/dist/node_modules/refractor/lang/clike.js

@@ -0,0 +1,38 @@
+e.displayName = "clike";
+e.aliases = [];
+function e(n) {
+  n.languages.clike = {
+    comment: [
+      {
+        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      {
+        pattern: /(^|[^\\:])\/\/.*/,
+        lookbehind: !0,
+        greedy: !0
+      }
+    ],
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: !0
+    },
+    "class-name": {
+      pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+      lookbehind: !0,
+      inside: {
+        punctuation: /[.\\]/
+      }
+    },
+    keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+    boolean: /\b(?:false|true)\b/,
+    function: /\b\w+(?=\()/,
+    number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+    operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+    punctuation: /[{}[\];(),.:]/
+  };
+}
+export {
+  e as default
+};

package/dist/node_modules/refractor/lang/csharp.js

@@ -0,0 +1,385 @@
+import W from "./clike.js";
+K.displayName = "csharp";
+K.aliases = ["cs", "dotnet"];
+function K(k) {
+  k.register(W), (function(t) {
+    function r(s, u) {
+      return s.replace(/<<(\d+)>>/g, function(f, U) {
+        return "(?:" + u[+U] + ")";
+      });
+    }
+    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 m = d(
+      n.typeDeclaration
+    ), p = RegExp(
+      d(
+        n.type + " " + n.typeDeclaration + " " + n.contextual + " " + n.other
+      )
+    ), T = d(
+      n.typeDeclaration + " " + n.contextual + " " + n.other
+    ), z = 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, [
+      T,
+      b
+    ]), y = /\[\s*(?:,\s*)*\]/.source, j = r(
+      /<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source,
+      [i, y]
+    ), A = r(
+      /[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,
+      [g, h, y]
+    ), N = r(/\(<<0>>+(?:,<<0>>+)+\)/.source, [A]), c = r(
+      /(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source,
+      [N, i, y]
+    ), a = {
+      keyword: p,
+      punctuation: /[<>()?,.:[\]]/
+    }, w = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source, x = /"(?:\\.|[^\\"\r\n])*"/.source, O = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
+    t.languages.csharp = t.languages.extend("clike", {
+      string: [
+        {
+          pattern: e(/(^|[^$\\])<<0>>/.source, [O]),
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: e(/(^|[^@$\\])<<0>>/.source, [x]),
+          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, [
+            m,
+            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, [
+            j
+          ]),
+          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, z, 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,
+          [
+            m,
+            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 E = x + "|" + w, S = r(
+      /\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,
+      [E]
+    ), R = l(
+      r(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+        S
+      ]),
+      2
+    ), $ = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source, F = r(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
+      i,
+      R
+    ]);
+    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,
+          [$, F]
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          target: {
+            pattern: e(/^<<0>>(?=\s*:)/.source, [$]),
+            alias: "keyword"
+          },
+          "attribute-arguments": {
+            pattern: e(/\(<<0>>*\)/.source, [R]),
+            inside: t.languages.csharp
+          },
+          "class-name": {
+            pattern: RegExp(i),
+            inside: {
+              punctuation: /\./
+            }
+          },
+          punctuation: /[:,]/
+        }
+      }
+    });
+    var v = /:[^}\r\n]+/.source, I = l(
+      r(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+        S
+      ]),
+      2
+    ), _ = r(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+      I,
+      v
+    ]), B = l(
+      r(
+        /[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source,
+        [E]
+      ),
+      2
+    ), D = r(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+      B,
+      v
+    ]);
+    function C(s, u) {
+      return {
+        interpolation: {
+          pattern: e(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [s]),
+          lookbehind: !0,
+          inside: {
+            "format-string": {
+              pattern: e(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
+                u,
+                v
+              ]),
+              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,
+            [_]
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: C(_, I)
+        },
+        {
+          pattern: e(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [
+            D
+          ]),
+          lookbehind: !0,
+          greedy: !0,
+          inside: C(D, B)
+        }
+      ],
+      char: {
+        pattern: RegExp(w),
+        greedy: !0
+      }
+    }), t.languages.dotnet = t.languages.cs = t.languages.csharp;
+  })(k);
+}
+export {
+  K as default
+};