@distri/react 0.2.5 → 0.2.8

package/dist/chunk-W3M6SKHX.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-WDVOU5L7.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-WS7EBKQB.js

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

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

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

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

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