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

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

@@ -0,0 +1,32 @@
+import { __require as o } from "./json.mjs";
+var e, t;
+function d() {
+  if (t)
+    return e;
+  t = 1;
+  var u = o();
+  e = r, r.displayName = "json5", r.aliases = [];
+  function r(n) {
+    n.register(u), function(a) {
+      var s = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
+      a.languages.json5 = a.languages.extend("json", {
+        property: [{
+          pattern: RegExp(s.source + "(?=\\s*:)"),
+          greedy: !0
+        }, {
+          pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
+          alias: "unquoted"
+        }],
+        string: {
+          pattern: s,
+          greedy: !0
+        },
+        number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
+      });
+    }(n);
+  }
+  return e;
+}
+export {
+  d as __require
+};

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

@@ -0,0 +1,20 @@
+import { __require as o } from "./json.mjs";
+var r, s;
+function t() {
+  if (s)
+    return r;
+  s = 1;
+  var a = o();
+  r = e, e.displayName = "jsonp", e.aliases = [];
+  function e(n) {
+    n.register(a), n.languages.jsonp = n.languages.extend("json", {
+      punctuation: /[{}[\]();,.]/
+    }), n.languages.insertBefore("jsonp", "punctuation", {
+      function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/
+    });
+  }
+  return r;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,53 @@
+var e, t;
+function s() {
+  if (t)
+    return e;
+  t = 1, e = a, a.displayName = "jsstacktrace", a.aliases = [];
+  function a(n) {
+    n.languages.jsstacktrace = {
+      "error-message": {
+        pattern: /^\S.*/m,
+        alias: "string"
+      },
+      "stack-frame": {
+        pattern: /(^[ \t]+)at[ \t].*/m,
+        lookbehind: !0,
+        inside: {
+          "not-my-code": {
+            pattern: /^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m,
+            alias: "comment"
+          },
+          filename: {
+            pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
+            lookbehind: !0,
+            alias: "url"
+          },
+          function: {
+            pattern: /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
+            lookbehind: !0,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          punctuation: /[()]/,
+          keyword: /\b(?:at|new)\b/,
+          alias: {
+            pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
+            alias: "variable"
+          },
+          "line-number": {
+            pattern: /:\d+(?::\d+)?\b/,
+            alias: "number",
+            inside: {
+              punctuation: /:/
+            }
+          }
+        }
+      }
+    };
+  }
+  return e;
+}
+export {
+  s as __require
+};

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

@@ -0,0 +1,61 @@
+var p, d;
+function v() {
+  if (d)
+    return p;
+  d = 1, p = u, u.displayName = "jsx", u.aliases = [];
+  function u(x) {
+    (function(a) {
+      var i = a.util.clone(a.languages.javascript), j = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, h = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, l = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+      function c(e, t) {
+        return e = e.replace(/<S>/g, function() {
+          return j;
+        }).replace(/<BRACES>/g, function() {
+          return h;
+        }).replace(/<SPREAD>/g, function() {
+          return l;
+        }), RegExp(e, t);
+      }
+      l = c(l).source, a.languages.jsx = a.languages.extend("markup", i), a.languages.jsx.tag.pattern = c(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source), a.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, a.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, a.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, a.languages.jsx.tag.inside.comment = i.comment, a.languages.insertBefore("inside", "attr-name", {
+        spread: {
+          pattern: c(/<SPREAD>/.source),
+          inside: a.languages.jsx
+        }
+      }, a.languages.jsx.tag), a.languages.insertBefore("inside", "special-attr", {
+        script: {
+          // Allow for two levels of nesting
+          pattern: c(/=<BRACES>/.source),
+          alias: "language-javascript",
+          inside: {
+            "script-punctuation": {
+              pattern: /^=(?=\{)/,
+              alias: "punctuation"
+            },
+            rest: a.languages.jsx
+          }
+        }
+      }, a.languages.jsx.tag);
+      var g = function(e) {
+        return e ? typeof e == "string" ? e : typeof e.content == "string" ? e.content : e.content.map(g).join("") : "";
+      }, f = function(e) {
+        for (var t = [], s = 0; s < e.length; s++) {
+          var n = e[s], o = !1;
+          if (typeof n != "string" && (n.type === "tag" && n.content[0] && n.content[0].type === "tag" ? n.content[0].content[0].content === "</" ? t.length > 0 && t[t.length - 1].tagName === g(n.content[0].content[1]) && t.pop() : n.content[n.content.length - 1].content === "/>" || t.push({
+            tagName: g(n.content[0].content[1]),
+            openedBraces: 0
+          }) : t.length > 0 && n.type === "punctuation" && n.content === "{" ? t[t.length - 1].openedBraces++ : t.length > 0 && t[t.length - 1].openedBraces > 0 && n.type === "punctuation" && n.content === "}" ? t[t.length - 1].openedBraces-- : o = !0), (o || typeof n == "string") && t.length > 0 && t[t.length - 1].openedBraces === 0) {
+            var r = g(n);
+            s < e.length - 1 && (typeof e[s + 1] == "string" || e[s + 1].type === "plain-text") && (r += g(e[s + 1]), e.splice(s + 1, 1)), s > 0 && (typeof e[s - 1] == "string" || e[s - 1].type === "plain-text") && (r = g(e[s - 1]) + r, e.splice(s - 1, 1), s--), e[s] = new a.Token("plain-text", r, null, r);
+          }
+          n.content && typeof n.content != "string" && f(n.content);
+        }
+      };
+      a.hooks.add("after-tokenize", function(e) {
+        e.language !== "jsx" && e.language !== "tsx" || f(e.tokens);
+      });
+    })(x);
+  }
+  return p;
+}
+export {
+  v as __require
+};

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

@@ -0,0 +1,47 @@
+var r, t;
+function n() {
+  if (t)
+    return r;
+  t = 1, r = e, e.displayName = "julia", e.aliases = [];
+  function e(a) {
+    a.languages.julia = {
+      comment: {
+        // support one level of nested comments
+        // https://github.com/JuliaLang/julia/pull/6128
+        pattern: /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/,
+        lookbehind: !0
+      },
+      regex: {
+        // https://docs.julialang.org/en/v1/manual/strings/#Regular-Expressions-1
+        pattern: /r"(?:\\.|[^"\\\r\n])*"[imsx]{0,4}/,
+        greedy: !0
+      },
+      string: {
+        // https://docs.julialang.org/en/v1/manual/strings/#String-Basics-1
+        // https://docs.julialang.org/en/v1/manual/strings/#non-standard-string-literals-1
+        // https://docs.julialang.org/en/v1/manual/running-external-programs/#Running-External-Programs-1
+        pattern: /"""[\s\S]+?"""|(?:\b\w+)?"(?:\\.|[^"\\\r\n])*"|`(?:[^\\`\r\n]|\\.)*`/,
+        greedy: !0
+      },
+      char: {
+        // https://docs.julialang.org/en/v1/manual/strings/#man-characters-1
+        pattern: /(^|[^\w'])'(?:\\[^\r\n][^'\r\n]*|[^\\\r\n])'/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+(?:_[\da-f]+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[efp][+-]?\d+(?:_\d+)*)?j?/i,
+      // https://docs.julialang.org/en/v1/manual/mathematical-operations/
+      // https://docs.julialang.org/en/v1/manual/mathematical-operations/#Operator-Precedence-and-Associativity-1
+      operator: /&&|\|\||[-+*^%÷⊻&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥'√∛]/,
+      punctuation: /::?|[{}[\]();,.?]/,
+      // https://docs.julialang.org/en/v1/base/numbers/#Base.im
+      constant: /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[πℯ]/
+    };
+  }
+  return r;
+}
+export {
+  n as __require
+};

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

@@ -0,0 +1,54 @@
+var r, _;
+function i() {
+  if (_)
+    return r;
+  _ = 1, r = e, e.displayName = "keepalived", e.aliases = [];
+  function e(t) {
+    t.languages.keepalived = {
+      comment: {
+        pattern: /[#!].*/,
+        greedy: !0
+      },
+      string: {
+        pattern: /(^|[^\\])(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      // support IPv4, IPv6, subnet mask
+      ip: {
+        pattern: RegExp(/\b(?:(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){5}:(?:[\da-f]{1,4}:)?[\da-f]{1,4}|(?:[\da-f]{1,4}:){4}:(?:[\da-f]{1,4}:){0,2}[\da-f]{1,4}|(?:[\da-f]{1,4}:){3}:(?:[\da-f]{1,4}:){0,3}[\da-f]{1,4}|(?:[\da-f]{1,4}:){2}:(?:[\da-f]{1,4}:){0,4}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}<ipv4>|(?:[\da-f]{1,4}:){0,5}:<ipv4>|::(?:[\da-f]{1,4}:){0,5}<ipv4>|[\da-f]{1,4}::(?:[\da-f]{1,4}:){0,5}[\da-f]{1,4}|::(?:[\da-f]{1,4}:){0,6}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:)(?:\/\d{1,3})?|<ipv4>(?:\/\d{1,2})?)\b/.source.replace(/<ipv4>/g, function() {
+          return /(?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d))/.source;
+        }), "i"),
+        alias: "number"
+      },
+      // support *nix / Windows, directory / file
+      path: {
+        pattern: /(\s)\/(?:[^\/\s]+\/)*[^\/\s]*|\b[a-zA-Z]:\\(?:[^\\\s]+\\)*[^\\\s]*/,
+        lookbehind: !0,
+        alias: "string"
+      },
+      variable: /\$\{?\w+\}?/,
+      email: {
+        pattern: /[\w-]+@[\w-]+(?:\.[\w-]{2,3}){1,2}/,
+        alias: "string"
+      },
+      "conditional-configuration": {
+        pattern: /@\^?[\w-]+/,
+        alias: "variable"
+      },
+      operator: /=/,
+      property: /\b(?:BFD_CHECK|DNS_CHECK|FILE_CHECK|HTTP_GET|MISC_CHECK|NAME|PING_CHECK|SCRIPTS|SMTP_CHECK|SSL|SSL_GET|TCP_CHECK|UDP_CHECK|accept|advert_int|alpha|auth_pass|auth_type|authentication|bfd_cpu_affinity|bfd_instance|bfd_no_swap|bfd_priority|bfd_process_name|bfd_rlimit_rttime|bfd_rt_priority|bind_if|bind_port|bindto|ca|certificate|check_unicast_src|checker|checker_cpu_affinity|checker_log_all_failures|checker_no_swap|checker_priority|checker_rlimit_rttime|checker_rt_priority|child_wait_time|connect_ip|connect_port|connect_timeout|dbus_service_name|debug|default_interface|delay|delay_before_retry|delay_loop|digest|dont_track_primary|dynamic|dynamic_interfaces|enable_(?:dbus|script_security|sni|snmp_checker|snmp_rfc|snmp_rfcv2|snmp_rfcv3|snmp_vrrp|traps)|end|fall|fast_recovery|file|flag-[123]|fork_delay|full_command|fwmark|garp_group|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|global_defs|global_tracking|gna_interval|group|ha_suspend|hashed|helo_name|higher_prio_send_advert|hoplimit|http_protocol|hysteresis|idle_tx|include|inhibit_on_failure|init_fail|init_file|instance|interface|interfaces|interval|ip_family|ipvs_process_name|keepalived.conf|kernel_rx_buf_size|key|linkbeat_interfaces|linkbeat_use_polling|log_all_failures|log_unknown_vrids|lower_prio_no_advert|lthreshold|lvs_flush|lvs_flush_onstop|lvs_method|lvs_netlink_cmd_rcv_bufs|lvs_netlink_cmd_rcv_bufs_force|lvs_netlink_monitor_rcv_bufs|lvs_netlink_monitor_rcv_bufs_force|lvs_notify_fifo|lvs_notify_fifo_script|lvs_sched|lvs_sync_daemon|max_auto_priority|max_hops|mcast_src_ip|mh-fallback|mh-port|min_auto_priority_delay|min_rx|min_tx|misc_dynamic|misc_path|misc_timeout|multiplier|name|namespace_with_ipsets|native_ipv6|neighbor_ip|net_namespace|net_namespace_ipvs|nftables|nftables_counters|nftables_ifindex|nftables_priority|no_accept|no_checker_emails|no_email_faults|nopreempt|notification_email|notification_email_from|notify|notify_backup|notify_deleted|notify_down|notify_fault|notify_fifo|notify_fifo_script|notify_master|notify_master_rx_lower_pri|notify_priority_changes|notify_stop|notify_up|old_unicast_checksum|omega|ops|param_match|passive|password|path|persistence_engine|persistence_granularity|persistence_timeout|preempt|preempt_delay|priority|process|process_monitor_rcv_bufs|process_monitor_rcv_bufs_force|process_name|process_names|promote_secondaries|protocol|proxy_arp|proxy_arp_pvlan|quorum|quorum_down|quorum_max|quorum_up|random_seed|real_server|regex|regex_max_offset|regex_min_offset|regex_no_match|regex_options|regex_stack|reload_repeat|reload_time_file|require_reply|retry|rise|router_id|rs_init_notifies|script|script_user|sh-fallback|sh-port|shutdown_script|shutdown_script_timeout|skip_check_adv_addr|smtp_alert|smtp_alert_checker|smtp_alert_vrrp|smtp_connect_timeout|smtp_helo_name|smtp_server|snmp_socket|sorry_server|sorry_server_inhibit|sorry_server_lvs_method|source_ip|start|startup_script|startup_script_timeout|state|static_ipaddress|static_routes|static_rules|status_code|step|strict_mode|sync_group_tracking_weight|terminate_delay|timeout|track_bfd|track_file|track_group|track_interface|track_process|track_script|track_src_ip|ttl|type|umask|unicast_peer|unicast_src_ip|unicast_ttl|url|use_ipvlan|use_pid_dir|use_vmac|user|uthreshold|val[123]|version|virtual_ipaddress|virtual_ipaddress_excluded|virtual_router_id|virtual_routes|virtual_rules|virtual_server|virtual_server_group|virtualhost|vmac_xmit_base|vrrp|vrrp_(?:check_unicast_src|cpu_affinity|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|gna_interval|higher_prio_send_advert|instance|ipsets|iptables|lower_prio_no_advert|mcast_group4|mcast_group6|min_garp|netlink_cmd_rcv_bufs|netlink_cmd_rcv_bufs_force|netlink_monitor_rcv_bufs|netlink_monitor_rcv_bufs_force|no_swap|notify_fifo|notify_fifo_script|notify_priority_changes|priority|process_name|rlimit_rttime|rt_priority|rx_bufs_multiplier|rx_bufs_policy|script|skip_check_adv_addr|startup_delay|strict|sync_group|track_process|version)|warmup|weight)\b/,
+      constant: /\b(?:A|AAAA|AH|BACKUP|CNAME|DR|MASTER|MX|NAT|NS|PASS|SCTP|SOA|TCP|TUN|TXT|UDP|dh|fo|lblc|lblcr|lc|mh|nq|ovf|rr|sed|sh|wlc|wrr)\b/,
+      number: {
+        pattern: /(^|[^\w.-])-?\d+(?:\.\d+)?/,
+        lookbehind: !0
+      },
+      boolean: /\b(?:false|no|off|on|true|yes)\b/,
+      punctuation: /[\{\}]/
+    };
+  }
+  return r;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,55 @@
+var a, r;
+function n() {
+  if (r)
+    return a;
+  r = 1, a = e, e.displayName = "keyman", e.aliases = [];
+  function e(t) {
+    t.languages.keyman = {
+      comment: {
+        pattern: /\bc .*/i,
+        greedy: !0
+      },
+      string: {
+        pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+        greedy: !0
+      },
+      "virtual-key": {
+        pattern: /\[\s*(?:(?:ALT|CAPS|CTRL|LALT|LCTRL|NCAPS|RALT|RCTRL|SHIFT)\s+)*(?:[TKU]_[\w?]+|[A-E]\d\d?|"[^"\r\n]*"|'[^'\r\n]*')\s*\]/i,
+        greedy: !0,
+        alias: "function"
+        // alias for styles
+      },
+      // https://help.keyman.com/developer/language/guide/headers
+      "header-keyword": {
+        pattern: /&\w+/,
+        alias: "bold"
+        // alias for styles
+      },
+      "header-statement": {
+        pattern: /\b(?:bitmap|bitmaps|caps always off|caps on only|copyright|hotkey|language|layout|message|name|shift frees caps|version)\b/i,
+        alias: "bold"
+        // alias for styles
+      },
+      "rule-keyword": {
+        pattern: /\b(?:any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|reset|return|save|set|store|use)\b/i,
+        alias: "keyword"
+      },
+      "structural-keyword": {
+        pattern: /\b(?:ansi|begin|group|match|nomatch|unicode|using keys)\b/i,
+        alias: "keyword"
+      },
+      "compile-target": {
+        pattern: /\$(?:keyman|keymanonly|keymanweb|kmfl|weaver):/i,
+        alias: "property"
+      },
+      // U+####, x###, d### characters and numbers
+      number: /\b(?:U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i,
+      operator: /[+>\\$]|\.\./,
+      punctuation: /[()=,]/
+    };
+  }
+  return a;
+}
+export {
+  n as __require
+};

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

@@ -0,0 +1,81 @@
+var t, i;
+function l() {
+  if (i)
+    return t;
+  i = 1, t = n, n.displayName = "kotlin", n.aliases = ["kt", "kts"];
+  function n(r) {
+    (function(e) {
+      e.languages.kotlin = e.languages.extend("clike", {
+        keyword: {
+          // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
+          pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+          lookbehind: !0
+        },
+        function: [{
+          pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+          greedy: !0
+        }, {
+          pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+          lookbehind: !0,
+          greedy: !0
+        }],
+        number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+        operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
+      }), delete e.languages.kotlin["class-name"];
+      var a = {
+        "interpolation-punctuation": {
+          pattern: /^\$\{?|\}$/,
+          alias: "punctuation"
+        },
+        expression: {
+          pattern: /[\s\S]+/,
+          inside: e.languages.kotlin
+        }
+      };
+      e.languages.insertBefore("kotlin", "string", {
+        // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
+        "string-literal": [{
+          pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+          alias: "multiline",
+          inside: {
+            interpolation: {
+              pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+              inside: a
+            },
+            string: /[\s\S]+/
+          }
+        }, {
+          pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+          alias: "singleline",
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+              lookbehind: !0,
+              inside: a
+            },
+            string: /[\s\S]+/
+          }
+        }],
+        char: {
+          // https://kotlinlang.org/spec/expressions.html#character-literals
+          pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+          greedy: !0
+        }
+      }), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", {
+        annotation: {
+          pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+          alias: "builtin"
+        }
+      }), e.languages.insertBefore("kotlin", "function", {
+        label: {
+          pattern: /\b\w+@|@\w+\b/,
+          alias: "symbol"
+        }
+      }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
+    })(r);
+  }
+  return t;
+}
+export {
+  l as __require
+};

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

@@ -0,0 +1,85 @@
+var o, t;
+function p() {
+  if (t)
+    return o;
+  t = 1, o = e, e.displayName = "kumir", e.aliases = ["kum"];
+  function e(a) {
+    (function(r) {
+      var u = /\s\x00-\x1f\x22-\x2f\x3a-\x3f\x5b-\x5e\x60\x7b-\x7e/.source;
+      function n(d, i) {
+        return RegExp(d.replace(/<nonId>/g, u), i);
+      }
+      r.languages.kumir = {
+        comment: {
+          pattern: /\|.*/
+        },
+        prolog: {
+          pattern: /#.*/,
+          greedy: !0
+        },
+        string: {
+          pattern: /"[^\n\r"]*"|'[^\n\r']*'/,
+          greedy: !0
+        },
+        boolean: {
+          pattern: n(/(^|[<nonId>])(?:да|нет)(?=[<nonId>]|$)/.source),
+          lookbehind: !0
+        },
+        "operator-word": {
+          pattern: n(/(^|[<nonId>])(?:и|или|не)(?=[<nonId>]|$)/.source),
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        "system-variable": {
+          pattern: n(/(^|[<nonId>])знач(?=[<nonId>]|$)/.source),
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        type: [{
+          pattern: n(/(^|[<nonId>])(?:вещ|лит|лог|сим|цел)(?:\x20*таб)?(?=[<nonId>]|$)/.source),
+          lookbehind: !0,
+          alias: "builtin"
+        }, {
+          pattern: n(/(^|[<nonId>])(?:компл|сканкод|файл|цвет)(?=[<nonId>]|$)/.source),
+          lookbehind: !0,
+          alias: "important"
+        }],
+        /**
+         * Should be performed after searching for type names because of "таб".
+         * "таб" is a reserved word, but never used without a preceding type name.
+         * "НАЗНАЧИТЬ", "Фввод", and "Фвывод" are not reserved words.
+         */
+        keyword: {
+          pattern: n(/(^|[<nonId>])(?:алг|арг(?:\x20*рез)?|ввод|ВКЛЮЧИТЬ|вс[её]|выбор|вывод|выход|дано|для|до|дс|если|иначе|исп|использовать|кон(?:(?:\x20+|_)исп)?|кц(?:(?:\x20+|_)при)?|надо|нач|нс|нц|от|пауза|пока|при|раза?|рез|стоп|таб|то|утв|шаг)(?=[<nonId>]|$)/.source),
+          lookbehind: !0
+        },
+        /** Should be performed after searching for reserved words. */
+        name: {
+          // eslint-disable-next-line regexp/no-super-linear-backtracking
+          pattern: n(/(^|[<nonId>])[^\d<nonId>][^<nonId>]*(?:\x20+[^<nonId>]+)*(?=[<nonId>]|$)/.source),
+          lookbehind: !0
+        },
+        /** Should be performed after searching for names. */
+        number: {
+          pattern: n(/(^|[<nonId>])(?:\B\$[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?=[<nonId>]|$)/.source, "i"),
+          lookbehind: !0
+        },
+        /** Should be performed after searching for words. */
+        punctuation: /:=|[(),:;\[\]]/,
+        /**
+         * Should be performed after searching for
+         * - numeric constants (because of "+" and "-");
+         * - punctuation marks (because of ":=" and "=").
+         */
+        "operator-char": {
+          pattern: /\*\*?|<[=>]?|>=?|[-+/=]/,
+          alias: "operator"
+        }
+      }, r.languages.kum = r.languages.kumir;
+    })(a);
+  }
+  return o;
+}
+export {
+  p as __require
+};

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

@@ -0,0 +1,47 @@
+var a, t;
+function r() {
+  if (t)
+    return a;
+  t = 1, a = e, e.displayName = "kusto", e.aliases = [];
+  function e(n) {
+    n.languages.kusto = {
+      comment: {
+        pattern: /\/\/.*/,
+        greedy: !0
+      },
+      string: {
+        pattern: /```[\s\S]*?```|[hH]?(?:"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\.)*'|@(?:"[^\r\n"]*"|'[^\r\n']*'))/,
+        greedy: !0
+      },
+      verb: {
+        pattern: /(\|\s*)[a-z][\w-]*/i,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      command: {
+        pattern: /\.[a-z][a-z\d-]*\b/,
+        alias: "keyword"
+      },
+      "class-name": /\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\b/,
+      keyword: /\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\s+regex|nulls\s+(?:first|last))(?![\w-])/,
+      boolean: /\b(?:false|null|true)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/,
+      datetime: [{
+        // RFC 822 + RFC 850
+        pattern: /\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\s*,\s*)?\d{1,2}(?:\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\s+|-)\d{2}\s+\d{2}:\d{2}(?::\d{2})?(?:\s*(?:\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\d{4}))?\b/,
+        alias: "number"
+      }, {
+        // ISO 8601
+        pattern: /[+-]?\b(?:\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)Z?/,
+        alias: "number"
+      }],
+      number: /\b(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?)(?:(?:min|sec|[mnµ]s|[dhms]|microsecond|tick)\b)?|[+-]?\binf\b/,
+      operator: /=>|[!=]~|[!=<>]=?|[-+*/%|]|\.\./,
+      punctuation: /[()\[\]{},;.:]/
+    };
+  }
+  return a;
+}
+export {
+  r as __require
+};

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

@@ -0,0 +1,68 @@
+var t, i;
+function u() {
+  if (i)
+    return t;
+  i = 1, t = e, e.displayName = "latex", e.aliases = ["tex", "context"];
+  function e(s) {
+    (function(a) {
+      var n = /\\(?:[^a-z()[\]]|[a-z*]+)/i, r = {
+        "equation-command": {
+          pattern: n,
+          alias: "regex"
+        }
+      };
+      a.languages.latex = {
+        comment: /%.*/,
+        // the verbatim environment prints whitespace to the document
+        cdata: {
+          pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+          lookbehind: !0
+        },
+        /*
+         * equations can be between $$ $$ or $ $ or \( \) or \[ \]
+         * (all are multiline)
+         */
+        equation: [{
+          pattern: /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/,
+          inside: r,
+          alias: "string"
+        }, {
+          pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+          lookbehind: !0,
+          inside: r,
+          alias: "string"
+        }],
+        /*
+         * arguments which are keywords or references are highlighted
+         * as keywords
+         */
+        keyword: {
+          pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+          lookbehind: !0
+        },
+        url: {
+          pattern: /(\\url\{)[^}]+(?=\})/,
+          lookbehind: !0
+        },
+        /*
+         * section or chapter headlines are highlighted as bold so that
+         * they stand out more
+         */
+        headline: {
+          pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+          lookbehind: !0,
+          alias: "class-name"
+        },
+        function: {
+          pattern: n,
+          alias: "selector"
+        },
+        punctuation: /[[\]{}&]/
+      }, a.languages.tex = a.languages.latex, a.languages.context = a.languages.latex;
+    })(s);
+  }
+  return t;
+}
+export {
+  u as __require
+};