@glodon-aiot/react-components 3.3.0-beta.15 → 3.3.0-beta.18

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

@@ -0,0 +1,146 @@
+var a, t;
+function i() {
+  if (t)
+    return a;
+  t = 1, a = e, e.displayName = "javastacktrace", e.aliases = [];
+  function e(n) {
+    n.languages.javastacktrace = {
+      // java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...]
+      // Caused by: java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...]
+      // Caused by: com.example.myproject.MyProjectServletException
+      // Caused by: MidLevelException: LowLevelException
+      // Suppressed: Resource$CloseFailException: Resource ID = 0
+      summary: {
+        pattern: /^([\t ]*)(?:(?:Caused by:|Suppressed:|Exception in thread "[^"]*")[\t ]+)?[\w$.]+(?::.*)?$/m,
+        lookbehind: !0,
+        inside: {
+          keyword: {
+            pattern: /^([\t ]*)(?:(?:Caused by|Suppressed)(?=:)|Exception in thread)/m,
+            lookbehind: !0
+          },
+          // the current thread if the summary starts with 'Exception in thread'
+          string: {
+            pattern: /^(\s*)"[^"]*"/,
+            lookbehind: !0
+          },
+          exceptions: {
+            pattern: /^(:?\s*)[\w$.]+(?=:|$)/,
+            lookbehind: !0,
+            inside: {
+              "class-name": /[\w$]+$/,
+              namespace: /\b[a-z]\w*\b/,
+              punctuation: /\./
+            }
+          },
+          message: {
+            pattern: /(:\s*)\S.*/,
+            lookbehind: !0,
+            alias: "string"
+          },
+          punctuation: /:/
+        }
+      },
+      // at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1166)
+      // at org.hsqldb.jdbc.Util.throwError(Unknown Source) here could be some notes
+      // at java.base/java.lang.Class.forName0(Native Method)
+      // at Util.<init>(Unknown Source)
+      // at com.foo.loader/foo@9.0/com.foo.Main.run(Main.java:101)
+      // at com.foo.loader//com.foo.bar.App.run(App.java:12)
+      // at acme@2.1/org.acme.Lib.test(Lib.java:80)
+      // at MyClass.mash(MyClass.java:9)
+      //
+      // More information:
+      // https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/lang/StackTraceElement.html#toString()
+      //
+      // A valid Java module name is defined as:
+      //   "A module name consists of one or more Java identifiers (§3.8) separated by "." tokens."
+      // https://docs.oracle.com/javase/specs/jls/se9/html/jls-6.html#jls-ModuleName
+      //
+      // A Java module version is defined by this class:
+      // https://docs.oracle.com/javase/9/docs/api/java/lang/module/ModuleDescriptor.Version.html
+      // This is the implementation of the `parse` method in JDK13:
+      // https://github.com/matcdac/jdk/blob/2305df71d1b7710266ae0956d73927a225132c0f/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java#L1108
+      // However, to keep this simple, a version will be matched by the pattern /@[\w$.+-]*/.
+      "stack-frame": {
+        pattern: /^([\t ]*)at (?:[\w$./]|@[\w$.+-]*\/)+(?:<init>)?\([^()]*\)/m,
+        lookbehind: !0,
+        inside: {
+          keyword: {
+            pattern: /^(\s*)at(?= )/,
+            lookbehind: !0
+          },
+          source: [
+            // (Main.java:15)
+            // (Main.scala:15)
+            {
+              pattern: /(\()\w+\.\w+:\d+(?=\))/,
+              lookbehind: !0,
+              inside: {
+                file: /^\w+\.\w+/,
+                punctuation: /:/,
+                "line-number": {
+                  pattern: /\b\d+\b/,
+                  alias: "number"
+                }
+              }
+            },
+            // (Unknown Source)
+            // (Native Method)
+            // (...something...)
+            {
+              pattern: /(\()[^()]*(?=\))/,
+              lookbehind: !0,
+              inside: {
+                keyword: /^(?:Native Method|Unknown Source)$/
+              }
+            }
+          ],
+          "class-name": /[\w$]+(?=\.(?:<init>|[\w$]+)\()/,
+          function: /(?:<init>|[\w$]+)(?=\()/,
+          "class-loader": {
+            pattern: /(\s)[a-z]\w*(?:\.[a-z]\w*)*(?=\/[\w@$.]*\/)/,
+            lookbehind: !0,
+            alias: "namespace",
+            inside: {
+              punctuation: /\./
+            }
+          },
+          module: {
+            pattern: /([\s/])[a-z]\w*(?:\.[a-z]\w*)*(?:@[\w$.+-]*)?(?=\/)/,
+            lookbehind: !0,
+            inside: {
+              version: {
+                pattern: /(@)[\s\S]+/,
+                lookbehind: !0,
+                alias: "number"
+              },
+              punctuation: /[@.]/
+            }
+          },
+          namespace: {
+            pattern: /(?:\b[a-z]\w*\.)+/,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          punctuation: /[()/.]/
+        }
+      },
+      // ... 32 more
+      // ... 32 common frames omitted
+      more: {
+        pattern: /^([\t ]*)\.{3} \d+ [a-z]+(?: [a-z]+)*/m,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\.{3}/,
+          number: /\d+/,
+          keyword: /\b[a-z]+(?: [a-z]+)*\b/
+        }
+      }
+    };
+  }
+  return a;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,26 @@
+var e, r;
+function n() {
+  if (r)
+    return e;
+  r = 1, e = u, u.displayName = "jexl", u.aliases = [];
+  function u(a) {
+    a.languages.jexl = {
+      string: /(["'])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+      transform: {
+        pattern: /(\|\s*)[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*/,
+        alias: "function",
+        lookbehind: !0
+      },
+      function: /[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*\s*(?=\()/,
+      number: /\b\d+(?:\.\d+)?\b|\B\.\d+\b/,
+      operator: /[<>!]=?|-|\+|&&|==|\|\|?|\/\/?|[?:*^%]/,
+      boolean: /\b(?:false|true)\b/,
+      keyword: /\bin\b/,
+      punctuation: /[{}[\](),.]/
+    };
+  }
+  return e;
+}
+export {
+  n as __require
+};

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

@@ -0,0 +1,51 @@
+var i, n;
+function r() {
+  if (n)
+    return i;
+  n = 1, i = e, e.displayName = "jolie", e.aliases = [];
+  function e(t) {
+    t.languages.jolie = t.languages.extend("clike", {
+      string: {
+        pattern: /(^|[^\\])"(?:\\[\s\S]|[^"\\])*"/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /((?:\b(?:as|courier|embed|in|inputPort|outputPort|service)\b|@)[ \t]*)\w+/,
+        lookbehind: !0
+      },
+      keyword: /\b(?:as|cH|comp|concurrent|constants|courier|cset|csets|default|define|else|embed|embedded|execution|exit|extender|for|foreach|forward|from|global|if|import|in|include|init|inputPort|install|instanceof|interface|is_defined|linkIn|linkOut|main|new|nullProcess|outputPort|over|private|provide|public|scope|sequential|service|single|spawn|synchronized|this|throw|throws|type|undef|until|while|with)\b/,
+      function: /\b[a-z_]\w*(?=[ \t]*[@(])/i,
+      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?l?/i,
+      operator: /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[?\/%^@|]/,
+      punctuation: /[()[\]{},;.:]/,
+      builtin: /\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\b/
+    }), t.languages.insertBefore("jolie", "keyword", {
+      aggregates: {
+        pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/,
+        lookbehind: !0,
+        inside: {
+          keyword: /\bwith\b/,
+          "class-name": /\w+/,
+          punctuation: /,/
+        }
+      },
+      redirects: {
+        pattern: /(\bRedirects\s*:\s*)(?:\w+\s*=>\s*\w+\s*,\s*)*(?:\w+\s*=>\s*\w+)/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /,/,
+          "class-name": /\w+/,
+          operator: /=>/
+        }
+      },
+      property: {
+        pattern: /\b(?:Aggregates|[Ii]nterfaces|Java|Javascript|Jolie|[Ll]ocation|OneWay|[Pp]rotocol|Redirects|RequestResponse)\b(?=[ \t]*:)/
+      }
+    });
+  }
+  return i;
+}
+export {
+  r as __require
+};

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

@@ -0,0 +1,71 @@
+var r, a;
+function s() {
+  if (a)
+    return r;
+  a = 1, r = e, e.displayName = "jq", e.aliases = [];
+  function e(o) {
+    (function(u) {
+      var n = /\\\((?:[^()]|\([^()]*\))*\)/.source, i = RegExp(/(^|[^\\])"(?:[^"\r\n\\]|\\[^\r\n(]|__)*"/.source.replace(/__/g, function() {
+        return n;
+      })), t = {
+        interpolation: {
+          pattern: RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + n),
+          lookbehind: !0,
+          inside: {
+            content: {
+              pattern: /^(\\\()[\s\S]+(?=\)$)/,
+              lookbehind: !0,
+              inside: null
+              // see below
+            },
+            punctuation: /^\\\(|\)$/
+          }
+        }
+      }, l = u.languages.jq = {
+        comment: /#.*/,
+        property: {
+          pattern: RegExp(i.source + /(?=\s*:(?!:))/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: t
+        },
+        string: {
+          pattern: i,
+          lookbehind: !0,
+          greedy: !0,
+          inside: t
+        },
+        function: {
+          pattern: /(\bdef\s+)[a-z_]\w+/i,
+          lookbehind: !0
+        },
+        variable: /\B\$\w+/,
+        "property-literal": {
+          pattern: /\b[a-z_]\w*(?=\s*:(?!:))/i,
+          alias: "property"
+        },
+        keyword: /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/,
+        boolean: /\b(?:false|true)\b/,
+        number: /(?:\b\d+\.|\B\.)?\b\d+(?:[eE][+-]?\d+)?\b/,
+        operator: [{
+          pattern: /\|=?/,
+          alias: "pipe"
+        }, /\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|not|or)\b/],
+        "c-style-function": {
+          pattern: /\b[a-z_]\w*(?=\s*\()/i,
+          alias: "function"
+        },
+        punctuation: /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/,
+        dot: {
+          pattern: /\./,
+          alias: "important"
+        }
+      };
+      t.interpolation.inside.content.inside = l;
+    })(o);
+  }
+  return r;
+}
+export {
+  s as __require
+};

package/dist/es/node_modules/refractor/lang/js-extras.mjs

@@ -0,0 +1,104 @@
+var s, c;
+function f() {
+  if (c)
+    return s;
+  c = 1, s = t, t.displayName = "jsExtras", t.aliases = [];
+  function t(p) {
+    (function(a) {
+      a.languages.insertBefore("javascript", "function-variable", {
+        "method-variable": {
+          pattern: RegExp("(\\.\\s*)" + a.languages.javascript["function-variable"].pattern.source),
+          lookbehind: !0,
+          alias: ["function-variable", "method", "function", "property-access"]
+        }
+      }), a.languages.insertBefore("javascript", "function", {
+        method: {
+          pattern: RegExp("(\\.\\s*)" + a.languages.javascript.function.source),
+          lookbehind: !0,
+          alias: ["function", "property-access"]
+        }
+      }), a.languages.insertBefore("javascript", "constant", {
+        "known-class-name": [{
+          // standard built-ins
+          // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+          pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
+          alias: "class-name"
+        }, {
+          // errors
+          pattern: /\b(?:[A-Z]\w*)Error\b/,
+          alias: "class-name"
+        }]
+      });
+      function r(u, b) {
+        return RegExp(u.replace(/<ID>/g, function() {
+          return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+        }), b);
+      }
+      a.languages.insertBefore("javascript", "keyword", {
+        imports: {
+          // https://tc39.es/ecma262/#sec-imports
+          pattern: r(/(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source),
+          lookbehind: !0,
+          inside: a.languages.javascript
+        },
+        exports: {
+          // https://tc39.es/ecma262/#sec-exports
+          pattern: r(/(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source),
+          lookbehind: !0,
+          inside: a.languages.javascript
+        }
+      }), a.languages.javascript.keyword.unshift({
+        pattern: /\b(?:as|default|export|from|import)\b/,
+        alias: "module"
+      }, {
+        pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
+        alias: "control-flow"
+      }, {
+        pattern: /\bnull\b/,
+        alias: ["null", "nil"]
+      }, {
+        pattern: /\bundefined\b/,
+        alias: "nil"
+      }), a.languages.insertBefore("javascript", "operator", {
+        spread: {
+          pattern: /\.{3}/,
+          alias: "operator"
+        },
+        arrow: {
+          pattern: /=>/,
+          alias: "operator"
+        }
+      }), a.languages.insertBefore("javascript", "punctuation", {
+        "property-access": {
+          pattern: r(/(\.\s*)#?<ID>/.source),
+          lookbehind: !0
+        },
+        "maybe-class-name": {
+          pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
+          lookbehind: !0
+        },
+        dom: {
+          // this contains only a few commonly used DOM variables
+          pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
+          alias: "variable"
+        },
+        console: {
+          pattern: /\bconsole(?=\s*\.)/,
+          alias: "class-name"
+        }
+      });
+      for (var o = ["function", "function-variable", "method", "method-variable", "property-access"], n = 0; n < o.length; n++) {
+        var i = o[n], e = a.languages.javascript[i];
+        a.util.type(e) === "RegExp" && (e = a.languages.javascript[i] = {
+          pattern: e
+        });
+        var l = e.inside || {};
+        e.inside = l, l["maybe-class-name"] = /^[A-Z][\s\S]*/;
+      }
+    })(p);
+  }
+  return s;
+}
+export {
+  f as __require
+};

package/dist/es/node_modules/refractor/lang/js-templates.mjs

@@ -0,0 +1,153 @@
+var z, O;
+function B() {
+  if (O)
+    return z;
+  O = 1, z = d, d.displayName = "jsTemplates", d.aliases = [];
+  function d(C) {
+    (function(a) {
+      var h = a.languages.javascript["template-string"], E = h.pattern.source, b = h.inside.interpolation, S = b.inside["interpolation-punctuation"], L = b.pattern.source;
+      function c(e, n) {
+        if (a.languages[e])
+          return {
+            pattern: RegExp("((?:" + n + ")\\s*)" + E),
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              "template-punctuation": {
+                pattern: /^`|`$/,
+                alias: "string"
+              },
+              "embedded-code": {
+                pattern: /[\s\S]+/,
+                alias: e
+              }
+            }
+          };
+      }
+      a.languages.javascript["template-string"] = [
+        // styled-jsx:
+        //   css`a { color: #25F; }`
+        // styled-components:
+        //   styled.h1`color: red;`
+        c("css", /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source),
+        // html`<p></p>`
+        // div.innerHTML = `<p></p>`
+        c("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source),
+        // svg`<path fill="#fff" d="M55.37 ..."/>`
+        c("svg", /\bsvg/.source),
+        // md`# h1`, markdown`## h2`
+        c("markdown", /\b(?:markdown|md)/.source),
+        // gql`...`, graphql`...`, graphql.experimental`...`
+        c("graphql", /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source),
+        // sql`...`
+        c("sql", /\bsql/.source),
+        // vanilla template string
+        h
+      ].filter(Boolean);
+      function R(e, n) {
+        return "___" + n.toUpperCase() + "_" + e + "___";
+      }
+      function q(e, n, r) {
+        var t = {
+          code: e,
+          grammar: n,
+          language: r
+        };
+        return a.hooks.run("before-tokenize", t), t.tokens = a.tokenize(t.code, t.grammar), a.hooks.run("after-tokenize", t), t.tokens;
+      }
+      function G(e) {
+        var n = {};
+        n["interpolation-punctuation"] = S;
+        var r = a.tokenize(e, n);
+        if (r.length === 3) {
+          var t = [1, 1];
+          t.push.apply(t, q(r[1], a.languages.javascript, "javascript")), r.splice.apply(r, t);
+        }
+        return new a.Token("interpolation", r, b.alias, e);
+      }
+      function H(e, n, r) {
+        var t = a.tokenize(e, {
+          interpolation: {
+            pattern: RegExp(L),
+            lookbehind: !0
+          }
+        }), l = 0, f = {}, p = t.map(function(s) {
+          if (typeof s == "string")
+            return s;
+          for (var o = s.content, i; e.indexOf(i = R(l++, r)) !== -1; )
+            ;
+          return f[i] = o, i;
+        }).join(""), v = q(p, n, r), y = Object.keys(f);
+        l = 0;
+        function u(s) {
+          for (var o = 0; o < s.length; o++) {
+            if (l >= y.length)
+              return;
+            var i = s[o];
+            if (typeof i == "string" || typeof i.content == "string") {
+              var k = y[l], m = typeof i == "string" ? i : (
+                /** @type {string} */
+                i.content
+              ), T = m.indexOf(k);
+              if (T !== -1) {
+                ++l;
+                var A = m.substring(0, T), M = G(f[k]), w = m.substring(T + k.length), g = [];
+                if (A && g.push(A), g.push(M), w) {
+                  var x = [w];
+                  u(x), g.push.apply(g, x);
+                }
+                typeof i == "string" ? (s.splice.apply(s, [o, 1].concat(g)), o += g.length - 1) : i.content = g;
+              }
+            } else {
+              var _ = i.content;
+              Array.isArray(_) ? u(_) : u([_]);
+            }
+          }
+        }
+        return u(v), new a.Token(r, v, "language-" + r, e);
+      }
+      var J = {
+        javascript: !0,
+        js: !0,
+        typescript: !0,
+        ts: !0,
+        jsx: !0,
+        tsx: !0
+      };
+      a.hooks.add("after-tokenize", function(e) {
+        if (!(e.language in J))
+          return;
+        function n(r) {
+          for (var t = 0, l = r.length; t < l; t++) {
+            var f = r[t];
+            if (typeof f != "string") {
+              var p = f.content;
+              if (!Array.isArray(p)) {
+                typeof p != "string" && n([p]);
+                continue;
+              }
+              if (f.type === "template-string") {
+                var v = p[1];
+                if (p.length === 3 && typeof v != "string" && v.type === "embedded-code") {
+                  var y = j(v), u = v.alias, s = Array.isArray(u) ? u[0] : u, o = a.languages[s];
+                  if (!o)
+                    continue;
+                  p[1] = H(y, o, s);
+                }
+              } else
+                n(p);
+            }
+          }
+        }
+        n(e.tokens);
+      });
+      function j(e) {
+        return typeof e == "string" ? e : Array.isArray(e) ? e.map(j).join("") : j(e.content);
+      }
+    })(C);
+  }
+  return z;
+}
+export {
+  B as __require
+};

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

@@ -0,0 +1,83 @@
+import { __require as c } from "./javadoclike.mjs";
+import { __require as d } from "./typescript.mjs";
+var s, i;
+function v() {
+  if (i)
+    return s;
+  i = 1;
+  var u = c(), p = d();
+  s = r, r.displayName = "jsdoc", r.aliases = [];
+  function r(t) {
+    t.register(u), t.register(p), function(e) {
+      var a = e.languages.javascript, n = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source, o = "(@(?:arg|argument|param|property)\\s+(?:" + n + "\\s+)?)";
+      e.languages.jsdoc = e.languages.extend("javadoclike", {
+        parameter: {
+          // @param {string} foo - foo bar
+          pattern: RegExp(o + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source),
+          lookbehind: !0,
+          inside: {
+            punctuation: /\./
+          }
+        }
+      }), e.languages.insertBefore("jsdoc", "keyword", {
+        "optional-parameter": {
+          // @param {string} [baz.foo="bar"] foo bar
+          pattern: RegExp(o + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source),
+          lookbehind: !0,
+          inside: {
+            parameter: {
+              pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/,
+              lookbehind: !0,
+              inside: {
+                punctuation: /\./
+              }
+            },
+            code: {
+              pattern: /(=)[\s\S]*(?=\]$)/,
+              lookbehind: !0,
+              inside: a,
+              alias: "language-javascript"
+            },
+            punctuation: /[=[\]]/
+          }
+        },
+        "class-name": [{
+          pattern: RegExp(/(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(/<TYPE>/g, function() {
+            return n;
+          })),
+          lookbehind: !0,
+          inside: {
+            punctuation: /\./
+          }
+        }, {
+          pattern: RegExp("(@[a-z]+\\s+)" + n),
+          lookbehind: !0,
+          inside: {
+            string: a.string,
+            number: a.number,
+            boolean: a.boolean,
+            keyword: e.languages.typescript.keyword,
+            operator: /=>|\.\.\.|[&|?:*]/,
+            punctuation: /[.,;=<>{}()[\]]/
+          }
+        }],
+        example: {
+          pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/,
+          lookbehind: !0,
+          inside: {
+            code: {
+              pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m,
+              lookbehind: !0,
+              inside: a,
+              alias: "language-javascript"
+            }
+          }
+        }
+      }), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
+    }(t);
+  }
+  return s;
+}
+export {
+  v as __require
+};

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

@@ -0,0 +1,36 @@
+var r, t;
+function a() {
+  if (t)
+    return r;
+  t = 1, r = e, e.displayName = "json", e.aliases = ["webmanifest"];
+  function e(n) {
+    n.languages.json = {
+      property: {
+        pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      string: {
+        pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+        greedy: !0
+      },
+      number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      punctuation: /[{}[\],]/,
+      operator: /:/,
+      boolean: /\b(?:false|true)\b/,
+      null: {
+        pattern: /\bnull\b/,
+        alias: "keyword"
+      }
+    }, n.languages.webmanifest = n.languages.json;
+  }
+  return r;
+}
+export {
+  a as __require
+};