@distri/react 0.3.1 → 0.3.2

package/dist/chunk-AH6RNPD4.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-XUQ4ZZPG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/django.js
+var require_django = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/django.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = django;
+    django.displayName = "django";
+    django.aliases = ["jinja2"];
+    function django(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        Prism2.languages.django = {
+          comment: /^\{#[\s\S]*?#\}$/,
+          tag: {
+            pattern: /(^\{%[+-]?\s*)\w+/,
+            lookbehind: true,
+            alias: "keyword"
+          },
+          delimiter: {
+            pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
+            alias: "punctuation"
+          },
+          string: {
+            pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+            greedy: true
+          },
+          filter: {
+            pattern: /(\|)\w+/,
+            lookbehind: true,
+            alias: "function"
+          },
+          test: {
+            pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+            lookbehind: true,
+            alias: "function"
+          },
+          function: /\b[a-z_]\w+(?=\s*\()/i,
+          keyword: /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+          operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+          number: /\b\d+(?:\.\d+)?\b/,
+          boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
+          variable: /\b\w+\b/,
+          punctuation: /[{}[\](),.:;]/
+        };
+        var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g;
+        var markupTemplating = Prism2.languages["markup-templating"];
+        Prism2.hooks.add("before-tokenize", function(env) {
+          markupTemplating.buildPlaceholders(env, "django", pattern);
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          markupTemplating.tokenizePlaceholders(env, "django");
+        });
+        Prism2.languages.jinja2 = Prism2.languages.django;
+        Prism2.hooks.add("before-tokenize", function(env) {
+          markupTemplating.buildPlaceholders(env, "jinja2", pattern);
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          markupTemplating.tokenizePlaceholders(env, "jinja2");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_django
+};

package/dist/chunk-AKPQ2QSW.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cypher.js
+var require_cypher = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cypher.js"(exports, module) {
+    module.exports = cypher;
+    cypher.displayName = "cypher";
+    cypher.aliases = [];
+    function cypher(Prism) {
+      Prism.languages.cypher = {
+        // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
+        comment: /\/\/.*/,
+        string: {
+          pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
+          lookbehind: true,
+          greedy: true
+        },
+        relationship: {
+          pattern: /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
+          lookbehind: true,
+          greedy: true,
+          alias: "property"
+        },
+        identifier: {
+          pattern: /`(?:[^`\\\r\n])*`/,
+          greedy: true
+        },
+        variable: /\$\w+/,
+        // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
+        keyword: /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
+        function: /\b\w+\b(?=\s*\()/,
+        boolean: /\b(?:false|null|true)\b/i,
+        number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+        // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
+        operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
+        punctuation: /[()[\]{},;.]/
+      };
+    }
+  }
+});
+
+export {
+  require_cypher
+};

package/dist/chunk-AL5F2RG6.js

@@ -0,0 +1,75 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/moonscript.js
+var require_moonscript = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/moonscript.js"(exports, module) {
+    module.exports = moonscript;
+    moonscript.displayName = "moonscript";
+    moonscript.aliases = ["moon"];
+    function moonscript(Prism) {
+      Prism.languages.moonscript = {
+        comment: /--.*/,
+        string: [
+          {
+            pattern: /'[^']*'|\[(=*)\[[\s\S]*?\]\1\]/,
+            greedy: true
+          },
+          {
+            pattern: /"[^"]*"/,
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: /#\{[^{}]*\}/,
+                inside: {
+                  moonscript: {
+                    pattern: /(^#\{)[\s\S]+(?=\})/,
+                    lookbehind: true,
+                    inside: null
+                    // see beow
+                  },
+                  "interpolation-punctuation": {
+                    pattern: /#\{|\}/,
+                    alias: "punctuation"
+                  }
+                }
+              }
+            }
+          }
+        ],
+        "class-name": [
+          {
+            pattern: /(\b(?:class|extends)[ \t]+)\w+/,
+            lookbehind: true
+          },
+          // class-like names start with a capital letter
+          /\b[A-Z]\w*/
+        ],
+        keyword: /\b(?:class|continue|do|else|elseif|export|extends|for|from|if|import|in|local|nil|return|self|super|switch|then|unless|using|when|while|with)\b/,
+        variable: /@@?\w*/,
+        property: {
+          pattern: /\b(?!\d)\w+(?=:)|(:)(?!\d)\w+/,
+          lookbehind: true
+        },
+        function: {
+          pattern: /\b(?:_G|_VERSION|assert|collectgarbage|coroutine\.(?:create|resume|running|status|wrap|yield)|debug\.(?:debug|getfenv|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|setfenv|sethook|setlocal|setmetatable|setupvalue|traceback)|dofile|error|getfenv|getmetatable|io\.(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write)|ipairs|load|loadfile|loadstring|math\.(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|ldexp|log|log10|max|min|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh)|module|next|os\.(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname)|package\.(?:cpath|loaded|loadlib|path|preload|seeall)|pairs|pcall|print|rawequal|rawget|rawset|require|select|setfenv|setmetatable|string\.(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|rep|reverse|sub|upper)|table\.(?:concat|insert|maxn|remove|sort)|tonumber|tostring|type|unpack|xpcall)\b/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        boolean: /\b(?:false|true)\b/,
+        number: /(?:\B\.\d+|\b\d+\.\d+|\b\d+(?=[eE]))(?:[eE][-+]?\d+)?\b|\b(?:0x[a-fA-F\d]+|\d+)(?:U?LL)?\b/,
+        operator: /\.{3}|[-=]>|~=|(?:[-+*/%<>!=]|\.\.)=?|[:#^]|\b(?:and|or)\b=?|\b(?:not)\b/,
+        punctuation: /[.,()[\]{}\\]/
+      };
+      Prism.languages.moonscript.string[1].inside.interpolation.inside.moonscript.inside = Prism.languages.moonscript;
+      Prism.languages.moon = Prism.languages.moonscript;
+    }
+  }
+});
+
+export {
+  require_moonscript
+};

package/dist/chunk-ANJSFC3S.js

@@ -0,0 +1,139 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-XUQ4ZZPG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ftl.js
+var require_ftl = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ftl.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = ftl;
+    ftl.displayName = "ftl";
+    ftl.aliases = [];
+    function ftl(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        var FTL_EXPR = /[^<()"']|\((?:<expr>)*\)|<(?!#--)|<#--(?:[^-]|-(?!->))*-->|"(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'/.source;
+        for (var i = 0; i < 2; i++) {
+          FTL_EXPR = FTL_EXPR.replace(/<expr>/g, function() {
+            return FTL_EXPR;
+          });
+        }
+        FTL_EXPR = FTL_EXPR.replace(/<expr>/g, /[^\s\S]/.source);
+        var ftl2 = {
+          comment: /<#--[\s\S]*?-->/,
+          string: [
+            {
+              // raw string
+              pattern: /\br("|')(?:(?!\1)[^\\]|\\.)*\1/,
+              greedy: true
+            },
+            {
+              pattern: RegExp(
+                /("|')(?:(?!\1|\$\{)[^\\]|\\.|\$\{(?:(?!\})(?:<expr>))*\})*\1/.source.replace(
+                  /<expr>/g,
+                  function() {
+                    return FTL_EXPR;
+                  }
+                )
+              ),
+              greedy: true,
+              inside: {
+                interpolation: {
+                  pattern: RegExp(
+                    /((?:^|[^\\])(?:\\\\)*)\$\{(?:(?!\})(?:<expr>))*\}/.source.replace(
+                      /<expr>/g,
+                      function() {
+                        return FTL_EXPR;
+                      }
+                    )
+                  ),
+                  lookbehind: true,
+                  inside: {
+                    "interpolation-punctuation": {
+                      pattern: /^\$\{|\}$/,
+                      alias: "punctuation"
+                    },
+                    rest: null
+                  }
+                }
+              }
+            }
+          ],
+          keyword: /\b(?:as)\b/,
+          boolean: /\b(?:false|true)\b/,
+          "builtin-function": {
+            pattern: /((?:^|[^?])\?\s*)\w+/,
+            lookbehind: true,
+            alias: "function"
+          },
+          function: /\b\w+(?=\s*\()/,
+          number: /\b\d+(?:\.\d+)?\b/,
+          operator: /\.\.[<*!]?|->|--|\+\+|&&|\|\||\?{1,2}|[-+*/%!=<>]=?|\b(?:gt|gte|lt|lte)\b/,
+          punctuation: /[,;.:()[\]{}]/
+        };
+        ftl2.string[1].inside.interpolation.inside.rest = ftl2;
+        Prism2.languages.ftl = {
+          "ftl-comment": {
+            // the pattern is shortened to be more efficient
+            pattern: /^<#--[\s\S]*/,
+            alias: "comment"
+          },
+          "ftl-directive": {
+            pattern: /^<[\s\S]+>$/,
+            inside: {
+              directive: {
+                pattern: /(^<\/?)[#@][a-z]\w*/i,
+                lookbehind: true,
+                alias: "keyword"
+              },
+              punctuation: /^<\/?|\/?>$/,
+              content: {
+                pattern: /\s*\S[\s\S]*/,
+                alias: "ftl",
+                inside: ftl2
+              }
+            }
+          },
+          "ftl-interpolation": {
+            pattern: /^\$\{[\s\S]*\}$/,
+            inside: {
+              punctuation: /^\$\{|\}$/,
+              content: {
+                pattern: /\s*\S[\s\S]*/,
+                alias: "ftl",
+                inside: ftl2
+              }
+            }
+          }
+        };
+        Prism2.hooks.add("before-tokenize", function(env) {
+          var pattern = RegExp(
+            /<#--[\s\S]*?-->|<\/?[#@][a-zA-Z](?:<expr>)*?>|\$\{(?:<expr>)*?\}/.source.replace(
+              /<expr>/g,
+              function() {
+                return FTL_EXPR;
+              }
+            ),
+            "gi"
+          );
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "ftl",
+            pattern
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "ftl");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_ftl
+};

package/dist/chunk-ANN6ENLU.js

@@ -0,0 +1,95 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/c.js
+var require_c = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/c.js"(exports, module) {
+    module.exports = c;
+    c.displayName = "c";
+    c.aliases = [];
+    function c(Prism) {
+      Prism.languages.c = Prism.languages.extend("clike", {
+        comment: {
+          pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+          greedy: true
+        },
+        string: {
+          // https://en.cppreference.com/w/c/language/string_literal
+          pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+          lookbehind: true
+        },
+        keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+        operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
+      });
+      Prism.languages.insertBefore("c", "string", {
+        char: {
+          // https://en.cppreference.com/w/c/language/character_constant
+          pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+          greedy: true
+        }
+      });
+      Prism.languages.insertBefore("c", "string", {
+        macro: {
+          // allow for multiline macro definitions
+          // spaces after the # character compile fine with gcc
+          pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
+          lookbehind: true,
+          greedy: true,
+          alias: "property",
+          inside: {
+            string: [
+              {
+                // highlight the path of the include statement as a string
+                pattern: /^(#\s*include\s*)<[^>]+>/,
+                lookbehind: true
+              },
+              Prism.languages.c["string"]
+            ],
+            char: Prism.languages.c["char"],
+            comment: Prism.languages.c["comment"],
+            "macro-name": [
+              {
+                pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+                lookbehind: true
+              },
+              {
+                pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+                lookbehind: true,
+                alias: "function"
+              }
+            ],
+            // highlight macro directives as keywords
+            directive: {
+              pattern: /^(#\s*)[a-z]+/,
+              lookbehind: true,
+              alias: "keyword"
+            },
+            "directive-hash": /^#/,
+            punctuation: /##|\\(?=[\r\n])/,
+            expression: {
+              pattern: /\S[\s\S]*/,
+              inside: Prism.languages.c
+            }
+          }
+        }
+      });
+      Prism.languages.insertBefore("c", "function", {
+        // highlight predefined macros as constants
+        constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
+      });
+      delete Prism.languages.c["boolean"];
+    }
+  }
+});
+
+export {
+  require_c
+};

package/dist/chunk-AQ2A5SM2.js

@@ -0,0 +1,147 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/js-extras.js
+var require_js_extras = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/js-extras.js"(exports, module) {
+    module.exports = jsExtras;
+    jsExtras.displayName = "jsExtras";
+    jsExtras.aliases = [];
+    function jsExtras(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.insertBefore("javascript", "function-variable", {
+          "method-variable": {
+            pattern: RegExp(
+              "(\\.\\s*)" + Prism2.languages.javascript["function-variable"].pattern.source
+            ),
+            lookbehind: true,
+            alias: ["function-variable", "method", "function", "property-access"]
+          }
+        });
+        Prism2.languages.insertBefore("javascript", "function", {
+          method: {
+            pattern: RegExp(
+              "(\\.\\s*)" + Prism2.languages.javascript["function"].source
+            ),
+            lookbehind: true,
+            alias: ["function", "property-access"]
+          }
+        });
+        Prism2.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 withId(source, flags) {
+          return RegExp(
+            source.replace(/<ID>/g, function() {
+              return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+            }),
+            flags
+          );
+        }
+        Prism2.languages.insertBefore("javascript", "keyword", {
+          imports: {
+            // https://tc39.es/ecma262/#sec-imports
+            pattern: withId(
+              /(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source
+            ),
+            lookbehind: true,
+            inside: Prism2.languages.javascript
+          },
+          exports: {
+            // https://tc39.es/ecma262/#sec-exports
+            pattern: withId(
+              /(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source
+            ),
+            lookbehind: true,
+            inside: Prism2.languages.javascript
+          }
+        });
+        Prism2.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"
+          }
+        );
+        Prism2.languages.insertBefore("javascript", "operator", {
+          spread: {
+            pattern: /\.{3}/,
+            alias: "operator"
+          },
+          arrow: {
+            pattern: /=>/,
+            alias: "operator"
+          }
+        });
+        Prism2.languages.insertBefore("javascript", "punctuation", {
+          "property-access": {
+            pattern: withId(/(\.\s*)#?<ID>/.source),
+            lookbehind: true
+          },
+          "maybe-class-name": {
+            pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
+            lookbehind: true
+          },
+          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"
+          }
+        });
+        var maybeClassNameTokens = [
+          "function",
+          "function-variable",
+          "method",
+          "method-variable",
+          "property-access"
+        ];
+        for (var i = 0; i < maybeClassNameTokens.length; i++) {
+          var token = maybeClassNameTokens[i];
+          var value = Prism2.languages.javascript[token];
+          if (Prism2.util.type(value) === "RegExp") {
+            value = Prism2.languages.javascript[token] = {
+              pattern: value
+            };
+          }
+          var inside = value.inside || {};
+          value.inside = inside;
+          inside["maybe-class-name"] = /^[A-Z][\s\S]*/;
+        }
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_js_extras
+};

package/dist/chunk-AQ3MKUYO.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
+};

package/dist/chunk-AQJYYOAC.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  require_haskell
+} from "./chunk-UPOA7A7K.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
+};