@distri/react 0.3.0 → 0.3.1

package/dist/chunk-W3M6SKHX.js

@@ -1,84 +0,0 @@
-"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-WDVOU5L7.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-WS7EBKQB.js

@@ -1,46 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bro.js
-var require_bro = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bro.js"(exports, module) {
-    module.exports = bro;
-    bro.displayName = "bro";
-    bro.aliases = [];
-    function bro(Prism) {
-      Prism.languages.bro = {
-        comment: {
-          pattern: /(^|[^\\$])#.*/,
-          lookbehind: true,
-          inside: {
-            italic: /\b(?:FIXME|TODO|XXX)\b/
-          }
-        },
-        string: {
-          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-          greedy: true
-        },
-        boolean: /\b[TF]\b/,
-        function: {
-          pattern: /(\b(?:event|function|hook)[ \t]+)\w+(?:::\w+)?/,
-          lookbehind: true
-        },
-        builtin: /(?:@(?:load(?:-(?:plugin|sigs))?|unload|prefixes|ifn?def|else|(?:end)?if|DIR|FILENAME))|(?:&?(?:add_func|create_expire|default|delete_func|encrypt|error_handler|expire_func|group|log|mergeable|optional|persistent|priority|raw_output|read_expire|redef|rotate_interval|rotate_size|synchronized|type_column|write_expire))/,
-        constant: {
-          pattern: /(\bconst[ \t]+)\w+/i,
-          lookbehind: true
-        },
-        keyword: /\b(?:add|addr|alarm|any|bool|break|const|continue|count|delete|double|else|enum|event|export|file|for|function|global|hook|if|in|int|interval|local|module|next|of|opaque|pattern|port|print|record|return|schedule|set|string|subnet|table|time|timeout|using|vector|when)\b/,
-        operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
-        number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
-        punctuation: /[{}[\];(),.:]/
-      };
-    }
-  }
-});
-
-export {
-  require_bro
-};

package/dist/chunk-WWAUXGX2.js

@@ -1,196 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lisp.js
-var require_lisp = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lisp.js"(exports, module) {
-    module.exports = lisp;
-    lisp.displayName = "lisp";
-    lisp.aliases = [];
-    function lisp(Prism) {
-      ;
-      (function(Prism2) {
-        function simple_form(name) {
-          return RegExp(/(\()/.source + "(?:" + name + ")" + /(?=[\s\)])/.source);
-        }
-        function primitive(pattern) {
-          return RegExp(
-            /([\s([])/.source + "(?:" + pattern + ")" + /(?=[\s)])/.source
-          );
-        }
-        var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source;
-        var marker = "&" + symbol;
-        var par = "(\\()";
-        var endpar = "(?=\\))";
-        var space = "(?=\\s)";
-        var nestedPar = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source;
-        var language = {
-          // Three or four semicolons are considered a heading.
-          // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
-          heading: {
-            pattern: /;;;.*/,
-            alias: ["comment", "title"]
-          },
-          comment: /;.*/,
-          string: {
-            pattern: /"(?:[^"\\]|\\.)*"/,
-            greedy: true,
-            inside: {
-              argument: /[-A-Z]+(?=[.,\s])/,
-              symbol: RegExp("`" + symbol + "'")
-            }
-          },
-          "quoted-symbol": {
-            pattern: RegExp("#?'" + symbol),
-            alias: ["variable", "symbol"]
-          },
-          "lisp-property": {
-            pattern: RegExp(":" + symbol),
-            alias: "property"
-          },
-          splice: {
-            pattern: RegExp(",@?" + symbol),
-            alias: ["symbol", "variable"]
-          },
-          keyword: [
-            {
-              pattern: RegExp(
-                par + "(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)" + space
-              ),
-              lookbehind: true
-            },
-            {
-              pattern: RegExp(
-                par + "(?:append|by|collect|concat|do|finally|for|in|return)" + space
-              ),
-              lookbehind: true
-            }
-          ],
-          declare: {
-            pattern: simple_form(/declare/.source),
-            lookbehind: true,
-            alias: "keyword"
-          },
-          interactive: {
-            pattern: simple_form(/interactive/.source),
-            lookbehind: true,
-            alias: "keyword"
-          },
-          boolean: {
-            pattern: primitive(/nil|t/.source),
-            lookbehind: true
-          },
-          number: {
-            pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source),
-            lookbehind: true
-          },
-          defvar: {
-            pattern: RegExp(par + "def(?:const|custom|group|var)\\s+" + symbol),
-            lookbehind: true,
-            inside: {
-              keyword: /^def[a-z]+/,
-              variable: RegExp(symbol)
-            }
-          },
-          defun: {
-            pattern: RegExp(
-              par + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + symbol + /\s+\(/.source + nestedPar + /\)/.source
-            ),
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              keyword: /^(?:cl-)?def\S+/,
-              // See below, this property needs to be defined later so that it can
-              // reference the language object.
-              arguments: null,
-              function: {
-                pattern: RegExp("(^\\s)" + symbol),
-                lookbehind: true
-              },
-              punctuation: /[()]/
-            }
-          },
-          lambda: {
-            pattern: RegExp(
-              par + "lambda\\s+\\(\\s*(?:&?" + symbol + "(?:\\s+&?" + symbol + ")*\\s*)?\\)"
-            ),
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              keyword: /^lambda/,
-              // See below, this property needs to be defined later so that it can
-              // reference the language object.
-              arguments: null,
-              punctuation: /[()]/
-            }
-          },
-          car: {
-            pattern: RegExp(par + symbol),
-            lookbehind: true
-          },
-          punctuation: [
-            // open paren, brackets, and close paren
-            /(?:['`,]?\(|[)\[\]])/,
-            // cons
-            {
-              pattern: /(\s)\.(?=\s)/,
-              lookbehind: true
-            }
-          ]
-        };
-        var arg = {
-          "lisp-marker": RegExp(marker),
-          varform: {
-            pattern: RegExp(
-              /\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source
-            ),
-            inside: language
-          },
-          argument: {
-            pattern: RegExp(/(^|[\s(])/.source + symbol),
-            lookbehind: true,
-            alias: "variable"
-          },
-          rest: language
-        };
-        var forms = "\\S+(?:\\s+\\S+)*";
-        var arglist = {
-          pattern: RegExp(par + nestedPar + endpar),
-          lookbehind: true,
-          inside: {
-            "rest-vars": {
-              pattern: RegExp("&(?:body|rest)\\s+" + forms),
-              inside: arg
-            },
-            "other-marker-vars": {
-              pattern: RegExp("&(?:aux|optional)\\s+" + forms),
-              inside: arg
-            },
-            keys: {
-              pattern: RegExp("&key\\s+" + forms + "(?:\\s+&allow-other-keys)?"),
-              inside: arg
-            },
-            argument: {
-              pattern: RegExp(symbol),
-              alias: "variable"
-            },
-            punctuation: /[()]/
-          }
-        };
-        language["lambda"].inside.arguments = arglist;
-        language["defun"].inside.arguments = Prism2.util.clone(arglist);
-        language["defun"].inside.arguments.inside.sublist = arglist;
-        Prism2.languages.lisp = language;
-        Prism2.languages.elisp = language;
-        Prism2.languages.emacs = language;
-        Prism2.languages["emacs-lisp"] = language;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_lisp
-};

package/dist/chunk-X6QBUAE7.js

@@ -1,31 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mizar.js
-var require_mizar = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mizar.js"(exports, module) {
-    module.exports = mizar;
-    mizar.displayName = "mizar";
-    mizar.aliases = [];
-    function mizar(Prism) {
-      Prism.languages.mizar = {
-        comment: /::.+/,
-        keyword: /@proof\b|\b(?:according|aggregate|all|and|antonym|are|as|associativity|assume|asymmetry|attr|be|begin|being|by|canceled|case|cases|clusters?|coherence|commutativity|compatibility|connectedness|consider|consistency|constructors|contradiction|correctness|def|deffunc|define|definitions?|defpred|do|does|end|environ|equals|ex|exactly|existence|for|from|func|given|hence|hereby|holds|idempotence|identity|iff?|implies|involutiveness|irreflexivity|is|it|let|means|mode|non|not|notations?|now|of|or|otherwise|over|per|pred|prefix|projectivity|proof|provided|qua|reconsider|redefine|reduce|reducibility|reflexivity|registrations?|requirements|reserve|sch|schemes?|section|selector|set|sethood|st|struct|such|suppose|symmetry|synonym|take|that|the|then|theorems?|thesis|thus|to|transitivity|uniqueness|vocabular(?:ies|y)|when|where|with|wrt)\b/,
-        parameter: {
-          pattern: /\$(?:10|\d)/,
-          alias: "variable"
-        },
-        variable: /\b\w+(?=:)/,
-        number: /(?:\b|-)\d+\b/,
-        operator: /\.\.\.|->|&|\.?=/,
-        punctuation: /\(#|#\)|[,:;\[\](){}]/
-      };
-    }
-  }
-});
-
-export {
-  require_mizar
-};

package/dist/chunk-XA3YT5Q2.js

@@ -1,150 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javascript.js
-var require_javascript = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javascript.js"(exports, module) {
-    module.exports = javascript;
-    javascript.displayName = "javascript";
-    javascript.aliases = ["js"];
-    function javascript(Prism) {
-      Prism.languages.javascript = Prism.languages.extend("clike", {
-        "class-name": [
-          Prism.languages.clike["class-name"],
-          {
-            pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-            lookbehind: true
-          }
-        ],
-        keyword: [
-          {
-            pattern: /((?:^|\})\s*)catch\b/,
-            lookbehind: true
-          },
-          {
-            pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
-            lookbehind: true
-          }
-        ],
-        // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-        function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
-        number: {
-          pattern: RegExp(
-            /(^|[^\w$])/.source + "(?:" + // constant
-            (/NaN|Infinity/.source + "|" + // binary integer
-            /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
-            /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
-            /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
-            /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
-            /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
-          ),
-          lookbehind: true
-        },
-        operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-      });
-      Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
-      Prism.languages.insertBefore("javascript", "keyword", {
-        regex: {
-          // eslint-disable-next-line regexp/no-dupe-characters-character-class
-          pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
-          lookbehind: true,
-          greedy: true,
-          inside: {
-            "regex-source": {
-              pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-              lookbehind: true,
-              alias: "language-regex",
-              inside: Prism.languages.regex
-            },
-            "regex-delimiter": /^\/|\/$/,
-            "regex-flags": /^[a-z]+$/
-          }
-        },
-        // This must be declared before keyword because we use "function" inside the look-forward
-        "function-variable": {
-          pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
-          alias: "function"
-        },
-        parameter: [
-          {
-            pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
-            lookbehind: true,
-            inside: Prism.languages.javascript
-          },
-          {
-            pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-            lookbehind: true,
-            inside: Prism.languages.javascript
-          },
-          {
-            pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-            lookbehind: true,
-            inside: Prism.languages.javascript
-          },
-          {
-            pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
-            lookbehind: true,
-            inside: Prism.languages.javascript
-          }
-        ],
-        constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-      });
-      Prism.languages.insertBefore("javascript", "string", {
-        hashbang: {
-          pattern: /^#!.*/,
-          greedy: true,
-          alias: "comment"
-        },
-        "template-string": {
-          pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
-          greedy: true,
-          inside: {
-            "template-punctuation": {
-              pattern: /^`|`$/,
-              alias: "string"
-            },
-            interpolation: {
-              pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-              lookbehind: true,
-              inside: {
-                "interpolation-punctuation": {
-                  pattern: /^\$\{|\}$/,
-                  alias: "punctuation"
-                },
-                rest: Prism.languages.javascript
-              }
-            },
-            string: /[\s\S]+/
-          }
-        },
-        "string-property": {
-          pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-          lookbehind: true,
-          greedy: true,
-          alias: "property"
-        }
-      });
-      Prism.languages.insertBefore("javascript", "operator", {
-        "literal-property": {
-          pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-          lookbehind: true,
-          alias: "property"
-        }
-      });
-      if (Prism.languages.markup) {
-        Prism.languages.markup.tag.addInlined("script", "javascript");
-        Prism.languages.markup.tag.addAttribute(
-          /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
-          "javascript"
-        );
-      }
-      Prism.languages.js = Prism.languages.javascript;
-    }
-  }
-});
-
-export {
-  require_javascript
-};

package/dist/chunk-XBB3NKEU.js

@@ -1,47 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wolfram.js
-var require_wolfram = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wolfram.js"(exports, module) {
-    module.exports = wolfram;
-    wolfram.displayName = "wolfram";
-    wolfram.aliases = ["mathematica", "wl", "nb"];
-    function wolfram(Prism) {
-      Prism.languages.wolfram = {
-        // Allow one level of nesting - note: regex taken from applescipt
-        comment: /\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
-        string: {
-          pattern: /"(?:\\.|[^"\\\r\n])*"/,
-          greedy: true
-        },
-        keyword: /\b(?:Abs|AbsArg|Accuracy|Block|Do|For|Function|If|Manipulate|Module|Nest|NestList|None|Return|Switch|Table|Which|While)\b/,
-        context: {
-          pattern: /\b\w+`+\w*/,
-          alias: "class-name"
-        },
-        blank: {
-          pattern: /\b\w+_\b/,
-          alias: "regex"
-        },
-        "global-variable": {
-          pattern: /\$\w+/,
-          alias: "variable"
-        },
-        boolean: /\b(?:False|True)\b/,
-        number: /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?j?\b/i,
-        operator: /\/\.|;|=\.|\^=|\^:=|:=|<<|>>|<\||\|>|:>|\|->|->|<-|@@@|@@|@|\/@|=!=|===|==|=|\+|-|\^|\[\/-+%=\]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-        punctuation: /[{}[\];(),.:]/
-      };
-      Prism.languages.mathematica = Prism.languages.wolfram;
-      Prism.languages.wl = Prism.languages.wolfram;
-      Prism.languages.nb = Prism.languages.wolfram;
-    }
-  }
-});
-
-export {
-  require_wolfram
-};