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

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

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

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

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

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

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

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