@distri/react 0.2.7 → 0.2.8

package/dist/chunk-G3RVOSQS.js

@@ -0,0 +1,47 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/false.js
+var require_false = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/false.js"(exports, module) {
+    module.exports = $false;
+    $false.displayName = "$false";
+    $false.aliases = [];
+    function $false(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages["false"] = {
+          comment: {
+            pattern: /\{[^}]*\}/
+          },
+          string: {
+            pattern: /"[^"]*"/,
+            greedy: true
+          },
+          "character-code": {
+            pattern: /'(?:[^\r]|\r\n?)/,
+            alias: "number"
+          },
+          "assembler-code": {
+            pattern: /\d+`/,
+            alias: "important"
+          },
+          number: /\d+/,
+          operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
+          punctuation: /\[|\]/,
+          variable: /[a-z]/,
+          "non-standard": {
+            pattern: /[()<BDO®]/,
+            alias: "bold"
+          }
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_false
+};

package/dist/chunk-GBDND3J7.js

@@ -0,0 +1,31 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/n4js.js
+var require_n4js = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/n4js.js"(exports, module) {
+    module.exports = n4js;
+    n4js.displayName = "n4js";
+    n4js.aliases = ["n4jsd"];
+    function n4js(Prism) {
+      Prism.languages.n4js = Prism.languages.extend("javascript", {
+        // Keywords from N4JS language spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html
+        keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/
+      });
+      Prism.languages.insertBefore("n4js", "constant", {
+        // Annotations in N4JS spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html#_annotations
+        annotation: {
+          pattern: /@+\w+/,
+          alias: "operator"
+        }
+      });
+      Prism.languages.n4jsd = Prism.languages.n4js;
+    }
+  }
+});
+
+export {
+  require_n4js
+};

package/dist/chunk-GHHVUAN4.js

@@ -0,0 +1,39 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/qore.js
+var require_qore = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/qore.js"(exports, module) {
+    module.exports = qore;
+    qore.displayName = "qore";
+    qore.aliases = [];
+    function qore(Prism) {
+      Prism.languages.qore = Prism.languages.extend("clike", {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
+          lookbehind: true
+        },
+        // Overridden to allow unescaped multi-line strings
+        string: {
+          pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+          greedy: true
+        },
+        keyword: /\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\b/,
+        boolean: /\b(?:false|true)\b/i,
+        function: /\$?\b(?!\d)\w+(?=\()/,
+        number: /\b(?:0b[01]+|0x(?:[\da-f]*\.)?[\da-fp\-]+|(?:\d+(?:\.\d+)?|\.\d+)(?:e\d+)?[df]|(?:\d+(?:\.\d+)?|\.\d+))\b/i,
+        operator: {
+          pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
+          lookbehind: true
+        },
+        variable: /\$(?!\d)\w+\b/
+      });
+    }
+  }
+});
+
+export {
+  require_qore
+};

package/dist/chunk-GKYHP5DM.js

@@ -0,0 +1,46 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/roboconf.js
+var require_roboconf = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/roboconf.js"(exports, module) {
+    module.exports = roboconf;
+    roboconf.displayName = "roboconf";
+    roboconf.aliases = [];
+    function roboconf(Prism) {
+      Prism.languages.roboconf = {
+        comment: /#.*/,
+        keyword: {
+          pattern: /(^|\s)(?:(?:external|import)\b|(?:facet|instance of)(?=[ \t]+[\w-]+[ \t]*\{))/,
+          lookbehind: true
+        },
+        component: {
+          pattern: /[\w-]+(?=[ \t]*\{)/,
+          alias: "variable"
+        },
+        property: /[\w.-]+(?=[ \t]*:)/,
+        value: {
+          pattern: /(=[ \t]*(?![ \t]))[^,;]+/,
+          lookbehind: true,
+          alias: "attr-value"
+        },
+        optional: {
+          pattern: /\(optional\)/,
+          alias: "builtin"
+        },
+        wildcard: {
+          pattern: /(\.)\*/,
+          lookbehind: true,
+          alias: "operator"
+        },
+        punctuation: /[{},.;:=]/
+      };
+    }
+  }
+});
+
+export {
+  require_roboconf
+};

package/dist/chunk-GN5JY4ON.js

@@ -0,0 +1,108 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pure.js
+var require_pure = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pure.js"(exports, module) {
+    module.exports = pure;
+    pure.displayName = "pure";
+    pure.aliases = [];
+    function pure(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.pure = {
+          comment: [
+            {
+              pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+              lookbehind: true
+            },
+            {
+              pattern: /(^|[^\\:])\/\/.*/,
+              lookbehind: true
+            },
+            /#!.+/
+          ],
+          "inline-lang": {
+            pattern: /%<[\s\S]+?%>/,
+            greedy: true,
+            inside: {
+              lang: {
+                pattern: /(^%< *)-\*-.+?-\*-/,
+                lookbehind: true,
+                alias: "comment"
+              },
+              delimiter: {
+                pattern: /^%<.*|%>$/,
+                alias: "punctuation"
+              }
+            }
+          },
+          string: {
+            pattern: /"(?:\\.|[^"\\\r\n])*"/,
+            greedy: true
+          },
+          number: {
+            // The look-behind prevents wrong highlighting of the .. operator
+            pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?L?)/i,
+            lookbehind: true
+          },
+          keyword: /\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\b/,
+          function: /\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\b/,
+          special: {
+            pattern: /\b__[a-z]+__\b/i,
+            alias: "builtin"
+          },
+          // Any combination of operator chars can be an operator
+          // eslint-disable-next-line no-misleading-character-class
+          operator: /(?:[!"#$%&'*+,\-.\/:<=>?@\\^`|~\u00a1-\u00bf\u00d7-\u00f7\u20d0-\u2bff]|\b_+\b)+|\b(?:and|div|mod|not|or)\b/,
+          // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?
+          punctuation: /[(){}\[\];,|]/
+        };
+        var inlineLanguages = [
+          "c",
+          {
+            lang: "c++",
+            alias: "cpp"
+          },
+          "fortran"
+        ];
+        var inlineLanguageRe = /%< *-\*- *<lang>\d* *-\*-[\s\S]+?%>/.source;
+        inlineLanguages.forEach(function(lang) {
+          var alias = lang;
+          if (typeof lang !== "string") {
+            alias = lang.alias;
+            lang = lang.lang;
+          }
+          if (Prism2.languages[alias]) {
+            var o = {};
+            o["inline-lang-" + alias] = {
+              pattern: RegExp(
+                inlineLanguageRe.replace(
+                  "<lang>",
+                  lang.replace(/([.+*?\/\\(){}\[\]])/g, "\\$1")
+                ),
+                "i"
+              ),
+              inside: Prism2.util.clone(Prism2.languages.pure["inline-lang"].inside)
+            };
+            o["inline-lang-" + alias].inside.rest = Prism2.util.clone(
+              Prism2.languages[alias]
+            );
+            Prism2.languages.insertBefore("pure", "inline-lang", o);
+          }
+        });
+        if (Prism2.languages.c) {
+          Prism2.languages.pure["inline-lang"].inside.rest = Prism2.util.clone(
+            Prism2.languages.c
+          );
+        }
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_pure
+};

package/dist/chunk-GSJ4ZPME.js

@@ -0,0 +1,44 @@
+"use client";
+import {
+  require_json
+} from "./chunk-VFSK564P.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/json5.js
+var require_json5 = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/json5.js"(exports, module) {
+    var refractorJson = require_json();
+    module.exports = json5;
+    json5.displayName = "json5";
+    json5.aliases = [];
+    function json5(Prism) {
+      Prism.register(refractorJson);
+      (function(Prism2) {
+        var string = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
+        Prism2.languages.json5 = Prism2.languages.extend("json", {
+          property: [
+            {
+              pattern: RegExp(string.source + "(?=\\s*:)"),
+              greedy: true
+            },
+            {
+              pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
+              alias: "unquoted"
+            }
+          ],
+          string: {
+            pattern: string,
+            greedy: true
+          },
+          number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_json5
+};

package/dist/chunk-HA25XUMO.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  require_haskell
+} from "./chunk-W3M6SKHX.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/purescript.js
+var require_purescript = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/purescript.js"(exports, module) {
+    var refractorHaskell = require_haskell();
+    module.exports = purescript;
+    purescript.displayName = "purescript";
+    purescript.aliases = ["purs"];
+    function purescript(Prism) {
+      Prism.register(refractorHaskell);
+      Prism.languages.purescript = Prism.languages.extend("haskell", {
+        keyword: /\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b|∀/,
+        "import-statement": {
+          // The imported or hidden names are not included in this import
+          // statement. This is because we want to highlight those exactly like
+          // we do for the names in the program.
+          pattern: /(^[\t ]*)import\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*(?:\s+as\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+          lookbehind: true,
+          inside: {
+            keyword: /\b(?:as|hiding|import)\b/,
+            punctuation: /\./
+          }
+        },
+        // These are builtin functions only. Constructors are highlighted later as a constant.
+        builtin: /\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\b/,
+        operator: [
+          // Infix operators
+          Prism.languages.haskell.operator[0],
+          // ASCII operators
+          Prism.languages.haskell.operator[2],
+          // All UTF16 Unicode operator symbols
+          // This regex is equivalent to /(?=[\x80-\uFFFF])[\p{gc=Math_Symbol}\p{gc=Currency_Symbol}\p{Modifier_Symbol}\p{Other_Symbol}]/u
+          // See https://github.com/PrismJS/prism/issues/3006 for more details.
+          /[\xa2-\xa6\xa8\xa9\xac\xae-\xb1\xb4\xb8\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384\u0385\u03f6\u0482\u058d-\u058f\u0606-\u0608\u060b\u060e\u060f\u06de\u06e9\u06fd\u06fe\u07f6\u07fe\u07ff\u09f2\u09f3\u09fa\u09fb\u0af1\u0b70\u0bf3-\u0bfa\u0c7f\u0d4f\u0d79\u0e3f\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce\u0fcf\u0fd5-\u0fd8\u109e\u109f\u1390-\u1399\u166d\u17db\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd\u1ffe\u2044\u2052\u207a-\u207c\u208a-\u208c\u20a0-\u20bf\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a\u218b\u2190-\u2307\u230c-\u2328\u232b-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012\u3013\u3020\u3036\u3037\u303e\u303f\u309b\u309c\u3190\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua700-\ua716\ua720\ua721\ua789\ua78a\ua828-\ua82b\ua836-\ua839\uaa77-\uaa79\uab5b\uab6a\uab6b\ufb29\ufbb2-\ufbc1\ufdfc\ufdfd\ufe62\ufe64-\ufe66\ufe69\uff04\uff0b\uff1c-\uff1e\uff3e\uff40\uff5c\uff5e\uffe0-\uffe6\uffe8-\uffee\ufffc\ufffd]/
+        ]
+      });
+      Prism.languages.purs = Prism.languages.purescript;
+    }
+  }
+});
+
+export {
+  require_purescript
+};

package/dist/chunk-HB5YQXW7.js

@@ -0,0 +1,41 @@
+"use client";
+import {
+  require_jsx
+} from "./chunk-YX5EOMYE.js";
+import {
+  require_typescript
+} from "./chunk-P4DAHZUQ.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tsx.js
+var require_tsx = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tsx.js"(exports, module) {
+    var refractorJsx = require_jsx();
+    var refractorTypescript = require_typescript();
+    module.exports = tsx;
+    tsx.displayName = "tsx";
+    tsx.aliases = [];
+    function tsx(Prism) {
+      Prism.register(refractorJsx);
+      Prism.register(refractorTypescript);
+      (function(Prism2) {
+        var typescript = Prism2.util.clone(Prism2.languages.typescript);
+        Prism2.languages.tsx = Prism2.languages.extend("jsx", typescript);
+        delete Prism2.languages.tsx["parameter"];
+        delete Prism2.languages.tsx["literal-property"];
+        var tag = Prism2.languages.tsx.tag;
+        tag.pattern = RegExp(
+          /(^|[^\w$]|(?=<\/))/.source + "(?:" + tag.pattern.source + ")",
+          tag.pattern.flags
+        );
+        tag.lookbehind = true;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_tsx
+};

package/dist/chunk-HBR63ZQM.js

@@ -0,0 +1,83 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/antlr4.js
+var require_antlr4 = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/antlr4.js"(exports, module) {
+    module.exports = antlr4;
+    antlr4.displayName = "antlr4";
+    antlr4.aliases = ["g4"];
+    function antlr4(Prism) {
+      Prism.languages.antlr4 = {
+        comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+        string: {
+          pattern: /'(?:\\.|[^\\'\r\n])*'/,
+          greedy: true
+        },
+        "character-class": {
+          pattern: /\[(?:\\.|[^\\\]\r\n])*\]/,
+          greedy: true,
+          alias: "regex",
+          inside: {
+            range: {
+              pattern: /([^[]|(?:^|[^\\])(?:\\\\)*\\\[)-(?!\])/,
+              lookbehind: true,
+              alias: "punctuation"
+            },
+            escape: /\\(?:u(?:[a-fA-F\d]{4}|\{[a-fA-F\d]+\})|[pP]\{[=\w-]+\}|[^\r\nupP])/,
+            punctuation: /[\[\]]/
+          }
+        },
+        action: {
+          pattern: /\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\}/,
+          greedy: true,
+          inside: {
+            content: {
+              // this might be C, C++, Python, Java, C#, or any other language ANTLR4 compiles to
+              pattern: /(\{)[\s\S]+(?=\})/,
+              lookbehind: true
+            },
+            punctuation: /[{}]/
+          }
+        },
+        command: {
+          pattern: /(->\s*(?!\s))(?:\s*(?:,\s*)?\b[a-z]\w*(?:\s*\([^()\r\n]*\))?)+(?=\s*;)/i,
+          lookbehind: true,
+          inside: {
+            function: /\b\w+(?=\s*(?:[,(]|$))/,
+            punctuation: /[,()]/
+          }
+        },
+        annotation: {
+          pattern: /@\w+(?:::\w+)*/,
+          alias: "keyword"
+        },
+        label: {
+          pattern: /#[ \t]*\w+/,
+          alias: "punctuation"
+        },
+        keyword: /\b(?:catch|channels|finally|fragment|grammar|import|lexer|locals|mode|options|parser|returns|throws|tokens)\b/,
+        definition: [
+          {
+            pattern: /\b[a-z]\w*(?=\s*:)/,
+            alias: ["rule", "class-name"]
+          },
+          {
+            pattern: /\b[A-Z]\w*(?=\s*:)/,
+            alias: ["token", "constant"]
+          }
+        ],
+        constant: /\b[A-Z][A-Z_]*\b/,
+        operator: /\.\.|->|[|~]|[*+?]\??/,
+        punctuation: /[;:()=]/
+      };
+      Prism.languages.g4 = Prism.languages.antlr4;
+    }
+  }
+});
+
+export {
+  require_antlr4
+};

package/dist/chunk-HENRLFPS.js

@@ -0,0 +1,130 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/css-extras.js
+var require_css_extras = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/css-extras.js"(exports, module) {
+    module.exports = cssExtras;
+    cssExtras.displayName = "cssExtras";
+    cssExtras.aliases = [];
+    function cssExtras(Prism) {
+      ;
+      (function(Prism2) {
+        var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+        var selectorInside;
+        Prism2.languages.css.selector = {
+          pattern: Prism2.languages.css.selector.pattern,
+          lookbehind: true,
+          inside: selectorInside = {
+            "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+            "pseudo-class": /:[-\w]+/,
+            class: /\.[-\w]+/,
+            id: /#[-\w]+/,
+            attribute: {
+              pattern: RegExp(`\\[(?:[^[\\]"']|` + string.source + ")*\\]"),
+              greedy: true,
+              inside: {
+                punctuation: /^\[|\]$/,
+                "case-sensitivity": {
+                  pattern: /(\s)[si]$/i,
+                  lookbehind: true,
+                  alias: "keyword"
+                },
+                namespace: {
+                  pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
+                  lookbehind: true,
+                  inside: {
+                    punctuation: /\|$/
+                  }
+                },
+                "attr-name": {
+                  pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
+                  lookbehind: true
+                },
+                "attr-value": [
+                  string,
+                  {
+                    pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
+                    lookbehind: true
+                  }
+                ],
+                operator: /[|~*^$]?=/
+              }
+            },
+            "n-th": [
+              {
+                pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
+                lookbehind: true,
+                inside: {
+                  number: /[\dn]+/,
+                  operator: /[+-]/
+                }
+              },
+              {
+                pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
+                lookbehind: true
+              }
+            ],
+            combinator: />|\+|~|\|\|/,
+            // the `tag` token has been existed and removed.
+            // because we can't find a perfect tokenize to match it.
+            // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
+            punctuation: /[(),]/
+          }
+        };
+        Prism2.languages.css["atrule"].inside["selector-function-argument"].inside = selectorInside;
+        Prism2.languages.insertBefore("css", "property", {
+          variable: {
+            pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
+            lookbehind: true
+          }
+        });
+        var unit = {
+          pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
+          lookbehind: true
+        };
+        var number = {
+          pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+          lookbehind: true
+        };
+        Prism2.languages.insertBefore("css", "function", {
+          operator: {
+            pattern: /(\s)[+\-*\/](?=\s)/,
+            lookbehind: true
+          },
+          // CAREFUL!
+          // Previewers and Inline color use hexcode and color.
+          hexcode: {
+            pattern: /\B#[\da-f]{3,8}\b/i,
+            alias: "color"
+          },
+          color: [
+            {
+              pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
+              lookbehind: true
+            },
+            {
+              pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
+              inside: {
+                unit,
+                number,
+                function: /[\w-]+(?=\()/,
+                punctuation: /[(),]/
+              }
+            }
+          ],
+          // it's important that there is no boundary assertion after the hex digits
+          entity: /\\[\da-f]{1,8}/i,
+          unit,
+          number
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_css_extras
+};

package/dist/chunk-HI5JB7PA.js

@@ -0,0 +1,43 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/agda.js
+var require_agda = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/agda.js"(exports, module) {
+    module.exports = agda;
+    agda.displayName = "agda";
+    agda.aliases = [];
+    function agda(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.agda = {
+          comment: /\{-[\s\S]*?(?:-\}|$)|--.*/,
+          string: {
+            pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
+            greedy: true
+          },
+          punctuation: /[(){}⦃⦄.;@]/,
+          "class-name": {
+            pattern: /((?:data|record) +)\S+/,
+            lookbehind: true
+          },
+          function: {
+            pattern: /(^[ \t]*)(?!\s)[^:\r\n]+(?=:)/m,
+            lookbehind: true
+          },
+          operator: {
+            pattern: /(^\s*|\s)(?:[=|:∀→λ\\?_]|->)(?=\s)/,
+            lookbehind: true
+          },
+          keyword: /\b(?:Set|abstract|constructor|data|eta-equality|field|forall|hiding|import|in|inductive|infix|infixl|infixr|instance|let|macro|module|mutual|no-eta-equality|open|overlap|pattern|postulate|primitive|private|public|quote|quoteContext|quoteGoal|quoteTerm|record|renaming|rewrite|syntax|tactic|unquote|unquoteDecl|unquoteDef|using|variable|where|with)\b/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_agda
+};