@distri/react 0.3.3 → 0.3.4

package/dist/chunk-AH6RNPD4.js

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

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

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

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

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

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

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

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