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

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

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

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

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

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

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

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

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

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