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

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

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

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

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

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

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

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