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

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

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

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

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

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

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

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

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

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

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

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