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

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

@@ -0,0 +1,57 @@
+var I, o;
+function t() {
+  if (o)
+    return I;
+  o = 1, I = e, e.displayName = "lolcode", e.aliases = [];
+  function e(r) {
+    r.languages.lolcode = {
+      comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
+      string: {
+        pattern: /"(?::.|[^":])*"/,
+        inside: {
+          variable: /:\{[^}]+\}/,
+          symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/]
+        },
+        greedy: !0
+      },
+      number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/,
+      symbol: {
+        pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/,
+        lookbehind: !0,
+        inside: {
+          keyword: /A(?=\s)/
+        }
+      },
+      label: {
+        pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
+        lookbehind: !0,
+        alias: "string"
+      },
+      function: {
+        pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/,
+        lookbehind: !0
+      },
+      keyword: [{
+        pattern: /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/,
+        lookbehind: !0
+      }, /'Z(?=\s|,|$)/],
+      boolean: {
+        pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/,
+        lookbehind: !0
+      },
+      variable: {
+        pattern: /(^|\s)IT(?=\s|,|$)/,
+        lookbehind: !0
+      },
+      operator: {
+        pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/,
+        lookbehind: !0
+      },
+      punctuation: /\.{3}|…|,|!/
+    };
+  }
+  return I;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,29 @@
+var r, n;
+function t() {
+  if (n)
+    return r;
+  n = 1, r = e, e.displayName = "lua", e.aliases = [];
+  function e(a) {
+    a.languages.lua = {
+      comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
+      // \z may be used to skip the following space
+      string: {
+        pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
+        greedy: !0
+      },
+      number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+      keyword: /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
+      function: /(?!\d)\w+(?=\s*(?:[({]))/,
+      operator: [/[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/, {
+        // Match ".." but don't break "..."
+        pattern: /(^|[^.])\.\.(?!\.)/,
+        lookbehind: !0
+      }],
+      punctuation: /[\[\](){},;]|\.+|:+/
+    };
+  }
+  return r;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,42 @@
+var r, t;
+function n() {
+  if (t)
+    return r;
+  t = 1, r = e, e.displayName = "magma", e.aliases = [];
+  function e(a) {
+    a.languages.magma = {
+      output: {
+        pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+        lookbehind: !0,
+        greedy: !0
+      },
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+        greedy: !0
+      },
+      string: {
+        pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      // http://magma.maths.usyd.edu.au/magma/handbook/text/82
+      keyword: /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/,
+      boolean: /\b(?:false|true)\b/,
+      generator: {
+        pattern: /\b[a-z_]\w*(?=\s*<)/i,
+        alias: "class-name"
+      },
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      number: {
+        pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+        lookbehind: !0
+      },
+      operator: /->|[-+*/^~!|#=]|:=|\.\./,
+      punctuation: /[()[\]{}<>,;.:]/
+    };
+  }
+  return r;
+}
+export {
+  n as __require
+};

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

@@ -0,0 +1,42 @@
+var i, r;
+function t() {
+  if (r)
+    return i;
+  r = 1, i = e, e.displayName = "makefile", e.aliases = [];
+  function e(a) {
+    a.languages.makefile = {
+      comment: {
+        pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+        lookbehind: !0
+      },
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      "builtin-target": {
+        pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+        alias: "builtin"
+      },
+      target: {
+        pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+        alias: "symbol",
+        inside: {
+          variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+        }
+      },
+      variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+      // Directives
+      keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+      function: {
+        pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+        lookbehind: !0
+      },
+      operator: /(?:::|[?:+!])?=|[|@]/,
+      punctuation: /[:;(){}]/
+    };
+  }
+  return i;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,306 @@
+var h, k;
+function $() {
+  if (k)
+    return h;
+  k = 1, h = g, g.displayName = "markdown", g.aliases = ["md"];
+  function g(_) {
+    (function(e) {
+      var m = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+      function p(n) {
+        return n = n.replace(/<inner>/g, function() {
+          return m;
+        }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + n + ")");
+      }
+      var c = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, d = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
+        return c;
+      }), b = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+      e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", {
+        "front-matter-block": {
+          pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            punctuation: /^---|---$/,
+            "front-matter": {
+              pattern: /\S+(?:\s+\S+)*/,
+              alias: ["yaml", "language-yaml"],
+              inside: e.languages.yaml
+            }
+          }
+        },
+        blockquote: {
+          // > ...
+          pattern: /^>(?:[\t ]*>)*/m,
+          alias: "punctuation"
+        },
+        table: {
+          pattern: RegExp("^" + d + b + "(?:" + d + ")*", "m"),
+          inside: {
+            "table-data-rows": {
+              pattern: RegExp("^(" + d + b + ")(?:" + d + ")*$"),
+              lookbehind: !0,
+              inside: {
+                "table-data": {
+                  pattern: RegExp(c),
+                  inside: e.languages.markdown
+                },
+                punctuation: /\|/
+              }
+            },
+            "table-line": {
+              pattern: RegExp("^(" + d + ")" + b + "$"),
+              lookbehind: !0,
+              inside: {
+                punctuation: /\||:?-{3,}:?/
+              }
+            },
+            "table-header-row": {
+              pattern: RegExp("^" + d + "$"),
+              inside: {
+                "table-header": {
+                  pattern: RegExp(c),
+                  alias: "important",
+                  inside: e.languages.markdown
+                },
+                punctuation: /\|/
+              }
+            }
+          }
+        },
+        code: [{
+          // Prefixed by 4 spaces or 1 tab and preceded by an empty line
+          pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+          lookbehind: !0,
+          alias: "keyword"
+        }, {
+          // ```optional language
+          // code block
+          // ```
+          pattern: /^```[\s\S]*?^```$/m,
+          greedy: !0,
+          inside: {
+            "code-block": {
+              pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+              lookbehind: !0
+            },
+            "code-language": {
+              pattern: /^(```).+/,
+              lookbehind: !0
+            },
+            punctuation: /```/
+          }
+        }],
+        title: [{
+          // title 1
+          // =======
+          // title 2
+          // -------
+          pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+          alias: "important",
+          inside: {
+            punctuation: /==+$|--+$/
+          }
+        }, {
+          // # title 1
+          // ###### title 6
+          pattern: /(^\s*)#.+/m,
+          lookbehind: !0,
+          alias: "important",
+          inside: {
+            punctuation: /^#+|#+$/
+          }
+        }],
+        hr: {
+          // ***
+          // ---
+          // * * *
+          // -----------
+          pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        list: {
+          // * item
+          // + item
+          // - item
+          // 1. item
+          pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        "url-reference": {
+          // [id]: http://example.com "Optional title"
+          // [id]: http://example.com 'Optional title'
+          // [id]: http://example.com (Optional title)
+          // [id]: <http://example.com> "Optional title"
+          pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+          inside: {
+            variable: {
+              pattern: /^(!?\[)[^\]]+/,
+              lookbehind: !0
+            },
+            string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+            punctuation: /^[\[\]!:]|[<>]/
+          },
+          alias: "url"
+        },
+        bold: {
+          // **strong**
+          // __strong__
+          // allow one nested instance of italic text using the same delimiter
+          pattern: p(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /(^..)[\s\S]+(?=..$)/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            punctuation: /\*\*|__/
+          }
+        },
+        italic: {
+          // *em*
+          // _em_
+          // allow one nested instance of bold text using the same delimiter
+          pattern: p(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /(^.)[\s\S]+(?=.$)/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            punctuation: /[*_]/
+          }
+        },
+        strike: {
+          // ~~strike through~~
+          // ~strike~
+          // eslint-disable-next-line regexp/strict
+          pattern: p(/(~~?)(?:(?!~)<inner>)+\2/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /(^~~?)[\s\S]+(?=\1$)/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            punctuation: /~~?/
+          }
+        },
+        "code-snippet": {
+          // `code`
+          // ``code``
+          pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+          lookbehind: !0,
+          greedy: !0,
+          alias: ["code", "keyword"]
+        },
+        url: {
+          // [example](http://example.com "Optional title")
+          // [example][id]
+          // [example] [id]
+          pattern: p(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            operator: /^!/,
+            content: {
+              pattern: /(^\[)[^\]]+(?=\])/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            variable: {
+              pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+              lookbehind: !0
+            },
+            url: {
+              pattern: /(^\]\()[^\s)]+/,
+              lookbehind: !0
+            },
+            string: {
+              pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+              lookbehind: !0
+            }
+          }
+        }
+      }), ["url", "bold", "italic", "strike"].forEach(function(n) {
+        ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(t) {
+          n !== t && (e.languages.markdown[n].inside.content.inside[t] = e.languages.markdown[t]);
+        });
+      }), e.hooks.add("after-tokenize", function(n) {
+        if (n.language !== "markdown" && n.language !== "md")
+          return;
+        function t(i) {
+          if (!(!i || typeof i == "string"))
+            for (var r = 0, u = i.length; r < u; r++) {
+              var o = i[r];
+              if (o.type !== "code") {
+                t(o.content);
+                continue;
+              }
+              var l = o.content[1], a = o.content[3];
+              if (l && a && l.type === "code-language" && a.type === "code-block" && typeof l.content == "string") {
+                var s = l.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+                s = (/[a-z][\w-]*/i.exec(s) || [""])[0].toLowerCase();
+                var f = "language-" + s;
+                a.alias ? typeof a.alias == "string" ? a.alias = [a.alias, f] : a.alias.push(f) : a.alias = [f];
+              }
+            }
+        }
+        t(n.tokens);
+      }), e.hooks.add("wrap", function(n) {
+        if (n.type === "code-block") {
+          for (var t = "", i = 0, r = n.classes.length; i < r; i++) {
+            var u = n.classes[i], o = /language-(.+)/.exec(u);
+            if (o) {
+              t = o[1];
+              break;
+            }
+          }
+          var l = e.languages[t];
+          if (l)
+            n.content = e.highlight(x(n.content.value), l, t);
+          else if (t && t !== "none" && e.plugins.autoloader) {
+            var a = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
+            n.attributes.id = a, e.plugins.autoloader.loadLanguages(t, function() {
+              var s = document.getElementById(a);
+              s && (s.innerHTML = e.highlight(s.textContent, e.languages[t], t));
+            });
+          }
+        }
+      });
+      var w = RegExp(e.languages.markup.tag.pattern.source, "gi"), y = {
+        amp: "&",
+        lt: "<",
+        gt: ">",
+        quot: '"'
+      }, v = String.fromCodePoint || String.fromCharCode;
+      function x(n) {
+        var t = n.replace(w, "");
+        return t = t.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(i, r) {
+          if (r = r.toLowerCase(), r[0] === "#") {
+            var u;
+            return r[1] === "x" ? u = parseInt(r.slice(2), 16) : u = Number(r.slice(1)), v(u);
+          } else {
+            var o = y[r];
+            return o || i;
+          }
+        }), t;
+      }
+      e.languages.md = e.languages.markdown;
+    })(_);
+  }
+  return h;
+}
+export {
+  $ as __require
+};

package/dist/es/node_modules/refractor/lang/markup-templating.mjs

@@ -0,0 +1,74 @@
+var s, T;
+function S() {
+  if (T)
+    return s;
+  T = 1, s = c, c.displayName = "markupTemplating", c.aliases = [];
+  function c(m) {
+    (function(f) {
+      function k(r, t) {
+        return "___" + r.toUpperCase() + t + "___";
+      }
+      Object.defineProperties(f.languages["markup-templating"] = {}, {
+        buildPlaceholders: {
+          /**
+           * Tokenize all inline templating expressions matching `placeholderPattern`.
+           *
+           * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+           * `true` will be replaced.
+           *
+           * @param {object} env The environment of the `before-tokenize` hook.
+           * @param {string} language The language id.
+           * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+           * @param {(match: string) => boolean} [replaceFilter]
+           */
+          value: function(r, t, o, p) {
+            if (r.language === t) {
+              var u = r.tokenStack = [];
+              r.code = r.code.replace(o, function(n) {
+                if (typeof p == "function" && !p(n))
+                  return n;
+                for (var i = u.length, a; r.code.indexOf(a = k(t, i)) !== -1; )
+                  ++i;
+                return u[i] = n, a;
+              }), r.grammar = f.languages.markup;
+            }
+          }
+        },
+        tokenizePlaceholders: {
+          /**
+           * Replace placeholders with proper tokens after tokenizing.
+           *
+           * @param {object} env The environment of the `after-tokenize` hook.
+           * @param {string} language The language id.
+           */
+          value: function(r, t) {
+            if (r.language !== t || !r.tokenStack)
+              return;
+            r.grammar = f.languages[t];
+            var o = 0, p = Object.keys(r.tokenStack);
+            function u(n) {
+              for (var i = 0; i < n.length && !(o >= p.length); i++) {
+                var a = n[i];
+                if (typeof a == "string" || a.content && typeof a.content == "string") {
+                  var y = p[o], d = r.tokenStack[y], l = typeof a == "string" ? a : a.content, h = k(t, y), g = l.indexOf(h);
+                  if (g > -1) {
+                    ++o;
+                    var v = l.substring(0, g), b = new f.Token(t, f.tokenize(d, r.grammar), "language-" + t, d), _ = l.substring(g + h.length), e = [];
+                    v && e.push.apply(e, u([v])), e.push(b), _ && e.push.apply(e, u([_])), typeof a == "string" ? n.splice.apply(n, [i, 1].concat(e)) : a.content = e;
+                  }
+                } else
+                  a.content && u(a.content);
+              }
+              return n;
+            }
+            u(r.tokens);
+          }
+        }
+      });
+    })(m);
+  }
+  return s;
+}
+export {
+  S as __require
+};