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

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

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

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

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

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

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

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

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