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

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

@@ -1,206 +0,0 @@
-var i, p;
-function u() {
-  if (p)
-    return i;
-  p = 1, i = r, r.displayName = "bash", r.aliases = ["shell"];
-  function r(l) {
-    (function(e) {
-      var n = "\\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", s = {
-        pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
-        lookbehind: !0,
-        alias: "punctuation",
-        // this looks reasonably well in all themes
-        inside: null
-        // see below
-      }, t = {
-        bash: s,
-        environment: {
-          pattern: RegExp("\\$" + n),
-          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("(\\{)" + n),
-                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+(?=\+?=)/,
-          inside: {
-            environment: {
-              pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + n),
-              lookbehind: !0,
-              alias: "constant"
-            }
-          },
-          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: s
-            }
-          },
-          // “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("\\$?" + n),
-          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|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|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|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
-        }
-      }, s.inside = e.languages.bash;
-      for (var o = ["comment", "function-name", "for-or-select", "assign-left", "string", "environment", "function", "keyword", "builtin", "boolean", "file-descriptor", "operator", "punctuation", "number"], d = t.variable[1].inside, a = 0; a < o.length; a++)
-        d[o[a]] = e.languages.bash[o[a]];
-      e.languages.shell = e.languages.bash;
-    })(l);
-  }
-  return i;
-}
-export {
-  u as __require
-};

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

@@ -1,29 +0,0 @@
-var T, R;
-function N() {
-  if (R)
-    return T;
-  R = 1, T = E, E.displayName = "basic", E.aliases = [];
-  function E(I) {
-    I.languages.basic = {
-      comment: {
-        pattern: /(?:!|REM\b).+/i,
-        inside: {
-          keyword: /^REM/i
-        }
-      },
-      string: {
-        pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
-        greedy: !0
-      },
-      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
-      keyword: /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
-      function: /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
-      operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
-      punctuation: /[,;:()]/
-    };
-  }
-  return T;
-}
-export {
-  N as __require
-};

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

@@ -1,95 +0,0 @@
-var i, o;
-function d() {
-  if (o)
-    return i;
-  o = 1, i = n, n.displayName = "batch", n.aliases = [];
-  function n(b) {
-    (function(s) {
-      var e = /%%?[~:\w]+%?|!\S+!/, r = {
-        pattern: /\/[a-z?]+(?=[ :]|$):?|-[a-z]\b|--[a-z-]+\b/im,
-        alias: "attr-name",
-        inside: {
-          punctuation: /:/
-        }
-      }, t = /"(?:[\\"]"|[^"])*"(?!")/, a = /(?:\b|-)\d+\b/;
-      s.languages.batch = {
-        comment: [/^::.*/m, {
-          pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
-          lookbehind: !0
-        }],
-        label: {
-          pattern: /^:.*/m,
-          alias: "property"
-        },
-        command: [{
-          // FOR command
-          pattern: /((?:^|[&(])[ \t]*)for(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* \S+ in \([^)]+\) do/im,
-          lookbehind: !0,
-          inside: {
-            keyword: /\b(?:do|in)\b|^for\b/i,
-            string: t,
-            parameter: r,
-            variable: e,
-            number: a,
-            punctuation: /[()',]/
-          }
-        }, {
-          // IF command
-          pattern: /((?:^|[&(])[ \t]*)if(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:not )?(?:cmdextversion \d+|defined \w+|errorlevel \d+|exist \S+|(?:"[^"]*"|(?!")(?:(?!==)\S)+)?(?:==| (?:equ|geq|gtr|leq|lss|neq) )(?:"[^"]*"|[^\s"]\S*))/im,
-          lookbehind: !0,
-          inside: {
-            keyword: /\b(?:cmdextversion|defined|errorlevel|exist|not)\b|^if\b/i,
-            string: t,
-            parameter: r,
-            variable: e,
-            number: a,
-            operator: /\^|==|\b(?:equ|geq|gtr|leq|lss|neq)\b/i
-          }
-        }, {
-          // ELSE command
-          pattern: /((?:^|[&()])[ \t]*)else\b/im,
-          lookbehind: !0,
-          inside: {
-            keyword: /^else\b/i
-          }
-        }, {
-          // SET command
-          pattern: /((?:^|[&(])[ \t]*)set(?: \/[a-z](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
-          lookbehind: !0,
-          inside: {
-            keyword: /^set\b/i,
-            string: t,
-            parameter: r,
-            variable: [e, /\w+(?=(?:[*\/%+\-&^|]|<<|>>)?=)/],
-            number: a,
-            operator: /[*\/%+\-&^|]=?|<<=?|>>=?|[!~_=]/,
-            punctuation: /[()',]/
-          }
-        }, {
-          // Other commands
-          pattern: /((?:^|[&(])[ \t]*@?)\w+\b(?:"(?:[\\"]"|[^"])*"(?!")|[^"^&)\r\n]|\^(?:\r\n|[\s\S]))*/m,
-          lookbehind: !0,
-          inside: {
-            keyword: /^\w+\b/,
-            string: t,
-            parameter: r,
-            label: {
-              pattern: /(^\s*):\S+/m,
-              lookbehind: !0,
-              alias: "property"
-            },
-            variable: e,
-            number: a,
-            operator: /\^/
-          }
-        }],
-        operator: /[&@]/,
-        punctuation: /[()']/
-      };
-    })(b);
-  }
-  return i;
-}
-export {
-  d as __require
-};

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

@@ -1,36 +0,0 @@
-var a, s;
-function n() {
-  if (s)
-    return a;
-  s = 1, a = e, e.displayName = "bbcode", e.aliases = ["shortcode"];
-  function e(t) {
-    t.languages.bbcode = {
-      tag: {
-        pattern: /\[\/?[^\s=\]]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))?(?:\s+[^\s=\]]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))*\s*\]/,
-        inside: {
-          tag: {
-            pattern: /^\[\/?[^\s=\]]+/,
-            inside: {
-              punctuation: /^\[\/?/
-            }
-          },
-          "attr-value": {
-            pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+)/,
-            inside: {
-              punctuation: [/^=/, {
-                pattern: /^(\s*)["']|["']$/,
-                lookbehind: !0
-              }]
-            }
-          },
-          punctuation: /\]/,
-          "attr-name": /[^\s=\]]+/
-        }
-      }
-    }, t.languages.shortcode = t.languages.bbcode;
-  }
-  return a;
-}
-export {
-  n as __require
-};

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

@@ -1,72 +0,0 @@
-var r, n;
-function i() {
-  if (n)
-    return r;
-  n = 1, r = e, e.displayName = "bicep", e.aliases = [];
-  function e(t) {
-    t.languages.bicep = {
-      comment: [{
-        // multiline comments eg /* ASDF */
-        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-        lookbehind: !0,
-        greedy: !0
-      }, {
-        // singleline comments eg // ASDF
-        pattern: /(^|[^\\:])\/\/.*/,
-        lookbehind: !0,
-        greedy: !0
-      }],
-      property: [{
-        pattern: /([\r\n][ \t]*)[a-z_]\w*(?=[ \t]*:)/i,
-        lookbehind: !0
-      }, {
-        pattern: /([\r\n][ \t]*)'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'(?=[ \t]*:)/,
-        lookbehind: !0,
-        greedy: !0
-      }],
-      string: [{
-        pattern: /'''[^'][\s\S]*?'''/,
-        greedy: !0
-      }, {
-        pattern: /(^|[^\\'])'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'/,
-        lookbehind: !0,
-        greedy: !0
-      }],
-      "interpolated-string": {
-        pattern: /(^|[^\\'])'(?:\\.|\$(?:(?!\{)|\{[^{}\r\n]*\})|[^'\\\r\n$])*'/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          interpolation: {
-            pattern: /\$\{[^{}\r\n]*\}/,
-            inside: {
-              expression: {
-                pattern: /(^\$\{)[\s\S]+(?=\}$)/,
-                lookbehind: !0
-              },
-              punctuation: /^\$\{|\}$/
-            }
-          },
-          string: /[\s\S]+/
-        }
-      },
-      datatype: {
-        pattern: /(\b(?:output|param)\b[ \t]+\w+[ \t]+)\w+\b/,
-        lookbehind: !0,
-        alias: "class-name"
-      },
-      boolean: /\b(?:false|true)\b/,
-      // https://github.com/Azure/bicep/blob/114a3251b4e6e30082a58729f19a8cc4e374ffa6/src/textmate/bicep.tmlanguage#L184
-      keyword: /\b(?:existing|for|if|in|module|null|output|param|resource|targetScope|var)\b/,
-      decorator: /@\w+\b/,
-      function: /\b[a-z_]\w*(?=[ \t]*\()/i,
-      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
-      operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
-      punctuation: /[{}[\];(),.:]/
-    }, t.languages.bicep["interpolated-string"].inside.interpolation.inside.expression.inside = t.languages.bicep;
-  }
-  return r;
-}
-export {
-  i as __require
-};

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

@@ -1,32 +0,0 @@
-var a, t;
-function i() {
-  if (t)
-    return a;
-  t = 1, a = e, e.displayName = "birb", e.aliases = [];
-  function e(r) {
-    r.languages.birb = r.languages.extend("clike", {
-      string: {
-        pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
-        greedy: !0
-      },
-      "class-name": [
-        /\b[A-Z](?:[\d_]*[a-zA-Z]\w*)?\b/,
-        // matches variable and function return types (parameters as well).
-        /\b(?:[A-Z]\w*|(?!(?:var|void)\b)[a-z]\w*)(?=\s+\w+\s*[;,=()])/
-      ],
-      keyword: /\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
-      operator: /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
-      variable: /\b[a-z_]\w*\b/
-    }), r.languages.insertBefore("birb", "function", {
-      metadata: {
-        pattern: /<\w+>/,
-        greedy: !0,
-        alias: "symbol"
-      }
-    });
-  }
-  return a;
-}
-export {
-  i as __require
-};

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

@@ -1,52 +0,0 @@
-import { __require as t } from "./c.mjs";
-var a, r;
-function o() {
-  if (r)
-    return a;
-  r = 1;
-  var i = t();
-  a = n, n.displayName = "bison", n.aliases = [];
-  function n(e) {
-    e.register(i), e.languages.bison = e.languages.extend("c", {}), e.languages.insertBefore("bison", "comment", {
-      bison: {
-        // This should match all the beginning of the file
-        // including the prologue(s), the bison declarations and
-        // the grammar rules.
-        pattern: /^(?:[^%]|%(?!%))*%%[\s\S]*?%%/,
-        inside: {
-          c: {
-            // Allow for one level of nested braces
-            pattern: /%\{[\s\S]*?%\}|\{(?:\{[^}]*\}|[^{}])*\}/,
-            inside: {
-              delimiter: {
-                pattern: /^%?\{|%?\}$/,
-                alias: "punctuation"
-              },
-              "bison-variable": {
-                pattern: /[$@](?:<[^\s>]+>)?[\w$]+/,
-                alias: "variable",
-                inside: {
-                  punctuation: /<|>/
-                }
-              },
-              rest: e.languages.c
-            }
-          },
-          comment: e.languages.c.comment,
-          string: e.languages.c.string,
-          property: /\S+(?=:)/,
-          keyword: /%\w+/,
-          number: {
-            pattern: /(^|[^@])\b(?:0x[\da-f]+|\d+)/i,
-            lookbehind: !0
-          },
-          punctuation: /%[%?]|[|:;\[\]<>]/
-        }
-      }
-    });
-  }
-  return a;
-}
-export {
-  o as __require
-};

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

@@ -1,31 +0,0 @@
-var e, a;
-function t() {
-  if (a)
-    return e;
-  a = 1, e = n, n.displayName = "bnf", n.aliases = ["rbnf"];
-  function n(r) {
-    r.languages.bnf = {
-      string: {
-        pattern: /"[^\r\n"]*"|'[^\r\n']*'/
-      },
-      definition: {
-        pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
-        alias: ["rule", "keyword"],
-        inside: {
-          punctuation: /^<|>$/
-        }
-      },
-      rule: {
-        pattern: /<[^<>\r\n\t]+>/,
-        inside: {
-          punctuation: /^<|>$/
-        }
-      },
-      operator: /::=|[|()[\]{}*+?]|\.{3}/
-    }, r.languages.rbnf = r.languages.bnf;
-  }
-  return e;
-}
-export {
-  t as __require
-};

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

@@ -1,32 +0,0 @@
-var r, e;
-function i() {
-  if (e)
-    return r;
-  e = 1, r = a, a.displayName = "brainfuck", a.aliases = [];
-  function a(n) {
-    n.languages.brainfuck = {
-      pointer: {
-        pattern: /<|>/,
-        alias: "keyword"
-      },
-      increment: {
-        pattern: /\+/,
-        alias: "inserted"
-      },
-      decrement: {
-        pattern: /-/,
-        alias: "deleted"
-      },
-      branching: {
-        pattern: /\[|\]/,
-        alias: "important"
-      },
-      operator: /[.,]/,
-      comment: /\S+/
-    };
-  }
-  return r;
-}
-export {
-  i as __require
-};

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

@@ -1,55 +0,0 @@
-var r, i;
-function n() {
-  if (i)
-    return r;
-  i = 1, r = e, e.displayName = "brightscript", e.aliases = [];
-  function e(t) {
-    t.languages.brightscript = {
-      comment: /(?:\brem|').*/i,
-      "directive-statement": {
-        pattern: /(^[\t ]*)#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if).*/im,
-        lookbehind: !0,
-        alias: "property",
-        inside: {
-          "error-message": {
-            pattern: /(^#error).+/,
-            lookbehind: !0
-          },
-          directive: {
-            pattern: /^#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if)/,
-            alias: "keyword"
-          },
-          expression: {
-            pattern: /[\s\S]+/,
-            inside: null
-            // see below
-          }
-        }
-      },
-      property: {
-        pattern: /([\r\n{,][\t ]*)(?:(?!\d)\w+|"(?:[^"\r\n]|"")*"(?!"))(?=[ \t]*:)/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      string: {
-        pattern: /"(?:[^"\r\n]|"")*"(?!")/,
-        greedy: !0
-      },
-      "class-name": {
-        pattern: /(\bAs[\t ]+)\w+/i,
-        lookbehind: !0
-      },
-      keyword: /\b(?:As|Dim|Each|Else|Elseif|End|Exit|For|Function|Goto|If|In|Print|Return|Step|Stop|Sub|Then|To|While)\b/i,
-      boolean: /\b(?:false|true)\b/i,
-      function: /\b(?!\d)\w+(?=[\t ]*\()/,
-      number: /(?:\b\d+(?:\.\d+)?(?:[ed][+-]\d+)?|&h[a-f\d]+)\b[%&!#]?/i,
-      operator: /--|\+\+|>>=?|<<=?|<>|[-+*/\\<>]=?|[:^=?]|\b(?:and|mod|not|or)\b/i,
-      punctuation: /[.,;()[\]{}]/,
-      constant: /\b(?:LINE_NUM)\b/i
-    }, t.languages.brightscript["directive-statement"].inside.expression.inside = t.languages.brightscript;
-  }
-  return r;
-}
-export {
-  n as __require
-};