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

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

@@ -0,0 +1,60 @@
+import { __require as d } from "./markup-templating.mjs";
+var t, u;
+function g() {
+  if (u)
+    return t;
+  u = 1;
+  var l = d();
+  t = o, o.displayName = "django", o.aliases = ["jinja2"];
+  function o(r) {
+    r.register(l), function(e) {
+      e.languages.django = {
+        comment: /^\{#[\s\S]*?#\}$/,
+        tag: {
+          pattern: /(^\{%[+-]?\s*)\w+/,
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        delimiter: {
+          pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
+          alias: "punctuation"
+        },
+        string: {
+          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: !0
+        },
+        filter: {
+          pattern: /(\|)\w+/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        test: {
+          pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        function: /\b[a-z_]\w+(?=\s*\()/i,
+        keyword: /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+        operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+        number: /\b\d+(?:\.\d+)?\b/,
+        boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
+        variable: /\b\w+\b/,
+        punctuation: /[{}[\](),.:;]/
+      };
+      var i = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g, n = e.languages["markup-templating"];
+      e.hooks.add("before-tokenize", function(a) {
+        n.buildPlaceholders(a, "django", i);
+      }), e.hooks.add("after-tokenize", function(a) {
+        n.tokenizePlaceholders(a, "django");
+      }), e.languages.jinja2 = e.languages.django, e.hooks.add("before-tokenize", function(a) {
+        n.buildPlaceholders(a, "jinja2", i);
+      }), e.hooks.add("after-tokenize", function(a) {
+        n.tokenizePlaceholders(a, "jinja2");
+      });
+    }(r);
+  }
+  return t;
+}
+export {
+  g as __require
+};

package/dist/es/node_modules/refractor/lang/dns-zone-file.mjs

@@ -0,0 +1,40 @@
+var S, N;
+function a() {
+  if (N)
+    return S;
+  N = 1, S = e, e.displayName = "dnsZoneFile", e.aliases = [];
+  function e(n) {
+    n.languages["dns-zone-file"] = {
+      comment: /;.*/,
+      string: {
+        pattern: /"(?:\\.|[^"\\\r\n])*"/,
+        greedy: !0
+      },
+      variable: [{
+        pattern: /(^\$ORIGIN[ \t]+)\S+/m,
+        lookbehind: !0
+      }, {
+        pattern: /(^|\s)@(?=\s|$)/,
+        lookbehind: !0
+      }],
+      keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
+      class: {
+        // https://tools.ietf.org/html/rfc1035#page-13
+        pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      type: {
+        // https://en.wikipedia.org/wiki/List_of_DNS_record_types
+        pattern: /(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      punctuation: /[()]/
+    }, n.languages["dns-zone"] = n.languages["dns-zone-file"];
+  }
+  return S;
+}
+export {
+  a as __require
+};

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

@@ -0,0 +1,83 @@
+var o, c;
+function l() {
+  if (c)
+    return o;
+  c = 1, o = r, r.displayName = "docker", r.aliases = ["dockerfile"];
+  function r(s) {
+    (function(t) {
+      var S = /\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source, d = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(/<SP_BS>/g, function() {
+        return S;
+      }), u = /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/.source, p = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(/<STR>/g, function() {
+        return u;
+      }), a = {
+        pattern: RegExp(u),
+        greedy: !0
+      }, i = {
+        pattern: /(^[ \t]*)#.*/m,
+        lookbehind: !0,
+        greedy: !0
+      };
+      function e(n, g) {
+        return n = n.replace(/<OPT>/g, function() {
+          return p;
+        }).replace(/<SP>/g, function() {
+          return d;
+        }), RegExp(n, g);
+      }
+      t.languages.docker = {
+        instruction: {
+          pattern: /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            options: {
+              pattern: e(/(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source, "i"),
+              lookbehind: !0,
+              greedy: !0,
+              inside: {
+                property: {
+                  pattern: /(^|\s)--[\w-]+/,
+                  lookbehind: !0
+                },
+                string: [a, {
+                  pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
+                  lookbehind: !0
+                }],
+                operator: /\\$/m,
+                punctuation: /=/
+              }
+            },
+            keyword: [{
+              // https://docs.docker.com/engine/reference/builder/#healthcheck
+              pattern: e(/(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/.source, "i"),
+              lookbehind: !0,
+              greedy: !0
+            }, {
+              // https://docs.docker.com/engine/reference/builder/#from
+              pattern: e(/(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/.source, "i"),
+              lookbehind: !0,
+              greedy: !0
+            }, {
+              // https://docs.docker.com/engine/reference/builder/#onbuild
+              pattern: e(/(^ONBUILD<SP>)\w+/.source, "i"),
+              lookbehind: !0,
+              greedy: !0
+            }, {
+              pattern: /^\w+/,
+              greedy: !0
+            }],
+            comment: i,
+            string: a,
+            variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
+            operator: /\\$/m
+          }
+        },
+        comment: i
+      }, t.languages.dockerfile = t.languages.docker;
+    })(s);
+  }
+  return o;
+}
+export {
+  l as __require
+};

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

@@ -0,0 +1,75 @@
+var n, u;
+function g() {
+  if (u)
+    return n;
+  u = 1, n = a, a.displayName = "dot", a.aliases = ["gv"];
+  function a(o) {
+    (function(e) {
+      var i = "(?:" + [
+        // an identifier
+        /[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source,
+        // a number
+        /-?(?:\.\d+|\d+(?:\.\d*)?)/.source,
+        // a double-quoted string
+        /"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source,
+        // HTML-like string
+        /<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/.source
+      ].join("|") + ")", r = {
+        markup: {
+          pattern: /(^<)[\s\S]+(?=>$)/,
+          lookbehind: !0,
+          alias: ["language-markup", "language-html", "language-xml"],
+          inside: e.languages.markup
+        }
+      };
+      function t(s, d) {
+        return RegExp(s.replace(/<ID>/g, function() {
+          return i;
+        }), d);
+      }
+      e.languages.dot = {
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
+          greedy: !0
+        },
+        "graph-name": {
+          pattern: t(/(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source, "i"),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "class-name",
+          inside: r
+        },
+        "attr-value": {
+          pattern: t(/(=[ \t\r\n]*)<ID>/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: r
+        },
+        "attr-name": {
+          pattern: t(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: r
+        },
+        keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
+        "compass-point": {
+          pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
+          lookbehind: !0,
+          alias: "builtin"
+        },
+        node: {
+          pattern: t(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: r
+        },
+        operator: /[=:]|-[->]/,
+        punctuation: /[\[\]{};,]/
+      }, e.languages.gv = e.languages.dot;
+    })(o);
+  }
+  return n;
+}
+export {
+  g as __require
+};

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

@@ -0,0 +1,32 @@
+var r, n;
+function t() {
+  if (n)
+    return r;
+  n = 1, r = e, e.displayName = "ebnf", e.aliases = [];
+  function e(a) {
+    a.languages.ebnf = {
+      comment: /\(\*[\s\S]*?\*\)/,
+      string: {
+        pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+        greedy: !0
+      },
+      special: {
+        pattern: /\?[^?\r\n]*\?/,
+        greedy: !0,
+        alias: "class-name"
+      },
+      definition: {
+        pattern: /^([\t ]*)[a-z]\w*(?:[ \t]+[a-z]\w*)*(?=\s*=)/im,
+        lookbehind: !0,
+        alias: ["rule", "keyword"]
+      },
+      rule: /\b[a-z]\w*(?:[ \t]+[a-z]\w*)*\b/i,
+      punctuation: /\([:/]|[:/]\)|[.,;()[\]{}]/,
+      operator: /[-=|*/!]/
+    };
+  }
+  return r;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,39 @@
+var t, i;
+function a() {
+  if (i)
+    return t;
+  i = 1, t = e, e.displayName = "editorconfig", e.aliases = [];
+  function e(r) {
+    r.languages.editorconfig = {
+      // https://editorconfig-specification.readthedocs.io
+      comment: /[;#].*/,
+      section: {
+        pattern: /(^[ \t]*)\[.+\]/m,
+        lookbehind: !0,
+        alias: "selector",
+        inside: {
+          regex: /\\\\[\[\]{},!?.*]/,
+          // Escape special characters with '\\'
+          operator: /[!?]|\.\.|\*{1,2}/,
+          punctuation: /[\[\]{},]/
+        }
+      },
+      key: {
+        pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
+        lookbehind: !0,
+        alias: "attr-name"
+      },
+      value: {
+        pattern: /=.*/,
+        alias: "attr-value",
+        inside: {
+          punctuation: /^=/
+        }
+      }
+    };
+  }
+  return t;
+}
+export {
+  a as __require
+};

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

@@ -0,0 +1,46 @@
+var r, a;
+function t() {
+  if (a)
+    return r;
+  a = 1, r = e, e.displayName = "eiffel", e.aliases = [];
+  function e(n) {
+    n.languages.eiffel = {
+      comment: /--.*/,
+      string: [
+        // Aligned-verbatim-strings
+        {
+          pattern: /"([^[]*)\[[\s\S]*?\]\1"/,
+          greedy: !0
+        },
+        // Non-aligned-verbatim-strings
+        {
+          pattern: /"([^{]*)\{[\s\S]*?\}\1"/,
+          greedy: !0
+        },
+        // Single-line string
+        {
+          pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
+          greedy: !0
+        }
+      ],
+      // normal char | special char | char code
+      char: /'(?:%.|[^%'\r\n])+'/,
+      keyword: /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
+      boolean: /\b(?:False|True)\b/i,
+      // Convention: class-names are always all upper-case characters
+      "class-name": /\b[A-Z][\dA-Z_]*\b/,
+      number: [
+        // hexa | octal | bin
+        /\b0[xcb][\da-f](?:_*[\da-f])*\b/i,
+        // Decimal
+        /(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
+      ],
+      punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
+      operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/
+    };
+  }
+  return r;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,33 @@
+import { __require as o } from "./markup-templating.mjs";
+var n, s;
+function l() {
+  if (s)
+    return n;
+  s = 1;
+  var u = o();
+  n = a, a.displayName = "ejs", a.aliases = ["eta"];
+  function a(r) {
+    r.register(u), function(e) {
+      e.languages.ejs = {
+        delimiter: {
+          pattern: /^<%[-_=]?|[-_]?%>$/,
+          alias: "punctuation"
+        },
+        comment: /^#[\s\S]*/,
+        "language-javascript": {
+          pattern: /[\s\S]+/,
+          inside: e.languages.javascript
+        }
+      }, e.hooks.add("before-tokenize", function(t) {
+        var i = /<%(?!%)[\s\S]+?%>/g;
+        e.languages["markup-templating"].buildPlaceholders(t, "ejs", i);
+      }), e.hooks.add("after-tokenize", function(t) {
+        e.languages["markup-templating"].tokenizePlaceholders(t, "ejs");
+      }), e.languages.eta = e.languages.ejs;
+    }(r);
+  }
+  return n;
+}
+export {
+  l as __require
+};

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

@@ -0,0 +1,100 @@
+var t, n;
+function i() {
+  if (n)
+    return t;
+  n = 1, t = e, e.displayName = "elixir", e.aliases = [];
+  function e(r) {
+    r.languages.elixir = {
+      doc: {
+        pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
+        inside: {
+          attribute: /^@\w+/,
+          string: /['"][\s\S]+/
+        }
+      },
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
+      regex: {
+        pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
+        greedy: !0
+      },
+      string: [{
+        // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
+        pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
+        greedy: !0,
+        inside: {
+          // See interpolation below
+        }
+      }, {
+        pattern: /("""|''')[\s\S]*?\1/,
+        greedy: !0,
+        inside: {
+          // See interpolation below
+        }
+      }, {
+        // Multi-line strings are allowed
+        pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0,
+        inside: {
+          // See interpolation below
+        }
+      }],
+      atom: {
+        // Look-behind prevents bad highlighting of the :: operator
+        pattern: /(^|[^:]):\w+/,
+        lookbehind: !0,
+        alias: "symbol"
+      },
+      module: {
+        pattern: /\b[A-Z]\w*\b/,
+        alias: "class-name"
+      },
+      // Look-ahead prevents bad highlighting of the :: operator
+      "attr-name": /\b\w+\??:(?!:)/,
+      argument: {
+        // Look-behind prevents bad highlighting of the && operator
+        pattern: /(^|[^&])&\d+/,
+        lookbehind: !0,
+        alias: "variable"
+      },
+      attribute: {
+        pattern: /@\w+/,
+        alias: "variable"
+      },
+      function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
+      number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
+      keyword: /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
+      boolean: /\b(?:false|nil|true)\b/,
+      operator: [/\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/, {
+        // We don't want to match <<
+        pattern: /([^<])<(?!<)/,
+        lookbehind: !0
+      }, {
+        // We don't want to match >>
+        pattern: /([^>])>(?!>)/,
+        lookbehind: !0
+      }],
+      punctuation: /<<|>>|[.,%\[\]{}()]/
+    }, r.languages.elixir.string.forEach(function(a) {
+      a.inside = {
+        interpolation: {
+          pattern: /#\{[^}]+\}/,
+          inside: {
+            delimiter: {
+              pattern: /^#\{|\}$/,
+              alias: "punctuation"
+            },
+            rest: r.languages.elixir
+          }
+        }
+      };
+    });
+  }
+  return t;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,54 @@
+var r, a;
+function n() {
+  if (a)
+    return r;
+  a = 1, r = e, e.displayName = "elm", e.aliases = [];
+  function e(t) {
+    t.languages.elm = {
+      comment: /--.*|\{-[\s\S]*?-\}/,
+      char: {
+        pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
+        greedy: !0
+      },
+      string: [{
+        // Multiline strings are wrapped in triple ". Quotes may appear unescaped.
+        pattern: /"""[\s\S]*?"""/,
+        greedy: !0
+      }, {
+        pattern: /"(?:[^\\"\r\n]|\\.)*"/,
+        greedy: !0
+      }],
+      "import-statement": {
+        // The imported or hidden names are not included in this import
+        // statement. This is because we want to highlight those exactly like
+        // we do for the names in the program.
+        pattern: /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
+        lookbehind: !0,
+        inside: {
+          keyword: /\b(?:as|exposing|import)\b/
+        }
+      },
+      keyword: /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
+      // These are builtin variables only. Constructors are highlighted later as a constant.
+      builtin: /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
+      // decimal integers and floating point numbers | hexadecimal integers
+      number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
+      // Most of this is needed because of the meaning of a single '.'.
+      // If it stands alone freely, it is the function composition.
+      // It may also be a separator between a module name and an identifier => no
+      // operator. If it comes together with other special characters it is an
+      // operator too.
+      // Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!
+      // Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ
+      operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
+      // In Elm, nearly everything is a variable, do not highlight these.
+      hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
+      constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
+      punctuation: /[{}[\]|(),.:]/
+    };
+  }
+  return r;
+}
+export {
+  n as __require
+};

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

@@ -0,0 +1,35 @@
+import { __require as b } from "./ruby.mjs";
+import { __require as g } from "./markup-templating.mjs";
+var t, u;
+function d() {
+  if (u)
+    return t;
+  u = 1;
+  var i = b(), o = g();
+  t = r, r.displayName = "erb", r.aliases = [];
+  function r(a) {
+    a.register(i), a.register(o), function(e) {
+      e.languages.erb = {
+        delimiter: {
+          pattern: /^(\s*)<%=?|%>(?=\s*$)/,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        ruby: {
+          pattern: /\s*\S[\s\S]*/,
+          alias: "language-ruby",
+          inside: e.languages.ruby
+        }
+      }, e.hooks.add("before-tokenize", function(n) {
+        var l = /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
+        e.languages["markup-templating"].buildPlaceholders(n, "erb", l);
+      }), e.hooks.add("after-tokenize", function(n) {
+        e.languages["markup-templating"].tokenizePlaceholders(n, "erb");
+      });
+    }(a);
+  }
+  return t;
+}
+export {
+  d as __require
+};

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

@@ -0,0 +1,47 @@
+var r, a;
+function t() {
+  if (a)
+    return r;
+  a = 1, r = e, e.displayName = "erlang", e.aliases = [];
+  function e(n) {
+    n.languages.erlang = {
+      comment: /%.+/,
+      string: {
+        pattern: /"(?:\\.|[^\\"\r\n])*"/,
+        greedy: !0
+      },
+      "quoted-function": {
+        pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
+        alias: "function"
+      },
+      "quoted-atom": {
+        pattern: /'(?:\\.|[^\\'\r\n])+'/,
+        alias: "atom"
+      },
+      boolean: /\b(?:false|true)\b/,
+      keyword: /\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,
+      number: [/\$\\?./, /\b\d+#[a-z0-9]+/i, /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i],
+      function: /\b[a-z][\w@]*(?=\()/,
+      variable: {
+        // Look-behind is used to prevent wrong highlighting of atoms containing "@"
+        pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
+        lookbehind: !0
+      },
+      operator: [/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/, {
+        // We don't want to match <<
+        pattern: /(^|[^<])<(?!<)/,
+        lookbehind: !0
+      }, {
+        // We don't want to match >>
+        pattern: /(^|[^>])>(?!>)/,
+        lookbehind: !0
+      }],
+      atom: /\b[a-z][\w@]*/,
+      punctuation: /[()[\]{}:;,.#|]|<<|>>/
+    };
+  }
+  return r;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,33 @@
+import { __require as g } from "./lua.mjs";
+import { __require as p } from "./markup-templating.mjs";
+var u, n;
+function d() {
+  if (n)
+    return u;
+  n = 1;
+  var l = g(), i = p();
+  u = a, a.displayName = "etlua", a.aliases = [];
+  function a(r) {
+    r.register(l), r.register(i), function(e) {
+      e.languages.etlua = {
+        delimiter: {
+          pattern: /^<%[-=]?|-?%>$/,
+          alias: "punctuation"
+        },
+        "language-lua": {
+          pattern: /[\s\S]+/,
+          inside: e.languages.lua
+        }
+      }, e.hooks.add("before-tokenize", function(t) {
+        var o = /<%[\s\S]+?%>/g;
+        e.languages["markup-templating"].buildPlaceholders(t, "etlua", o);
+      }), e.hooks.add("after-tokenize", function(t) {
+        e.languages["markup-templating"].tokenizePlaceholders(t, "etlua");
+      });
+    }(r);
+  }
+  return u;
+}
+export {
+  d as __require
+};