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

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

@@ -0,0 +1,68 @@
+import { __require as s } from "./markup-templating.mjs";
+import { __require as g } from "./php.mjs";
+var n, u;
+function h() {
+  if (u)
+    return n;
+  u = 1;
+  var l = s(), p = g();
+  n = t, t.displayName = "latte", t.aliases = [];
+  function t(r) {
+    r.register(l), r.register(p), function(a) {
+      a.languages.latte = {
+        comment: /^\{\*[\s\S]*/,
+        "latte-tag": {
+          // https://latte.nette.org/en/tags
+          pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i,
+          lookbehind: !0,
+          alias: "important"
+        },
+        delimiter: {
+          pattern: /^\{\/?|\}$/,
+          alias: "punctuation"
+        },
+        php: {
+          pattern: /\S(?:[\s\S]*\S)?/,
+          alias: "language-php",
+          inside: a.languages.php
+        }
+      };
+      var i = a.languages.extend("markup", {});
+      a.languages.insertBefore("inside", "attr-value", {
+        "n-attr": {
+          pattern: /n:[\w-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+))?/,
+          inside: {
+            "attr-name": {
+              pattern: /^[^\s=]+/,
+              alias: "important"
+            },
+            "attr-value": {
+              pattern: /=[\s\S]+/,
+              inside: {
+                punctuation: [/^=/, {
+                  pattern: /^(\s*)["']|["']$/,
+                  lookbehind: !0
+                }],
+                php: {
+                  pattern: /\S(?:[\s\S]*\S)?/,
+                  inside: a.languages.php
+                }
+              }
+            }
+          }
+        }
+      }, i.tag), a.hooks.add("before-tokenize", function(e) {
+        if (e.language === "latte") {
+          var o = /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g;
+          a.languages["markup-templating"].buildPlaceholders(e, "latte", o), e.grammar = i;
+        }
+      }), a.hooks.add("after-tokenize", function(e) {
+        a.languages["markup-templating"].tokenizePlaceholders(e, "latte");
+      });
+    }(r);
+  }
+  return n;
+}
+export {
+  h as __require
+};

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

@@ -0,0 +1,51 @@
+var a, t;
+function n() {
+  if (t)
+    return a;
+  t = 1, a = e, e.displayName = "less", e.aliases = [];
+  function e(s) {
+    s.languages.less = s.languages.extend("css", {
+      comment: [/\/\*[\s\S]*?\*\//, {
+        pattern: /(^|[^\\])\/\/.*/,
+        lookbehind: !0
+      }],
+      atrule: {
+        pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
+        inside: {
+          punctuation: /[:()]/
+        }
+      },
+      // selectors and mixins are considered the same
+      selector: {
+        pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
+        inside: {
+          // mixin parameters
+          variable: /@+[\w-]+/
+        }
+      },
+      property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
+      operator: /[+\-*\/]/
+    }), s.languages.insertBefore("less", "property", {
+      variable: [
+        // Variable declaration (the colon must be consumed!)
+        {
+          pattern: /@[\w-]+\s*:/,
+          inside: {
+            punctuation: /:/
+          }
+        },
+        // Variable usage
+        /@@?[\w-]+/
+      ],
+      "mixin-usage": {
+        pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
+        lookbehind: !0,
+        alias: "function"
+      }
+    });
+  }
+  return a;
+}
+export {
+  n as __require
+};

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

@@ -0,0 +1,77 @@
+import { __require as u } from "./scheme.mjs";
+var a, d;
+function c() {
+  if (d)
+    return a;
+  d = 1;
+  var o = u();
+  a = n, n.displayName = "lilypond", n.aliases = [];
+  function n(s) {
+    s.register(o), function(r) {
+      for (var e = /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source, l = 5, t = 0; t < l; t++)
+        e = e.replace(/<expr>/g, function() {
+          return e;
+        });
+      e = e.replace(/<expr>/g, /[^\s\S]/.source);
+      var i = r.languages.lilypond = {
+        comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/,
+        "embedded-scheme": {
+          pattern: RegExp(/(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(/<expr>/g, function() {
+            return e;
+          }), "m"),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            scheme: {
+              pattern: /^(#)[\s\S]+$/,
+              lookbehind: !0,
+              alias: "language-scheme",
+              inside: {
+                "embedded-lilypond": {
+                  pattern: /#\{[\s\S]*?#\}/,
+                  greedy: !0,
+                  inside: {
+                    punctuation: /^#\{|#\}$/,
+                    lilypond: {
+                      pattern: /[\s\S]+/,
+                      alias: "language-lilypond",
+                      inside: null
+                      // see below
+                    }
+                  }
+                },
+                rest: r.languages.scheme
+              }
+            },
+            punctuation: /#/
+          }
+        },
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: !0
+        },
+        "class-name": {
+          pattern: /(\\new\s+)[\w-]+/,
+          lookbehind: !0
+        },
+        keyword: {
+          pattern: /\\[a-z][-\w]*/i,
+          inside: {
+            punctuation: /^\\/
+          }
+        },
+        operator: /[=|]|<<|>>/,
+        punctuation: {
+          pattern: /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/,
+          lookbehind: !0
+        },
+        number: /\b\d+(?:\/\d+)?\b/
+      };
+      i["embedded-scheme"].inside.scheme.inside["embedded-lilypond"].inside.lilypond.inside = i, r.languages.ly = i;
+    }(s);
+  }
+  return a;
+}
+export {
+  c as __require
+};

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

@@ -0,0 +1,68 @@
+import { __require as d } from "./markup-templating.mjs";
+var i, l;
+function m() {
+  if (l)
+    return i;
+  l = 1;
+  var s = d();
+  i = r, r.displayName = "liquid", r.aliases = [];
+  function r(e) {
+    e.register(s), e.languages.liquid = {
+      comment: {
+        pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
+        lookbehind: !0
+      },
+      delimiter: {
+        pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/,
+        alias: "punctuation"
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: !0
+      },
+      keyword: /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/,
+      object: /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/,
+      function: [{
+        pattern: /(\|\s*)\w+/,
+        lookbehind: !0,
+        alias: "filter"
+      }, {
+        // array functions
+        pattern: /(\.\s*)(?:first|last|size)/,
+        lookbehind: !0
+      }],
+      boolean: /\b(?:false|nil|true)\b/,
+      range: {
+        pattern: /\.\./,
+        alias: "operator"
+      },
+      // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21
+      number: /\b\d+(?:\.\d+)?\b/,
+      operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/,
+      punctuation: /[.,\[\]()]/,
+      empty: {
+        pattern: /\bempty\b/,
+        alias: "keyword"
+      }
+    }, e.hooks.add("before-tokenize", function(a) {
+      var u = /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g, t = !1;
+      e.languages["markup-templating"].buildPlaceholders(a, "liquid", u, function(c) {
+        var n = /^\{%-?\s*(\w+)/.exec(c);
+        if (n) {
+          var o = n[1];
+          if (o === "raw" && !t)
+            return t = !0, !0;
+          if (o === "endraw")
+            return t = !1, !0;
+        }
+        return !t;
+      });
+    }), e.hooks.add("after-tokenize", function(a) {
+      e.languages["markup-templating"].tokenizePlaceholders(a, "liquid");
+    });
+  }
+  return i;
+}
+export {
+  m as __require
+};

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

@@ -0,0 +1,158 @@
+var p, b;
+function x() {
+  if (b)
+    return p;
+  b = 1, p = n, n.displayName = "lisp", n.aliases = [];
+  function n(m) {
+    (function(t) {
+      function d(u) {
+        return RegExp(/(\()/.source + "(?:" + u + ")" + /(?=[\s\)])/.source);
+      }
+      function c(u) {
+        return RegExp(/([\s([])/.source + "(?:" + u + ")" + /(?=[\s)])/.source);
+      }
+      var e = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source, k = "&" + e, a = "(\\()", v = "(?=\\))", g = "(?=\\s)", s = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source, r = {
+        // Three or four semicolons are considered a heading.
+        // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
+        heading: {
+          pattern: /;;;.*/,
+          alias: ["comment", "title"]
+        },
+        comment: /;.*/,
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: !0,
+          inside: {
+            argument: /[-A-Z]+(?=[.,\s])/,
+            symbol: RegExp("`" + e + "'")
+          }
+        },
+        "quoted-symbol": {
+          pattern: RegExp("#?'" + e),
+          alias: ["variable", "symbol"]
+        },
+        "lisp-property": {
+          pattern: RegExp(":" + e),
+          alias: "property"
+        },
+        splice: {
+          pattern: RegExp(",@?" + e),
+          alias: ["symbol", "variable"]
+        },
+        keyword: [{
+          pattern: RegExp(a + "(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)" + g),
+          lookbehind: !0
+        }, {
+          pattern: RegExp(a + "(?:append|by|collect|concat|do|finally|for|in|return)" + g),
+          lookbehind: !0
+        }],
+        declare: {
+          pattern: d(/declare/.source),
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        interactive: {
+          pattern: d(/interactive/.source),
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        boolean: {
+          pattern: c(/nil|t/.source),
+          lookbehind: !0
+        },
+        number: {
+          pattern: c(/[-+]?\d+(?:\.\d*)?/.source),
+          lookbehind: !0
+        },
+        defvar: {
+          pattern: RegExp(a + "def(?:const|custom|group|var)\\s+" + e),
+          lookbehind: !0,
+          inside: {
+            keyword: /^def[a-z]+/,
+            variable: RegExp(e)
+          }
+        },
+        defun: {
+          pattern: RegExp(a + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + e + /\s+\(/.source + s + /\)/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            keyword: /^(?:cl-)?def\S+/,
+            // See below, this property needs to be defined later so that it can
+            // reference the language object.
+            arguments: null,
+            function: {
+              pattern: RegExp("(^\\s)" + e),
+              lookbehind: !0
+            },
+            punctuation: /[()]/
+          }
+        },
+        lambda: {
+          pattern: RegExp(a + "lambda\\s+\\(\\s*(?:&?" + e + "(?:\\s+&?" + e + ")*\\s*)?\\)"),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            keyword: /^lambda/,
+            // See below, this property needs to be defined later so that it can
+            // reference the language object.
+            arguments: null,
+            punctuation: /[()]/
+          }
+        },
+        car: {
+          pattern: RegExp(a + e),
+          lookbehind: !0
+        },
+        punctuation: [
+          // open paren, brackets, and close paren
+          /(?:['`,]?\(|[)\[\]])/,
+          // cons
+          {
+            pattern: /(\s)\.(?=\s)/,
+            lookbehind: !0
+          }
+        ]
+      }, o = {
+        "lisp-marker": RegExp(k),
+        varform: {
+          pattern: RegExp(/\(/.source + e + /\s+(?=\S)/.source + s + /\)/.source),
+          inside: r
+        },
+        argument: {
+          pattern: RegExp(/(^|[\s(])/.source + e),
+          lookbehind: !0,
+          alias: "variable"
+        },
+        rest: r
+      }, i = "\\S+(?:\\s+\\S+)*", l = {
+        pattern: RegExp(a + s + v),
+        lookbehind: !0,
+        inside: {
+          "rest-vars": {
+            pattern: RegExp("&(?:body|rest)\\s+" + i),
+            inside: o
+          },
+          "other-marker-vars": {
+            pattern: RegExp("&(?:aux|optional)\\s+" + i),
+            inside: o
+          },
+          keys: {
+            pattern: RegExp("&key\\s+" + i + "(?:\\s+&allow-other-keys)?"),
+            inside: o
+          },
+          argument: {
+            pattern: RegExp(e),
+            alias: "variable"
+          },
+          punctuation: /[()]/
+        }
+      };
+      r.lambda.inside.arguments = l, r.defun.inside.arguments = t.util.clone(l), r.defun.inside.arguments.inside.sublist = l, t.languages.lisp = r, t.languages.elisp = r, t.languages.emacs = r, t.languages["emacs-lisp"] = r;
+    })(m);
+  }
+  return p;
+}
+export {
+  x as __require
+};

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

@@ -0,0 +1,119 @@
+var r, n;
+function i() {
+  if (n)
+    return r;
+  n = 1, r = e, e.displayName = "livescript", e.aliases = [];
+  function e(t) {
+    t.languages.livescript = {
+      comment: [{
+        pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+        lookbehind: !0
+      }, {
+        pattern: /(^|[^\\])#.*/,
+        lookbehind: !0
+      }],
+      "interpolated-string": {
+        /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern
+         * forcing it to match """-quoted string when it would otherwise match "-quoted first. */
+        pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          variable: {
+            pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m,
+            lookbehind: !0
+          },
+          interpolation: {
+            pattern: /(^|[^\\])#\{[^}]+\}/m,
+            lookbehind: !0,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^#\{|\}$/,
+                alias: "variable"
+              }
+              // See rest below
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      string: [{
+        pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+        greedy: !0
+      }, {
+        pattern: /<\[[\s\S]*?\]>/,
+        greedy: !0
+      }, /\\[^\s,;\])}]+/],
+      regex: [{
+        pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,
+        greedy: !0,
+        inside: {
+          comment: {
+            pattern: /(^|[^\\])#.*/,
+            lookbehind: !0
+          }
+        }
+      }, {
+        pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,
+        greedy: !0
+      }],
+      keyword: {
+        pattern: /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m,
+        lookbehind: !0
+      },
+      "keyword-operator": {
+        pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
+        lookbehind: !0,
+        alias: "operator"
+      },
+      boolean: {
+        pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m,
+        lookbehind: !0
+      },
+      argument: {
+        // Don't match .&. nor &&
+        pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m,
+        lookbehind: !0,
+        alias: "variable"
+      },
+      number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i,
+      identifier: /[a-z_](?:-?[a-z]|[\d_])*/i,
+      operator: [
+        // Spaced .
+        {
+          pattern: /( )\.(?= )/,
+          lookbehind: !0
+        },
+        // Full list, in order:
+        // .= .~ .. ...
+        // .&. .^. .<<. .>>. .>>>.
+        // := :: ::=
+        // &&
+        // || |>
+        // < << <<< <<<<
+        // <- <-- <-! <--!
+        // <~ <~~ <~! <~~!
+        // <| <= <?
+        // > >> >= >?
+        // - -- -> -->
+        // + ++
+        // @ @@
+        // % %%
+        // * **
+        // ! != !~=
+        // !~> !~~>
+        // !-> !-->
+        // ~ ~> ~~> ~=
+        // = ==
+        // ^ ^^
+        // / ?
+        /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/
+      ],
+      punctuation: /[(){}\[\]|.,:;`]/
+    }, t.languages.livescript["interpolated-string"].inside.interpolation.inside.rest = t.languages.livescript;
+  }
+  return r;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,31 @@
+var e, l;
+function t() {
+  if (l)
+    return e;
+  l = 1, e = a, a.displayName = "llvm", a.aliases = [];
+  function a(b) {
+    (function(r) {
+      r.languages.llvm = {
+        comment: /;.*/,
+        string: {
+          pattern: /"[^"]*"/,
+          greedy: !0
+        },
+        boolean: /\b(?:false|true)\b/,
+        variable: /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i,
+        label: /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i,
+        type: {
+          pattern: /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/,
+          alias: "class-name"
+        },
+        keyword: /\b[a-z_][a-z_0-9]*\b/,
+        number: /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/,
+        punctuation: /[{}[\];(),.!*=<>]/
+      };
+    })(b);
+  }
+  return e;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,103 @@
+var e, r;
+function n() {
+  if (r)
+    return e;
+  r = 1, e = a, a.displayName = "log", a.aliases = [];
+  function a(t) {
+    t.languages.log = {
+      string: {
+        // Single-quoted strings must not be confused with plain text. E.g. Can't isn't Susan's Chris' toy
+        pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/,
+        greedy: !0
+      },
+      exception: {
+        pattern: /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/,
+        lookbehind: !0,
+        greedy: !0,
+        alias: ["javastacktrace", "language-javastacktrace"],
+        inside: t.languages.javastacktrace || {
+          keyword: /\bat\b/,
+          function: /[a-z_][\w$]*(?=\()/,
+          punctuation: /[.:()]/
+        }
+      },
+      level: [{
+        pattern: /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/,
+        alias: ["error", "important"]
+      }, {
+        pattern: /\b(?:WARN|WARNING|WRN)\b/,
+        alias: ["warning", "important"]
+      }, {
+        pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/,
+        alias: ["info", "keyword"]
+      }, {
+        pattern: /\b(?:DBG|DEBUG|FINE)\b/,
+        alias: ["debug", "keyword"]
+      }, {
+        pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/,
+        alias: ["trace", "comment"]
+      }],
+      property: {
+        pattern: /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im,
+        lookbehind: !0
+      },
+      separator: {
+        pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m,
+        lookbehind: !0,
+        alias: "comment"
+      },
+      url: /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/,
+      email: {
+        pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/,
+        lookbehind: !0,
+        alias: "url"
+      },
+      "ip-address": {
+        pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/,
+        alias: "constant"
+      },
+      "mac-address": {
+        pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i,
+        alias: "constant"
+      },
+      domain: {
+        pattern: /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/,
+        lookbehind: !0,
+        alias: "constant"
+      },
+      uuid: {
+        pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i,
+        alias: "constant"
+      },
+      hash: {
+        pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i,
+        alias: "constant"
+      },
+      "file-path": {
+        pattern: /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "string"
+      },
+      date: {
+        pattern: RegExp(/\b\d{4}[-/]\d{2}[-/]\d{2}(?:T(?=\d{1,2}:)|(?=\s\d{1,2}:))/.source + "|" + /\b\d{1,4}[-/ ](?:\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\d{2,4}T?\b/.source + "|" + /\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\s{1,2}\d{1,2}\b/.source, "i"),
+        alias: "number"
+      },
+      time: {
+        pattern: /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/,
+        alias: "number"
+      },
+      boolean: /\b(?:false|null|true)\b/i,
+      number: {
+        pattern: /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i,
+        lookbehind: !0
+      },
+      operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/,
+      punctuation: /[\[\].,]/
+    };
+  }
+  return e;
+}
+export {
+  n as __require
+};