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

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

@@ -1,69 +0,0 @@
-var i, t;
-function o() {
-  if (t)
-    return i;
-  t = 1, i = n, n.displayName = "inform7", n.aliases = [];
-  function n(e) {
-    e.languages.inform7 = {
-      string: {
-        pattern: /"[^"]*"/,
-        inside: {
-          substitution: {
-            pattern: /\[[^\[\]]+\]/,
-            inside: {
-              delimiter: {
-                pattern: /\[|\]/,
-                alias: "punctuation"
-              }
-              // See rest below
-            }
-          }
-        }
-      },
-      comment: {
-        pattern: /\[[^\[\]]+\]/,
-        greedy: !0
-      },
-      title: {
-        pattern: /^[ \t]*(?:book|chapter|part(?! of)|section|table|volume)\b.+/im,
-        alias: "important"
-      },
-      number: {
-        pattern: /(^|[^-])(?:\b\d+(?:\.\d+)?(?:\^\d+)?(?:(?!\d)\w+)?|\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\b(?!-)/i,
-        lookbehind: !0
-      },
-      verb: {
-        pattern: /(^|[^-])\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\b(?!-)/i,
-        lookbehind: !0,
-        alias: "operator"
-      },
-      keyword: {
-        pattern: /(^|[^-])\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\b(?!-)/i,
-        lookbehind: !0
-      },
-      property: {
-        pattern: /(^|[^-])\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\b(?!-)/i,
-        lookbehind: !0,
-        alias: "symbol"
-      },
-      position: {
-        pattern: /(^|[^-])\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\b(?!-)/i,
-        lookbehind: !0,
-        alias: "keyword"
-      },
-      type: {
-        pattern: /(^|[^-])\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\b(?!-)/i,
-        lookbehind: !0,
-        alias: "variable"
-      },
-      punctuation: /[.,:;(){}]/
-    }, e.languages.inform7.string.inside.substitution.inside.rest = e.languages.inform7, e.languages.inform7.string.inside.substitution.inside.rest.text = {
-      pattern: /\S(?:\s*\S)*/,
-      alias: "comment"
-    };
-  }
-  return i;
-}
-export {
-  o as __require
-};

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

@@ -1,52 +0,0 @@
-var e, n;
-function r() {
-  if (n)
-    return e;
-  n = 1, e = t, t.displayName = "ini", t.aliases = [];
-  function t(i) {
-    i.languages.ini = {
-      /**
-       * The component mimics the behavior of the Win32 API parser.
-       *
-       * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}
-       */
-      comment: {
-        pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m,
-        lookbehind: !0
-      },
-      section: {
-        pattern: /(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m,
-        lookbehind: !0,
-        inside: {
-          "section-name": {
-            pattern: /(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/,
-            lookbehind: !0,
-            alias: "selector"
-          },
-          punctuation: /\[|\]/
-        }
-      },
-      key: {
-        pattern: /(^[ \f\t\v]*)[^ \f\n\r\t\v=]+(?:[ \f\t\v]+[^ \f\n\r\t\v=]+)*(?=[ \f\t\v]*=)/m,
-        lookbehind: !0,
-        alias: "attr-name"
-      },
-      value: {
-        pattern: /(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/,
-        lookbehind: !0,
-        alias: "attr-value",
-        inside: {
-          "inner-value": {
-            pattern: /^("|').+(?=\1$)/,
-            lookbehind: !0
-          }
-        }
-      },
-      punctuation: /=/
-    };
-  }
-  return e;
-}
-export {
-  r as __require
-};

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

@@ -1,34 +0,0 @@
-var r, t;
-function i() {
-  if (t)
-    return r;
-  t = 1, r = e, e.displayName = "io", e.aliases = [];
-  function e(o) {
-    o.languages.io = {
-      comment: {
-        pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*|#.*)/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      "triple-quoted-string": {
-        pattern: /"""(?:\\[\s\S]|(?!""")[^\\])*"""/,
-        greedy: !0,
-        alias: "string"
-      },
-      string: {
-        pattern: /"(?:\\.|[^\\\r\n"])*"/,
-        greedy: !0
-      },
-      keyword: /\b(?:activate|activeCoroCount|asString|block|break|call|catch|clone|collectGarbage|compileString|continue|do|doFile|doMessage|doString|else|elseif|exit|for|foreach|forward|getEnvironmentVariable|getSlot|hasSlot|if|ifFalse|ifNil|ifNilEval|ifTrue|isActive|isNil|isResumable|list|message|method|parent|pass|pause|perform|performWithArgList|print|println|proto|raise|raiseResumable|removeSlot|resend|resume|schedulerSleepSeconds|self|sender|setSchedulerSleepSeconds|setSlot|shallowCopy|slotNames|super|system|then|thisBlock|thisContext|try|type|uniqueId|updateSlot|wait|while|write|yield)\b/,
-      builtin: /\b(?:Array|AudioDevice|AudioMixer|BigNum|Block|Box|Buffer|CFunction|CGI|Color|Curses|DBM|DNSResolver|DOConnection|DOProxy|DOServer|Date|Directory|Duration|DynLib|Error|Exception|FFT|File|Fnmatch|Font|Future|GL|GLE|GLScissor|GLU|GLUCylinder|GLUQuadric|GLUSphere|GLUT|Host|Image|Importer|LinkList|List|Lobby|Locals|MD5|MP3Decoder|MP3Encoder|Map|Message|Movie|Notification|Number|Object|OpenGL|Point|Protos|Random|Regex|SGML|SGMLElement|SGMLParser|SQLite|Sequence|Server|ShowMessage|SleepyCat|SleepyCatCursor|Socket|SocketManager|Sound|Soup|Store|String|Tree|UDPSender|UPDReceiver|URL|User|Warning|WeakLink)\b/,
-      boolean: /\b(?:false|nil|true)\b/,
-      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?/i,
-      operator: /[=!*/%+\-^&|]=|>>?=?|<<?=?|:?:?=|\+\+?|--?|\*\*?|\/\/?|%|\|\|?|&&?|\b(?:and|not|or|return)\b|@@?|\?\??|\.\./,
-      punctuation: /[{}[\];(),.:]/
-    };
-  }
-  return r;
-}
-export {
-  i as __require
-};

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

@@ -1,40 +0,0 @@
-var r, a;
-function n() {
-  if (a)
-    return r;
-  a = 1, r = e, e.displayName = "j", e.aliases = [];
-  function e(t) {
-    t.languages.j = {
-      comment: {
-        pattern: /\bNB\..*/,
-        greedy: !0
-      },
-      string: {
-        pattern: /'(?:''|[^'\r\n])*'/,
-        greedy: !0
-      },
-      keyword: /\b(?:(?:CR|LF|adverb|conjunction|def|define|dyad|monad|noun|verb)\b|(?:assert|break|case|catch[dt]?|continue|do|else|elseif|end|fcase|for|for_\w+|goto_\w+|if|label_\w+|return|select|throw|try|while|whilst)\.)/,
-      verb: {
-        // Negative look-ahead prevents bad highlighting
-        // of ^: ;. =. =: !. !:
-        pattern: /(?!\^:|;\.|[=!][.:])(?:\{(?:\.|::?)?|p(?:\.\.?|:)|[=!\]]|[<>+*\-%$|,#][.:]?|[?^]\.?|[;\[]:?|[~}"i][.:]|[ACeEIjLor]\.|(?:[_\/\\qsux]|_?\d):)/,
-        alias: "keyword"
-      },
-      number: /\b_?(?:(?!\d:)\d+(?:\.\d+)?(?:(?:ad|ar|[ejpx])_?\d+(?:\.\d+)?)*(?:b_?[\da-z]+(?:\.[\da-z]+)?)?|_\b(?!\.))/,
-      adverb: {
-        pattern: /[~}]|[\/\\]\.?|[bfM]\.|t[.:]/,
-        alias: "builtin"
-      },
-      operator: /[=a][.:]|_\./,
-      conjunction: {
-        pattern: /&(?:\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\.|`:?|[\^LS]:|"/,
-        alias: "variable"
-      },
-      punctuation: /[()]/
-    };
-  }
-  return r;
-}
-export {
-  n as __require
-};

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

@@ -1,86 +0,0 @@
-var r, i;
-function u() {
-  if (i)
-    return r;
-  i = 1, r = a, a.displayName = "java", a.aliases = [];
-  function a(o) {
-    (function(e) {
-      var t = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, s = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, n = {
-        pattern: RegExp(s + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
-        lookbehind: !0,
-        inside: {
-          namespace: {
-            pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-            inside: {
-              punctuation: /\./
-            }
-          },
-          punctuation: /\./
-        }
-      };
-      e.languages.java = e.languages.extend("clike", {
-        string: {
-          pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
-          lookbehind: !0,
-          greedy: !0
-        },
-        "class-name": [n, {
-          // variables and parameters
-          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-          pattern: RegExp(s + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source),
-          lookbehind: !0,
-          inside: n.inside
-        }],
-        keyword: t,
-        function: [e.languages.clike.function, {
-          pattern: /(::\s*)[a-z_]\w*/,
-          lookbehind: !0
-        }],
-        number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
-        operator: {
-          pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
-          lookbehind: !0
-        }
-      }), e.languages.insertBefore("java", "string", {
-        "triple-quoted-string": {
-          // http://openjdk.java.net/jeps/355#Description
-          pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
-          greedy: !0,
-          alias: "string"
-        },
-        char: {
-          pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
-          greedy: !0
-        }
-      }), e.languages.insertBefore("java", "class-name", {
-        annotation: {
-          pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
-          lookbehind: !0,
-          alias: "punctuation"
-        },
-        generics: {
-          pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
-          inside: {
-            "class-name": n,
-            keyword: t,
-            punctuation: /[<>(),.:]/,
-            operator: /[?&|]/
-          }
-        },
-        namespace: {
-          pattern: RegExp(/(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(/<keyword>/g, function() {
-            return t.source;
-          })),
-          lookbehind: !0,
-          inside: {
-            punctuation: /\./
-          }
-        }
-      });
-    })(o);
-  }
-  return r;
-}
-export {
-  u as __require
-};

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

@@ -1,89 +0,0 @@
-import { __require as c } from "./java.mjs";
-import { __require as l } from "./javadoclike.mjs";
-var t, o;
-function v() {
-  if (o)
-    return t;
-  o = 1;
-  var s = c(), i = l();
-  t = a, a.displayName = "javadoc", a.aliases = [];
-  function a(n) {
-    n.register(s), n.register(i), function(e) {
-      var r = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m, u = /#\s*\w+(?:\s*\([^()]*\))?/.source, d = /(?:\b[a-zA-Z]\w+\s*\.\s*)*\b[A-Z]\w*(?:\s*<mem>)?|<mem>/.source.replace(/<mem>/g, function() {
-        return u;
-      });
-      e.languages.javadoc = e.languages.extend("javadoclike", {}), e.languages.insertBefore("javadoc", "keyword", {
-        reference: {
-          pattern: RegExp(/(@(?:exception|link|linkplain|see|throws|value)\s+(?:\*\s*)?)/.source + "(?:" + d + ")"),
-          lookbehind: !0,
-          inside: {
-            function: {
-              pattern: /(#\s*)\w+(?=\s*\()/,
-              lookbehind: !0
-            },
-            field: {
-              pattern: /(#\s*)\w+/,
-              lookbehind: !0
-            },
-            namespace: {
-              pattern: /\b(?:[a-z]\w*\s*\.\s*)+/,
-              inside: {
-                punctuation: /\./
-              }
-            },
-            "class-name": /\b[A-Z]\w*/,
-            keyword: e.languages.java.keyword,
-            punctuation: /[#()[\],.]/
-          }
-        },
-        "class-name": {
-          // @param <T> the first generic type parameter
-          pattern: /(@param\s+)<[A-Z]\w*>/,
-          lookbehind: !0,
-          inside: {
-            punctuation: /[.<>]/
-          }
-        },
-        "code-section": [{
-          pattern: /(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/,
-          lookbehind: !0,
-          inside: {
-            code: {
-              // there can't be any HTML inside of {@code} tags
-              pattern: r,
-              lookbehind: !0,
-              inside: e.languages.java,
-              alias: "language-java"
-            }
-          }
-        }, {
-          pattern: /(<(code|pre|tt)>(?!<code>)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/,
-          lookbehind: !0,
-          inside: {
-            line: {
-              pattern: r,
-              lookbehind: !0,
-              inside: {
-                // highlight HTML tags and entities
-                tag: e.languages.markup.tag,
-                entity: e.languages.markup.entity,
-                code: {
-                  // everything else is Java code
-                  pattern: /.+/,
-                  inside: e.languages.java,
-                  alias: "language-java"
-                }
-              }
-            }
-          }
-        }],
-        tag: e.languages.markup.tag,
-        entity: e.languages.markup.entity
-      }), e.languages.javadoclike.addSupport("java", e.languages.javadoc);
-    }(n);
-  }
-  return t;
-}
-export {
-  v as __require
-};

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

@@ -1,60 +0,0 @@
-var d, f;
-function l() {
-  if (f)
-    return d;
-  f = 1, d = i, i.displayName = "javadoclike", i.aliases = [];
-  function i(s) {
-    (function(u) {
-      var c = u.languages.javadoclike = {
-        parameter: {
-          pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
-          lookbehind: !0
-        },
-        keyword: {
-          // keywords are the first word in a line preceded be an `@` or surrounded by curly braces.
-          // @word, {@word}
-          pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
-          lookbehind: !0
-        },
-        punctuation: /[{}]/
-      };
-      function v(r, n) {
-        var t = "doc-comment", a = u.languages[r];
-        if (a) {
-          var e = a[t];
-          if (!e) {
-            var p = {};
-            p[t] = {
-              pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
-              lookbehind: !0,
-              alias: "comment"
-            }, a = u.languages.insertBefore(r, "comment", p), e = a[t];
-          }
-          if (e instanceof RegExp && (e = a[t] = {
-            pattern: e
-          }), Array.isArray(e))
-            for (var o = 0, k = e.length; o < k; o++)
-              e[o] instanceof RegExp && (e[o] = {
-                pattern: e[o]
-              }), n(e[o]);
-          else
-            n(e);
-        }
-      }
-      function m(r, n) {
-        typeof r == "string" && (r = [r]), r.forEach(function(t) {
-          v(t, function(a) {
-            a.inside || (a.inside = {}), a.inside.rest = n;
-          });
-        });
-      }
-      Object.defineProperty(c, "addSupport", {
-        value: m
-      }), c.addSupport(["java", "javascript", "php"], c);
-    })(s);
-  }
-  return d;
-}
-export {
-  l as __require
-};

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

@@ -1,114 +0,0 @@
-var a = t;
-t.displayName = "javascript";
-t.aliases = ["js"];
-function t(e) {
-  e.languages.javascript = e.languages.extend("clike", {
-    "class-name": [e.languages.clike["class-name"], {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-      lookbehind: !0
-    }],
-    keyword: [{
-      pattern: /((?:^|\})\s*)catch\b/,
-      lookbehind: !0
-    }, {
-      pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
-      lookbehind: !0
-    }],
-    // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-    function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
-    number: {
-      pattern: RegExp(/(^|[^\w$])/.source + "(?:" + // constant
-      (/NaN|Infinity/.source + "|" + // binary integer
-      /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
-      /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
-      /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
-      /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
-      /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source),
-      lookbehind: !0
-    },
-    operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-  }), e.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, e.languages.insertBefore("javascript", "keyword", {
-    regex: {
-      // eslint-disable-next-line regexp/no-dupe-characters-character-class
-      pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        "regex-source": {
-          pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-          lookbehind: !0,
-          alias: "language-regex",
-          inside: e.languages.regex
-        },
-        "regex-delimiter": /^\/|\/$/,
-        "regex-flags": /^[a-z]+$/
-      }
-    },
-    // This must be declared before keyword because we use "function" inside the look-forward
-    "function-variable": {
-      pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
-      alias: "function"
-    },
-    parameter: [{
-      pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
-      lookbehind: !0,
-      inside: e.languages.javascript
-    }, {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-      lookbehind: !0,
-      inside: e.languages.javascript
-    }, {
-      pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-      lookbehind: !0,
-      inside: e.languages.javascript
-    }, {
-      pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
-      lookbehind: !0,
-      inside: e.languages.javascript
-    }],
-    constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-  }), e.languages.insertBefore("javascript", "string", {
-    hashbang: {
-      pattern: /^#!.*/,
-      greedy: !0,
-      alias: "comment"
-    },
-    "template-string": {
-      pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
-      greedy: !0,
-      inside: {
-        "template-punctuation": {
-          pattern: /^`|`$/,
-          alias: "string"
-        },
-        interpolation: {
-          pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-          lookbehind: !0,
-          inside: {
-            "interpolation-punctuation": {
-              pattern: /^\$\{|\}$/,
-              alias: "punctuation"
-            },
-            rest: e.languages.javascript
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    "string-property": {
-      pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-      lookbehind: !0,
-      greedy: !0,
-      alias: "property"
-    }
-  }), e.languages.insertBefore("javascript", "operator", {
-    "literal-property": {
-      pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-      lookbehind: !0,
-      alias: "property"
-    }
-  }), e.languages.markup && (e.languages.markup.tag.addInlined("script", "javascript"), e.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, "javascript")), e.languages.js = e.languages.javascript;
-}
-export {
-  a as j
-};