@distri/react 0.3.1 → 0.3.3

package/dist/chunk-UPOA7A7K.js

@@ -0,0 +1,84 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/haskell.js
+var require_haskell = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/haskell.js"(exports, module) {
+    module.exports = haskell;
+    haskell.displayName = "haskell";
+    haskell.aliases = ["hs"];
+    function haskell(Prism) {
+      Prism.languages.haskell = {
+        comment: {
+          pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
+          lookbehind: true
+        },
+        char: {
+          pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
+          alias: "string"
+        },
+        string: {
+          pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
+          greedy: true
+        },
+        keyword: /\b(?:case|class|data|deriving|do|else|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+(?:qualified\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|qualified)\b/,
+            punctuation: /\./
+          }
+        },
+        // These are builtin variables only. Constructors are highlighted later as a constant.
+        builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
+        // decimal integers and floating point numbers | octal integers | hexadecimal integers
+        number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
+        operator: [
+          {
+            // infix operator
+            pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
+            greedy: true
+          },
+          {
+            // function composition
+            pattern: /(\s)\.(?=\s)/,
+            lookbehind: true
+          },
+          // Most of this is needed because of the meaning of a single '.'.
+          // If it stands alone freely, it is the function composition.
+          // It may also be a separator between a module name and an identifier => no
+          // operator. If it comes together with other special characters it is an
+          // operator too.
+          //
+          // This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
+          /[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
+        ],
+        // In Haskell, nearly everything is a variable, do not highlight these.
+        hvariable: {
+          pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        constant: {
+          pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        punctuation: /[{}[\];(),.:]/
+      };
+      Prism.languages.hs = Prism.languages.haskell;
+    }
+  }
+});
+
+export {
+  require_haskell
+};

package/dist/chunk-UR3RVG2E.js

@@ -0,0 +1,47 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/j.js
+var require_j = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/j.js"(exports, module) {
+    module.exports = j;
+    j.displayName = "j";
+    j.aliases = [];
+    function j(Prism) {
+      Prism.languages.j = {
+        comment: {
+          pattern: /\bNB\..*/,
+          greedy: true
+        },
+        string: {
+          pattern: /'(?:''|[^'\r\n])*'/,
+          greedy: true
+        },
+        keyword: /\b(?:(?:CR|LF|adverb|conjunction|def|define|dyad|monad|noun|verb)\b|(?:assert|break|case|catch[dt]?|continue|do|else|elseif|end|fcase|for|for_\w+|goto_\w+|if|label_\w+|return|select|throw|try|while|whilst)\.)/,
+        verb: {
+          // Negative look-ahead prevents bad highlighting
+          // of ^: ;. =. =: !. !:
+          pattern: /(?!\^:|;\.|[=!][.:])(?:\{(?:\.|::?)?|p(?:\.\.?|:)|[=!\]]|[<>+*\-%$|,#][.:]?|[?^]\.?|[;\[]:?|[~}"i][.:]|[ACeEIjLor]\.|(?:[_\/\\qsux]|_?\d):)/,
+          alias: "keyword"
+        },
+        number: /\b_?(?:(?!\d:)\d+(?:\.\d+)?(?:(?:ad|ar|[ejpx])_?\d+(?:\.\d+)?)*(?:b_?[\da-z]+(?:\.[\da-z]+)?)?|_\b(?!\.))/,
+        adverb: {
+          pattern: /[~}]|[\/\\]\.?|[bfM]\.|t[.:]/,
+          alias: "builtin"
+        },
+        operator: /[=a][.:]|_\./,
+        conjunction: {
+          pattern: /&(?:\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\.|`:?|[\^LS]:|"/,
+          alias: "variable"
+        },
+        punctuation: /[()]/
+      };
+    }
+  }
+});
+
+export {
+  require_j
+};

package/dist/chunk-UXDI4352.js

@@ -0,0 +1,238 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bash.js
+var require_bash = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bash.js"(exports, module) {
+    module.exports = bash;
+    bash.displayName = "bash";
+    bash.aliases = ["shell"];
+    function bash(Prism) {
+      ;
+      (function(Prism2) {
+        var envVars = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b";
+        var commandAfterHeredoc = {
+          pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+          lookbehind: true,
+          alias: "punctuation",
+          // this looks reasonably well in all themes
+          inside: null
+          // see below
+        };
+        var insideString = {
+          bash: commandAfterHeredoc,
+          environment: {
+            pattern: RegExp("\\$" + envVars),
+            alias: "constant"
+          },
+          variable: [
+            // [0]: Arithmetic Environment
+            {
+              pattern: /\$?\(\([\s\S]+?\)\)/,
+              greedy: true,
+              inside: {
+                // If there is a $ sign at the beginning highlight $(( and )) as variable
+                variable: [
+                  {
+                    pattern: /(^\$\(\([\s\S]+)\)\)/,
+                    lookbehind: true
+                  },
+                  /^\$\(\(/
+                ],
+                number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+                // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+                operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+                // If there is no $ sign at the beginning highlight (( and )) as punctuation
+                punctuation: /\(\(?|\)\)?|,|;/
+              }
+            },
+            // [1]: Command Substitution
+            {
+              pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+              greedy: true,
+              inside: {
+                variable: /^\$\(|^`|\)$|`$/
+              }
+            },
+            // [2]: Brace expansion
+            {
+              pattern: /\$\{[^}]+\}/,
+              greedy: true,
+              inside: {
+                operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+                punctuation: /[\[\]]/,
+                environment: {
+                  pattern: RegExp("(\\{)" + envVars),
+                  lookbehind: true,
+                  alias: "constant"
+                }
+              }
+            },
+            /\$(?:\w+|[#?*!@$])/
+          ],
+          // Escape sequences from echo and printf's manuals, and escaped quotes.
+          entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+        };
+        Prism2.languages.bash = {
+          shebang: {
+            pattern: /^#!\s*\/.*/,
+            alias: "important"
+          },
+          comment: {
+            pattern: /(^|[^"{\\$])#.*/,
+            lookbehind: true
+          },
+          "function-name": [
+            // a) function foo {
+            // b) foo() {
+            // c) function foo() {
+            // but not “foo {”
+            {
+              // a) and c)
+              pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+              lookbehind: true,
+              alias: "function"
+            },
+            {
+              // b)
+              pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+              alias: "function"
+            }
+          ],
+          // Highlight variable names as variables in for and select beginnings.
+          "for-or-select": {
+            pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+            alias: "variable",
+            lookbehind: true
+          },
+          // Highlight variable names as variables in the left-hand part
+          // of assignments (“=” and “+=”).
+          "assign-left": {
+            pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
+            inside: {
+              environment: {
+                pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + envVars),
+                lookbehind: true,
+                alias: "constant"
+              }
+            },
+            alias: "variable",
+            lookbehind: true
+          },
+          string: [
+            // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+            {
+              pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+              lookbehind: true,
+              greedy: true,
+              inside: insideString
+            },
+            // Here-document with quotes around the tag
+            // → No expansion (so no “inside”).
+            {
+              pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+              lookbehind: true,
+              greedy: true,
+              inside: {
+                bash: commandAfterHeredoc
+              }
+            },
+            // “Normal” string
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+              pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+              lookbehind: true,
+              greedy: true,
+              inside: insideString
+            },
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+              pattern: /(^|[^$\\])'[^']*'/,
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+              pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+              greedy: true,
+              inside: {
+                entity: insideString.entity
+              }
+            }
+          ],
+          environment: {
+            pattern: RegExp("\\$?" + envVars),
+            alias: "constant"
+          },
+          variable: insideString.variable,
+          function: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+            lookbehind: true
+          },
+          keyword: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+            lookbehind: true
+          },
+          // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+          builtin: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+            lookbehind: true,
+            // Alias added to make those easier to distinguish from strings.
+            alias: "class-name"
+          },
+          boolean: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+            lookbehind: true
+          },
+          "file-descriptor": {
+            pattern: /\B&\d\b/,
+            alias: "important"
+          },
+          operator: {
+            // Lots of redirections here, but not just that.
+            pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+            inside: {
+              "file-descriptor": {
+                pattern: /^\d/,
+                alias: "important"
+              }
+            }
+          },
+          punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+          number: {
+            pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+            lookbehind: true
+          }
+        };
+        commandAfterHeredoc.inside = Prism2.languages.bash;
+        var toBeCopied = [
+          "comment",
+          "function-name",
+          "for-or-select",
+          "assign-left",
+          "string",
+          "environment",
+          "function",
+          "keyword",
+          "builtin",
+          "boolean",
+          "file-descriptor",
+          "operator",
+          "punctuation",
+          "number"
+        ];
+        var inside = insideString.variable[1].inside;
+        for (var i = 0; i < toBeCopied.length; i++) {
+          inside[toBeCopied[i]] = Prism2.languages.bash[toBeCopied[i]];
+        }
+        Prism2.languages.shell = Prism2.languages.bash;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_bash
+};

package/dist/chunk-UYAK2IKF.js

@@ -0,0 +1,94 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/parser.js
+var require_parser = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/parser.js"(exports, module) {
+    module.exports = parser;
+    parser.displayName = "parser";
+    parser.aliases = [];
+    function parser(Prism) {
+      ;
+      (function(Prism2) {
+        var parser2 = Prism2.languages.parser = Prism2.languages.extend("markup", {
+          keyword: {
+            pattern: /(^|[^^])(?:\^(?:case|eval|for|if|switch|throw)\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\b)/,
+            lookbehind: true
+          },
+          variable: {
+            pattern: /(^|[^^])\B\$(?:\w+|(?=[.{]))(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+            lookbehind: true,
+            inside: {
+              punctuation: /\.|:+/
+            }
+          },
+          function: {
+            pattern: /(^|[^^])\B[@^]\w+(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+            lookbehind: true,
+            inside: {
+              keyword: {
+                pattern: /(^@)(?:GET_|SET_)/,
+                lookbehind: true
+              },
+              punctuation: /\.|:+/
+            }
+          },
+          escape: {
+            pattern: /\^(?:[$^;@()\[\]{}"':]|#[a-f\d]*)/i,
+            alias: "builtin"
+          },
+          punctuation: /[\[\](){};]/
+        });
+        parser2 = Prism2.languages.insertBefore("parser", "keyword", {
+          "parser-comment": {
+            pattern: /(\s)#.*/,
+            lookbehind: true,
+            alias: "comment"
+          },
+          expression: {
+            // Allow for 3 levels of depth
+            pattern: /(^|[^^])\((?:[^()]|\((?:[^()]|\((?:[^()])*\))*\))*\)/,
+            greedy: true,
+            lookbehind: true,
+            inside: {
+              string: {
+                pattern: /(^|[^^])(["'])(?:(?!\2)[^^]|\^[\s\S])*\2/,
+                lookbehind: true
+              },
+              keyword: parser2.keyword,
+              variable: parser2.variable,
+              function: parser2.function,
+              boolean: /\b(?:false|true)\b/,
+              number: /\b(?:0x[a-f\d]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?)\b/i,
+              escape: parser2.escape,
+              operator: /[~+*\/\\%]|!(?:\|\|?|=)?|&&?|\|\|?|==|<[<=]?|>[>=]?|-[fd]?|\b(?:def|eq|ge|gt|in|is|le|lt|ne)\b/,
+              punctuation: parser2.punctuation
+            }
+          }
+        });
+        Prism2.languages.insertBefore(
+          "inside",
+          "punctuation",
+          {
+            expression: parser2.expression,
+            keyword: parser2.keyword,
+            variable: parser2.variable,
+            function: parser2.function,
+            escape: parser2.escape,
+            "parser-punctuation": {
+              pattern: parser2.punctuation,
+              alias: "punctuation"
+            }
+          },
+          parser2["tag"].inside["attr-value"]
+        );
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_parser
+};

package/dist/chunk-V6AWCJO5.js

@@ -0,0 +1,97 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/v.js
+var require_v = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/v.js"(exports, module) {
+    module.exports = v;
+    v.displayName = "v";
+    v.aliases = [];
+    function v(Prism) {
+      ;
+      (function(Prism2) {
+        var interpolationExpr = {
+          pattern: /[\s\S]+/,
+          inside: null
+        };
+        Prism2.languages.v = Prism2.languages.extend("clike", {
+          string: {
+            pattern: /r?(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+            alias: "quoted-string",
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[^{}]*\}|\w+(?:\.\w+(?:\([^\(\)]*\))?|\[[^\[\]]+\])*)/,
+                lookbehind: true,
+                inside: {
+                  "interpolation-variable": {
+                    pattern: /^\$\w[\s\S]*$/,
+                    alias: "variable"
+                  },
+                  "interpolation-punctuation": {
+                    pattern: /^\$\{|\}$/,
+                    alias: "punctuation"
+                  },
+                  "interpolation-expression": interpolationExpr
+                }
+              }
+            }
+          },
+          "class-name": {
+            pattern: /(\b(?:enum|interface|struct|type)\s+)(?:C\.)?\w+/,
+            lookbehind: true
+          },
+          keyword: /(?:\b(?:__global|as|asm|assert|atomic|break|chan|const|continue|defer|else|embed|enum|fn|for|go(?:to)?|if|import|in|interface|is|lock|match|module|mut|none|or|pub|return|rlock|select|shared|sizeof|static|struct|type(?:of)?|union|unsafe)|\$(?:else|for|if)|#(?:flag|include))\b/,
+          number: /\b(?:0x[a-f\d]+(?:_[a-f\d]+)*|0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?)\b/i,
+          operator: /~|\?|[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\.?/,
+          builtin: /\b(?:any(?:_float|_int)?|bool|byte(?:ptr)?|charptr|f(?:32|64)|i(?:8|16|64|128|nt)|rune|size_t|string|u(?:16|32|64|128)|voidptr)\b/
+        });
+        interpolationExpr.inside = Prism2.languages.v;
+        Prism2.languages.insertBefore("v", "string", {
+          char: {
+            pattern: /`(?:\\`|\\?[^`]{1,2})`/,
+            // using {1,2} instead of `u` flag for compatibility
+            alias: "rune"
+          }
+        });
+        Prism2.languages.insertBefore("v", "operator", {
+          attribute: {
+            pattern: /(^[\t ]*)\[(?:deprecated|direct_array_access|flag|inline|live|ref_only|typedef|unsafe_fn|windows_stdcall)\]/m,
+            lookbehind: true,
+            alias: "annotation",
+            inside: {
+              punctuation: /[\[\]]/,
+              keyword: /\w+/
+            }
+          },
+          generic: {
+            pattern: /<\w+>(?=\s*[\)\{])/,
+            inside: {
+              punctuation: /[<>]/,
+              "class-name": /\w+/
+            }
+          }
+        });
+        Prism2.languages.insertBefore("v", "function", {
+          "generic-function": {
+            // e.g. foo<T>( ...
+            pattern: /\b\w+\s*<\w+>(?=\()/,
+            inside: {
+              function: /^\w+/,
+              generic: {
+                pattern: /<\w+>/,
+                inside: Prism2.languages.v.generic.inside
+              }
+            }
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_v
+};

package/dist/chunk-VDMFDRVD.js

@@ -0,0 +1,67 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lolcode.js
+var require_lolcode = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lolcode.js"(exports, module) {
+    module.exports = lolcode;
+    lolcode.displayName = "lolcode";
+    lolcode.aliases = [];
+    function lolcode(Prism) {
+      Prism.languages.lolcode = {
+        comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
+        string: {
+          pattern: /"(?::.|[^":])*"/,
+          inside: {
+            variable: /:\{[^}]+\}/,
+            symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/]
+          },
+          greedy: true
+        },
+        number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/,
+        symbol: {
+          pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/,
+          lookbehind: true,
+          inside: {
+            keyword: /A(?=\s)/
+          }
+        },
+        label: {
+          pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
+          lookbehind: true,
+          alias: "string"
+        },
+        function: {
+          pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/,
+          lookbehind: true
+        },
+        keyword: [
+          {
+            pattern: /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/,
+            lookbehind: true
+          },
+          /'Z(?=\s|,|$)/
+        ],
+        boolean: {
+          pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/,
+          lookbehind: true
+        },
+        variable: {
+          pattern: /(^|\s)IT(?=\s|,|$)/,
+          lookbehind: true
+        },
+        operator: {
+          pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/,
+          lookbehind: true
+        },
+        punctuation: /\.{3}|…|,|!/
+      };
+    }
+  }
+});
+
+export {
+  require_lolcode
+};