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

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

@@ -0,0 +1,199 @@
+var n, i;
+function r() {
+  if (i)
+    return n;
+  i = 1, n = t, t.displayName = "rest", t.aliases = [];
+  function t(e) {
+    e.languages.rest = {
+      table: [{
+        pattern: /(^[\t ]*)(?:\+[=-]+)+\+(?:\r?\n|\r)(?:\1[+|].+[+|](?:\r?\n|\r))+\1(?:\+[=-]+)+\+/m,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\||(?:\+[=-]+)+\+/
+        }
+      }, {
+        pattern: /(^[\t ]*)=+ [ =]*=(?:(?:\r?\n|\r)\1.+)+(?:\r?\n|\r)\1=+ [ =]*=(?=(?:\r?\n|\r){2}|\s*$)/m,
+        lookbehind: !0,
+        inside: {
+          punctuation: /[=-]+/
+        }
+      }],
+      // Directive-like patterns
+      "substitution-def": {
+        pattern: /(^[\t ]*\.\. )\|(?:[^|\s](?:[^|]*[^|\s])?)\| [^:]+::/m,
+        lookbehind: !0,
+        inside: {
+          substitution: {
+            pattern: /^\|(?:[^|\s]|[^|\s][^|]*[^|\s])\|/,
+            alias: "attr-value",
+            inside: {
+              punctuation: /^\||\|$/
+            }
+          },
+          directive: {
+            pattern: /( )(?! )[^:]+::/,
+            lookbehind: !0,
+            alias: "function",
+            inside: {
+              punctuation: /::$/
+            }
+          }
+        }
+      },
+      "link-target": [{
+        pattern: /(^[\t ]*\.\. )\[[^\]]+\]/m,
+        lookbehind: !0,
+        alias: "string",
+        inside: {
+          punctuation: /^\[|\]$/
+        }
+      }, {
+        pattern: /(^[\t ]*\.\. )_(?:`[^`]+`|(?:[^:\\]|\\.)+):/m,
+        lookbehind: !0,
+        alias: "string",
+        inside: {
+          punctuation: /^_|:$/
+        }
+      }],
+      directive: {
+        pattern: /(^[\t ]*\.\. )[^:]+::/m,
+        lookbehind: !0,
+        alias: "function",
+        inside: {
+          punctuation: /::$/
+        }
+      },
+      comment: {
+        // The two alternatives try to prevent highlighting of blank comments
+        pattern: /(^[\t ]*\.\.)(?:(?: .+)?(?:(?:\r?\n|\r).+)+| .+)(?=(?:\r?\n|\r){2}|$)/m,
+        lookbehind: !0
+      },
+      title: [
+        // Overlined and underlined
+        {
+          pattern: /^(([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+)(?:\r?\n|\r).+(?:\r?\n|\r)\1$/m,
+          inside: {
+            punctuation: /^[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+|[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+            important: /.+/
+          }
+        },
+        // Underlined only
+        {
+          pattern: /(^|(?:\r?\n|\r){2}).+(?:\r?\n|\r)([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+(?=\r?\n|\r|$)/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+            important: /.+/
+          }
+        }
+      ],
+      hr: {
+        pattern: /((?:\r?\n|\r){2})([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2{3,}(?=(?:\r?\n|\r){2})/,
+        lookbehind: !0,
+        alias: "punctuation"
+      },
+      field: {
+        pattern: /(^[\t ]*):[^:\r\n]+:(?= )/m,
+        lookbehind: !0,
+        alias: "attr-name"
+      },
+      "command-line-option": {
+        pattern: /(^[\t ]*)(?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?(?:, (?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?)*(?=(?:\r?\n|\r)? {2,}\S)/im,
+        lookbehind: !0,
+        alias: "symbol"
+      },
+      "literal-block": {
+        pattern: /::(?:\r?\n|\r){2}([ \t]+)(?![ \t]).+(?:(?:\r?\n|\r)\1.+)*/,
+        inside: {
+          "literal-block-punctuation": {
+            pattern: /^::/,
+            alias: "punctuation"
+          }
+        }
+      },
+      "quoted-literal-block": {
+        pattern: /::(?:\r?\n|\r){2}([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]).*(?:(?:\r?\n|\r)\1.*)*/,
+        inside: {
+          "literal-block-punctuation": {
+            pattern: /^(?:::|([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\1*)/m,
+            alias: "punctuation"
+          }
+        }
+      },
+      "list-bullet": {
+        pattern: /(^[\t ]*)(?:[*+\-•‣⁃]|\(?(?:\d+|[a-z]|[ivxdclm]+)\)|(?:\d+|[a-z]|[ivxdclm]+)\.)(?= )/im,
+        lookbehind: !0,
+        alias: "punctuation"
+      },
+      "doctest-block": {
+        pattern: /(^[\t ]*)>>> .+(?:(?:\r?\n|\r).+)*/m,
+        lookbehind: !0,
+        inside: {
+          punctuation: /^>>>/
+        }
+      },
+      inline: [{
+        pattern: /(^|[\s\-:\/'"<(\[{])(?::[^:]+:`.*?`|`.*?`:[^:]+:|(\*\*?|``?|\|)(?!\s)(?:(?!\2).)*\S\2(?=[\s\-.,:;!?\\\/'")\]}]|$))/m,
+        lookbehind: !0,
+        inside: {
+          bold: {
+            pattern: /(^\*\*).+(?=\*\*$)/,
+            lookbehind: !0
+          },
+          italic: {
+            pattern: /(^\*).+(?=\*$)/,
+            lookbehind: !0
+          },
+          "inline-literal": {
+            pattern: /(^``).+(?=``$)/,
+            lookbehind: !0,
+            alias: "symbol"
+          },
+          role: {
+            pattern: /^:[^:]+:|:[^:]+:$/,
+            alias: "function",
+            inside: {
+              punctuation: /^:|:$/
+            }
+          },
+          "interpreted-text": {
+            pattern: /(^`).+(?=`$)/,
+            lookbehind: !0,
+            alias: "attr-value"
+          },
+          substitution: {
+            pattern: /(^\|).+(?=\|$)/,
+            lookbehind: !0,
+            alias: "attr-value"
+          },
+          punctuation: /\*\*?|``?|\|/
+        }
+      }],
+      link: [{
+        pattern: /\[[^\[\]]+\]_(?=[\s\-.,:;!?\\\/'")\]}]|$)/,
+        alias: "string",
+        inside: {
+          punctuation: /^\[|\]_$/
+        }
+      }, {
+        pattern: /(?:\b[a-z\d]+(?:[_.:+][a-z\d]+)*_?_|`[^`]+`_?_|_`[^`]+`)(?=[\s\-.,:;!?\\\/'")\]}]|$)/i,
+        alias: "string",
+        inside: {
+          punctuation: /^_?`|`$|`?_?_$/
+        }
+      }],
+      // Line block start,
+      // quote attribution,
+      // explicit markup start,
+      // and anonymous hyperlink target shortcut (__)
+      punctuation: {
+        pattern: /(^[\t ]*)(?:\|(?= |$)|(?:---?|—|\.\.|__)(?= )|\.\.$)/m,
+        lookbehind: !0
+      }
+    };
+  }
+  return n;
+}
+export {
+  r as __require
+};

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

@@ -0,0 +1,41 @@
+var r, t;
+function i() {
+  if (t)
+    return r;
+  t = 1, r = e, e.displayName = "rip", e.aliases = [];
+  function e(d) {
+    d.languages.rip = {
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      char: {
+        pattern: /\B`[^\s`'",.:;#\/\\()<>\[\]{}]\b/,
+        greedy: !0
+      },
+      string: {
+        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      regex: {
+        pattern: /(^|[^/])\/(?!\/)(?:\[[^\n\r\]]*\]|\\.|[^/\\\r\n\[])+\/(?=\s*(?:$|[\r\n,.;})]))/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /(?:=>|->)|\b(?:case|catch|class|else|exit|finally|if|raise|return|switch|try)\b/,
+      builtin: /@|\bSystem\b/,
+      boolean: /\b(?:false|true)\b/,
+      date: /\b\d{4}-\d{2}-\d{2}\b/,
+      time: /\b\d{2}:\d{2}:\d{2}\b/,
+      datetime: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\b/,
+      symbol: /:[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/,
+      number: /[+-]?\b(?:\d+\.\d+|\d+)\b/,
+      punctuation: /(?:\.{2,3})|[`,.:;=\/\\()<>\[\]{}]/,
+      reference: /[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/
+    };
+  }
+  return r;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,39 @@
+var t, a;
+function r() {
+  if (a)
+    return t;
+  a = 1, t = o, o.displayName = "roboconf", o.aliases = [];
+  function o(e) {
+    e.languages.roboconf = {
+      comment: /#.*/,
+      keyword: {
+        pattern: /(^|\s)(?:(?:external|import)\b|(?:facet|instance of)(?=[ \t]+[\w-]+[ \t]*\{))/,
+        lookbehind: !0
+      },
+      component: {
+        pattern: /[\w-]+(?=[ \t]*\{)/,
+        alias: "variable"
+      },
+      property: /[\w.-]+(?=[ \t]*:)/,
+      value: {
+        pattern: /(=[ \t]*(?![ \t]))[^,;]+/,
+        lookbehind: !0,
+        alias: "attr-value"
+      },
+      optional: {
+        pattern: /\(optional\)/,
+        alias: "builtin"
+      },
+      wildcard: {
+        pattern: /(\.)\*/,
+        lookbehind: !0,
+        alias: "operator"
+      },
+      punctuation: /[{},.;:=]/
+    };
+  }
+  return t;
+}
+export {
+  r as __require
+};

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

@@ -0,0 +1,95 @@
+var u, l;
+function k() {
+  if (l)
+    return u;
+  l = 1, u = r, r.displayName = "robotframework", r.aliases = [];
+  function r(p) {
+    (function(n) {
+      var d = {
+        pattern: /(^[ \t]*| {2}|\t)#.*/m,
+        lookbehind: !0,
+        greedy: !0
+      }, a = {
+        pattern: /((?:^|[^\\])(?:\\{2})*)[$@&%]\{(?:[^{}\r\n]|\{[^{}\r\n]*\})*\}/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /^[$@&%]\{|\}$/
+        }
+      };
+      function e(b, c) {
+        var t = {};
+        t["section-header"] = {
+          pattern: /^ ?\*{3}.+?\*{3}/,
+          alias: "keyword"
+        };
+        for (var m in c)
+          t[m] = c[m];
+        return t.tag = {
+          pattern: /([\r\n](?: {2}|\t)[ \t]*)\[[-\w]+\]/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\[|\]/
+          }
+        }, t.variable = a, t.comment = d, {
+          pattern: RegExp(/^ ?\*{3}[ \t]*<name>[ \t]*\*{3}(?:.|[\r\n](?!\*{3}))*/.source.replace(/<name>/g, function() {
+            return b;
+          }), "im"),
+          alias: "section",
+          inside: t
+        };
+      }
+      var o = {
+        pattern: /(\[Documentation\](?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
+        lookbehind: !0,
+        alias: "string"
+      }, i = {
+        pattern: /([\r\n] ?)(?!#)(?:\S(?:[ \t]\S)*)+/,
+        lookbehind: !0,
+        alias: "function",
+        inside: {
+          variable: a
+        }
+      }, s = {
+        pattern: /([\r\n](?: {2}|\t)[ \t]*)(?!\[|\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
+        lookbehind: !0,
+        inside: {
+          variable: a
+        }
+      };
+      n.languages.robotframework = {
+        settings: e("Settings", {
+          documentation: {
+            pattern: /([\r\n] ?Documentation(?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
+            lookbehind: !0,
+            alias: "string"
+          },
+          property: {
+            pattern: /([\r\n] ?)(?!\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
+            lookbehind: !0
+          }
+        }),
+        variables: e("Variables"),
+        "test-cases": e("Test Cases", {
+          "test-name": i,
+          documentation: o,
+          property: s
+        }),
+        keywords: e("Keywords", {
+          "keyword-name": i,
+          documentation: o,
+          property: s
+        }),
+        tasks: e("Tasks", {
+          "task-name": i,
+          documentation: o,
+          property: s
+        }),
+        comment: d
+      }, n.languages.robot = n.languages.robotframework;
+    })(p);
+  }
+  return u;
+}
+export {
+  k as __require
+};

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

@@ -0,0 +1,159 @@
+var i, s;
+function u() {
+  if (s)
+    return i;
+  s = 1, i = r, r.displayName = "ruby", r.aliases = ["rb"];
+  function r(o) {
+    (function(e) {
+      e.languages.ruby = e.languages.extend("clike", {
+        comment: {
+          pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+          greedy: !0
+        },
+        "class-name": {
+          pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /[.\\]/
+          }
+        },
+        keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+        operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+        punctuation: /[(){}[\].,;]/
+      }), e.languages.insertBefore("ruby", "operator", {
+        "double-colon": {
+          pattern: /::/,
+          alias: "punctuation"
+        }
+      });
+      var n = {
+        pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+        lookbehind: !0,
+        inside: {
+          content: {
+            pattern: /^(#\{)[\s\S]+(?=\}$)/,
+            lookbehind: !0,
+            inside: e.languages.ruby
+          },
+          delimiter: {
+            pattern: /^#\{|\}$/,
+            alias: "punctuation"
+          }
+        }
+      };
+      delete e.languages.ruby.function;
+      var t = "(?:" + [/([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source, /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source, /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source, /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source, /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source].join("|") + ")", a = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
+      e.languages.insertBefore("ruby", "keyword", {
+        "regex-literal": [{
+          pattern: RegExp(/%r/.source + t + /[egimnosux]{0,6}/.source),
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            regex: /[\s\S]+/
+          }
+        }, {
+          pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            regex: /[\s\S]+/
+          }
+        }],
+        variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+        symbol: [{
+          pattern: RegExp(/(^|[^:]):/.source + a),
+          lookbehind: !0,
+          greedy: !0
+        }, {
+          pattern: RegExp(/([\r\n{(,][ \t]*)/.source + a + /(?=:(?!:))/.source),
+          lookbehind: !0,
+          greedy: !0
+        }],
+        "method-definition": {
+          pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+          lookbehind: !0,
+          inside: {
+            function: /\b\w+$/,
+            keyword: /^self\b/,
+            "class-name": /^\w+/,
+            punctuation: /\./
+          }
+        }
+      }), e.languages.insertBefore("ruby", "string", {
+        "string-literal": [{
+          pattern: RegExp(/%[qQiIwWs]?/.source + t),
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            string: /[\s\S]+/
+          }
+        }, {
+          pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            string: /[\s\S]+/
+          }
+        }, {
+          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+          alias: "heredoc-string",
+          greedy: !0,
+          inside: {
+            delimiter: {
+              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+              inside: {
+                symbol: /\b\w+/,
+                punctuation: /^<<[-~]?/
+              }
+            },
+            interpolation: n,
+            string: /[\s\S]+/
+          }
+        }, {
+          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+          alias: "heredoc-string",
+          greedy: !0,
+          inside: {
+            delimiter: {
+              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+              inside: {
+                symbol: /\b\w+/,
+                punctuation: /^<<[-~]?'|'$/
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }],
+        "command-literal": [{
+          pattern: RegExp(/%x/.source + t),
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            command: {
+              pattern: /[\s\S]+/,
+              alias: "string"
+            }
+          }
+        }, {
+          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            command: {
+              pattern: /[\s\S]+/,
+              alias: "string"
+            }
+          }
+        }]
+      }), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", {
+        builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+        constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+      }), e.languages.rb = e.languages.ruby;
+    })(o);
+  }
+  return i;
+}
+export {
+  u as __require
+};

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

@@ -0,0 +1,122 @@
+var r, s;
+function i() {
+  if (s)
+    return r;
+  s = 1, r = a, a.displayName = "rust", a.aliases = [];
+  function a(u) {
+    (function(t) {
+      for (var e = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, n = 0; n < 2; n++)
+        e = e.replace(/<self>/g, function() {
+          return e;
+        });
+      e = e.replace(/<self>/g, function() {
+        return /[^\s\S]/.source;
+      }), t.languages.rust = {
+        comment: [{
+          pattern: RegExp(/(^|[^\\])/.source + e),
+          lookbehind: !0,
+          greedy: !0
+        }, {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }],
+        string: {
+          pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+          greedy: !0
+        },
+        char: {
+          pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+          greedy: !0
+        },
+        attribute: {
+          pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+          greedy: !0,
+          alias: "attr-name",
+          inside: {
+            string: null
+            // see below
+          }
+        },
+        // Closure params should not be confused with bitwise OR |
+        "closure-params": {
+          pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            "closure-punctuation": {
+              pattern: /^\||\|$/,
+              alias: "punctuation"
+            },
+            rest: null
+            // see below
+          }
+        },
+        "lifetime-annotation": {
+          pattern: /'\w+/,
+          alias: "symbol"
+        },
+        "fragment-specifier": {
+          pattern: /(\$\w+:)[a-z]+/,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        variable: /\$\w+/,
+        "function-definition": {
+          pattern: /(\bfn\s+)\w+/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        "type-definition": {
+          pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+          lookbehind: !0,
+          alias: "class-name"
+        },
+        "module-declaration": [{
+          pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+          lookbehind: !0,
+          alias: "namespace"
+        }, {
+          pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+          lookbehind: !0,
+          alias: "namespace",
+          inside: {
+            punctuation: /::/
+          }
+        }],
+        keyword: [
+          // https://github.com/rust-lang/reference/blob/master/src/keywords.md
+          /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+          // primitives and str
+          // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
+          /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
+        ],
+        // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+        // and Rust's naming conventions recommend snake_case anyway.
+        // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
+        function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+        macro: {
+          pattern: /\b\w+!/,
+          alias: "property"
+        },
+        constant: /\b[A-Z_][A-Z_\d]+\b/,
+        "class-name": /\b[A-Z]\w*\b/,
+        namespace: {
+          pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+          inside: {
+            punctuation: /::/
+          }
+        },
+        // Hex, oct, bin, dec numbers with visual separators and type suffix
+        number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+        boolean: /\b(?:false|true)\b/,
+        punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+        operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+      }, t.languages.rust["closure-params"].inside.rest = t.languages.rust, t.languages.rust.attribute.inside.string = t.languages.rust.string;
+    })(u);
+  }
+  return r;
+}
+export {
+  i as __require
+};