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

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

@@ -1,80 +0,0 @@
-var n, t;
-function o() {
-  if (t)
-    return n;
-  t = 1, n = r, r.displayName = "parser", r.aliases = [];
-  function r(i) {
-    (function(a) {
-      var e = a.languages.parser = a.languages.extend("markup", {
-        keyword: {
-          pattern: /(^|[^^])(?:\^(?:case|eval|for|if|switch|throw)\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\b)/,
-          lookbehind: !0
-        },
-        variable: {
-          pattern: /(^|[^^])\B\$(?:\w+|(?=[.{]))(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\.|:+/
-          }
-        },
-        function: {
-          pattern: /(^|[^^])\B[@^]\w+(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
-          lookbehind: !0,
-          inside: {
-            keyword: {
-              pattern: /(^@)(?:GET_|SET_)/,
-              lookbehind: !0
-            },
-            punctuation: /\.|:+/
-          }
-        },
-        escape: {
-          pattern: /\^(?:[$^;@()\[\]{}"':]|#[a-f\d]*)/i,
-          alias: "builtin"
-        },
-        punctuation: /[\[\](){};]/
-      });
-      e = a.languages.insertBefore("parser", "keyword", {
-        "parser-comment": {
-          pattern: /(\s)#.*/,
-          lookbehind: !0,
-          alias: "comment"
-        },
-        expression: {
-          // Allow for 3 levels of depth
-          pattern: /(^|[^^])\((?:[^()]|\((?:[^()]|\((?:[^()])*\))*\))*\)/,
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            string: {
-              pattern: /(^|[^^])(["'])(?:(?!\2)[^^]|\^[\s\S])*\2/,
-              lookbehind: !0
-            },
-            keyword: e.keyword,
-            variable: e.variable,
-            function: e.function,
-            boolean: /\b(?:false|true)\b/,
-            number: /\b(?:0x[a-f\d]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?)\b/i,
-            escape: e.escape,
-            operator: /[~+*\/\\%]|!(?:\|\|?|=)?|&&?|\|\|?|==|<[<=]?|>[>=]?|-[fd]?|\b(?:def|eq|ge|gt|in|is|le|lt|ne)\b/,
-            punctuation: e.punctuation
-          }
-        }
-      }), a.languages.insertBefore("inside", "punctuation", {
-        expression: e.expression,
-        keyword: e.keyword,
-        variable: e.variable,
-        function: e.function,
-        escape: e.escape,
-        "parser-punctuation": {
-          pattern: e.punctuation,
-          alias: "punctuation"
-        }
-      }, e.tag.inside["attr-value"]);
-    })(i);
-  }
-  return n;
-}
-export {
-  o as __require
-};

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

@@ -1,66 +0,0 @@
-var r, t;
-function n() {
-  if (t)
-    return r;
-  t = 1, r = a, a.displayName = "pascal", a.aliases = ["objectpascal"];
-  function a(e) {
-    e.languages.pascal = {
-      directive: {
-        pattern: /\{\$[\s\S]*?\}/,
-        greedy: !0,
-        alias: ["marco", "property"]
-      },
-      comment: {
-        pattern: /\(\*[\s\S]*?\*\)|\{[\s\S]*?\}|\/\/.*/,
-        greedy: !0
-      },
-      string: {
-        pattern: /(?:'(?:''|[^'\r\n])*'(?!')|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
-        greedy: !0
-      },
-      asm: {
-        pattern: /(\basm\b)[\s\S]+?(?=\bend\s*[;[])/i,
-        lookbehind: !0,
-        greedy: !0,
-        inside: null
-        // see below
-      },
-      keyword: [{
-        // Turbo Pascal
-        pattern: /(^|[^&])\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\b/i,
-        lookbehind: !0
-      }, {
-        // Free Pascal
-        pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,
-        lookbehind: !0
-      }, {
-        // Object Pascal
-        pattern: /(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
-        lookbehind: !0
-      }, {
-        // Modifiers
-        pattern: /(^|[^&])\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\b/i,
-        lookbehind: !0
-      }],
-      number: [
-        // Hexadecimal, octal and binary
-        /(?:[&%]\d+|\$[a-f\d]+)/i,
-        // Decimal
-        /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i
-      ],
-      operator: [/\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/, {
-        pattern: /(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,
-        lookbehind: !0
-      }],
-      punctuation: /\(\.|\.\)|[()\[\]:;,.]/
-    }, e.languages.pascal.asm.inside = e.languages.extend("pascal", {
-      asm: void 0,
-      keyword: void 0,
-      operator: void 0
-    }), e.languages.objectpascal = e.languages.pascal;
-  }
-  return r;
-}
-export {
-  n as __require
-};

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

@@ -1,70 +0,0 @@
-var t, o;
-function p() {
-  if (o)
-    return t;
-  o = 1, t = n, n.displayName = "pascaligo", n.aliases = [];
-  function n(s) {
-    (function(u) {
-      var c = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source, r = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(/<braces>/g, function() {
-        return c;
-      }), i = u.languages.pascaligo = {
-        comment: /\(\*[\s\S]+?\*\)|\/\/.*/,
-        string: {
-          pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,
-          greedy: !0
-        },
-        "class-name": [{
-          pattern: RegExp(/(\btype\s+\w+\s+is\s+)<type>/.source.replace(/<type>/g, function() {
-            return r;
-          }), "i"),
-          lookbehind: !0,
-          inside: null
-          // see below
-        }, {
-          pattern: RegExp(/<type>(?=\s+is\b)/.source.replace(/<type>/g, function() {
-            return r;
-          }), "i"),
-          inside: null
-          // see below
-        }, {
-          pattern: RegExp(/(:\s*)<type>/.source.replace(/<type>/g, function() {
-            return r;
-          })),
-          lookbehind: !0,
-          inside: null
-          // see below
-        }],
-        keyword: {
-          pattern: /(^|[^&])\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\b/i,
-          lookbehind: !0
-        },
-        boolean: {
-          pattern: /(^|[^&])\b(?:False|True)\b/i,
-          lookbehind: !0
-        },
-        builtin: {
-          pattern: /(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,
-          lookbehind: !0
-        },
-        function: /\b\w+(?=\s*\()/,
-        number: [
-          // Hexadecimal, octal and binary
-          /%[01]+|&[0-7]+|\$[a-f\d]+/i,
-          // Decimal
-          /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?(?:mtz|n)?/i
-        ],
-        operator: /->|=\/=|\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=|]|\b(?:and|mod|or)\b/,
-        punctuation: /\(\.|\.\)|[()\[\]:;,.{}]/
-      }, l = ["comment", "keyword", "builtin", "operator", "punctuation"].reduce(function(e, a) {
-        return e[a] = i[a], e;
-      }, {});
-      i["class-name"].forEach(function(e) {
-        e.inside = l;
-      });
-    })(s);
-  }
-  return t;
-}
-export {
-  p as __require
-};

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

@@ -1,63 +0,0 @@
-var r, a;
-function n() {
-  if (a)
-    return r;
-  a = 1, r = e, e.displayName = "pcaxis", e.aliases = ["px"];
-  function e(t) {
-    t.languages.pcaxis = {
-      string: /"[^"]*"/,
-      keyword: {
-        pattern: /((?:^|;)\s*)[-A-Z\d]+(?:\s*\[[-\w]+\])?(?:\s*\("[^"]*"(?:,\s*"[^"]*")*\))?(?=\s*=)/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          keyword: /^[-A-Z\d]+/,
-          language: {
-            pattern: /^(\s*)\[[-\w]+\]/,
-            lookbehind: !0,
-            inside: {
-              punctuation: /^\[|\]$/,
-              property: /[-\w]+/
-            }
-          },
-          "sub-key": {
-            pattern: /^(\s*)\S[\s\S]*/,
-            lookbehind: !0,
-            inside: {
-              parameter: {
-                pattern: /"[^"]*"/,
-                alias: "property"
-              },
-              punctuation: /^\(|\)$|,/
-            }
-          }
-        }
-      },
-      operator: /=/,
-      tlist: {
-        pattern: /TLIST\s*\(\s*\w+(?:(?:\s*,\s*"[^"]*")+|\s*,\s*"[^"]*"-"[^"]*")?\s*\)/,
-        greedy: !0,
-        inside: {
-          function: /^TLIST/,
-          property: {
-            pattern: /^(\s*\(\s*)\w+/,
-            lookbehind: !0
-          },
-          string: /"[^"]*"/,
-          punctuation: /[(),]/,
-          operator: /-/
-        }
-      },
-      punctuation: /[;,]/,
-      number: {
-        pattern: /(^|\s)\d+(?:\.\d+)?(?!\S)/,
-        lookbehind: !0
-      },
-      boolean: /NO|YES/
-    }, t.languages.px = t.languages.pcaxis;
-  }
-  return r;
-}
-export {
-  n as __require
-};

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

@@ -1,51 +0,0 @@
-var t, a;
-function n() {
-  if (a)
-    return t;
-  a = 1, t = e, e.displayName = "peoplecode", e.aliases = ["pcode"];
-  function e(o) {
-    o.languages.peoplecode = {
-      comment: RegExp([
-        // C-style multiline comments
-        /\/\*[\s\S]*?\*\//.source,
-        // REM comments
-        /\bREM[^;]*;/.source,
-        // Nested <* *> comments
-        /<\*(?:[^<*]|\*(?!>)|<(?!\*)|<\*(?:(?!\*>)[\s\S])*\*>)*\*>/.source,
-        // /+ +/ comments
-        /\/\+[\s\S]*?\+\//.source
-      ].join("|")),
-      string: {
-        pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
-        greedy: !0
-      },
-      variable: /%\w+/,
-      "function-definition": {
-        pattern: /((?:^|[^\w-])(?:function|method)\s+)\w+/i,
-        lookbehind: !0,
-        alias: "function"
-      },
-      "class-name": {
-        pattern: /((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,
-        lookbehind: !0,
-        inside: {
-          punctuation: /:/
-        }
-      },
-      keyword: /\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\b/i,
-      "operator-keyword": {
-        pattern: /\b(?:and|not|or)\b/i,
-        alias: "operator"
-      },
-      function: /[_a-z]\w*(?=\s*\()/i,
-      boolean: /\b(?:false|true)\b/i,
-      number: /\b\d+(?:\.\d+)?\b/,
-      operator: /<>|[<>]=?|!=|\*\*|[-+*/|=@]/,
-      punctuation: /[:.;,()[\]]/
-    }, o.languages.pcode = o.languages.peoplecode;
-  }
-  return t;
-}
-export {
-  n as __require
-};

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

@@ -1,134 +0,0 @@
-var t, s;
-function o() {
-  if (s)
-    return t;
-  s = 1, t = r, r.displayName = "perl", r.aliases = [];
-  function r(n) {
-    (function(a) {
-      var e = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source;
-      a.languages.perl = {
-        comment: [{
-          // POD
-          pattern: /(^\s*)=\w[\s\S]*?=cut.*/m,
-          lookbehind: !0,
-          greedy: !0
-        }, {
-          pattern: /(^|[^\\$])#.*/,
-          lookbehind: !0,
-          greedy: !0
-        }],
-        // TODO Could be nice to handle Heredoc too.
-        string: [
-          {
-            pattern: RegExp(/\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
-              // q/.../
-              /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-              // q a...a
-              // eslint-disable-next-line regexp/strict
-              /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
-              // q(...)
-              // q{...}
-              // q[...]
-              // q<...>
-              e
-            ].join("|") + ")"),
-            greedy: !0
-          },
-          // "...", `...`
-          {
-            pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
-            greedy: !0
-          },
-          // '...'
-          // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
-          {
-            pattern: /'(?:[^'\\\r\n]|\\.)*'/,
-            greedy: !0
-          }
-        ],
-        regex: [
-          {
-            pattern: RegExp(/\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
-              // m/.../
-              /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-              // m a...a
-              // eslint-disable-next-line regexp/strict
-              /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
-              // m(...)
-              // m{...}
-              // m[...]
-              // m<...>
-              e
-            ].join("|") + ")" + /[msixpodualngc]*/.source),
-            greedy: !0
-          },
-          // The lookbehinds prevent -s from breaking
-          {
-            pattern: RegExp(/(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
-              // s/.../.../
-              // eslint-disable-next-line regexp/strict
-              /([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
-              // s a...a...a
-              // eslint-disable-next-line regexp/strict
-              /([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source,
-              // s(...)(...)
-              // s{...}{...}
-              // s[...][...]
-              // s<...><...>
-              // s(...)[...]
-              e + /\s*/.source + e
-            ].join("|") + ")" + /[msixpodualngcer]*/.source),
-            lookbehind: !0,
-            greedy: !0
-          },
-          // /.../
-          // The look-ahead tries to prevent two divisions on
-          // the same line from being highlighted as regex.
-          // This does not support multi-line regex.
-          {
-            pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/,
-            greedy: !0
-          }
-        ],
-        // FIXME Not sure about the handling of ::, ', and #
-        variable: [
-          // ${^POSTMATCH}
-          /[&*$@%]\{\^[A-Z]+\}/,
-          // $^V
-          /[&*$@%]\^[A-Z_]/,
-          // ${...}
-          /[&*$@%]#?(?=\{)/,
-          // $foo
-          /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/,
-          // $1
-          /[&*$@%]\d+/,
-          // $_, @_, %!
-          // The negative lookahead prevents from breaking the %= operator
-          /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
-        ],
-        filehandle: {
-          // <>, <FOO>, _
-          pattern: /<(?![<=])\S*?>|\b_\b/,
-          alias: "symbol"
-        },
-        "v-string": {
-          // v1.2, 1.2.3
-          pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
-          alias: "string"
-        },
-        function: {
-          pattern: /(\bsub[ \t]+)\w+/,
-          lookbehind: !0
-        },
-        keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
-        number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
-        operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/,
-        punctuation: /[{}[\];(),:]/
-      };
-    })(n);
-  }
-  return t;
-}
-export {
-  o as __require
-};

package/dist/es/node_modules/refractor/lang/php-extras.mjs

@@ -1,29 +0,0 @@
-import { __require as s } from "./php.mjs";
-var e, t;
-function n() {
-  if (t)
-    return e;
-  t = 1;
-  var p = s();
-  e = r, r.displayName = "phpExtras", r.aliases = [];
-  function r(a) {
-    a.register(p), a.languages.insertBefore("php", "variable", {
-      this: {
-        pattern: /\$this\b/,
-        alias: "keyword"
-      },
-      global: /\$(?:GLOBALS|HTTP_RAW_POST_DATA|_(?:COOKIE|ENV|FILES|GET|POST|REQUEST|SERVER|SESSION)|argc|argv|http_response_header|php_errormsg)\b/,
-      scope: {
-        pattern: /\b[\w\\]+::/,
-        inside: {
-          keyword: /\b(?:parent|self|static)\b/,
-          punctuation: /::|\\/
-        }
-      }
-    });
-  }
-  return e;
-}
-export {
-  n as __require
-};