@distri/react 0.3.1 → 0.3.3

package/dist/chunk-JEUPR533.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-JX27E7Z7.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nand2tetris-hdl.js
+var require_nand2tetris_hdl = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nand2tetris-hdl.js"(exports, module) {
+    module.exports = nand2tetrisHdl;
+    nand2tetrisHdl.displayName = "nand2tetrisHdl";
+    nand2tetrisHdl.aliases = [];
+    function nand2tetrisHdl(Prism) {
+      Prism.languages["nand2tetris-hdl"] = {
+        comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+        keyword: /\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\b/,
+        boolean: /\b(?:false|true)\b/,
+        function: /\b[A-Za-z][A-Za-z0-9]*(?=\()/,
+        number: /\b\d+\b/,
+        operator: /=|\.\./,
+        punctuation: /[{}[\];(),:]/
+      };
+    }
+  }
+});
+
+export {
+  require_nand2tetris_hdl
+};

package/dist/chunk-JZBGRMXH.js

@@ -0,0 +1,137 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/livescript.js
+var require_livescript = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/livescript.js"(exports, module) {
+    module.exports = livescript;
+    livescript.displayName = "livescript";
+    livescript.aliases = [];
+    function livescript(Prism) {
+      Prism.languages.livescript = {
+        comment: [
+          {
+            pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+            lookbehind: true
+          },
+          {
+            pattern: /(^|[^\\])#.*/,
+            lookbehind: true
+          }
+        ],
+        "interpolated-string": {
+          /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern
+           * forcing it to match """-quoted string when it would otherwise match "-quoted first. */
+          pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            variable: {
+              pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m,
+              lookbehind: true
+            },
+            interpolation: {
+              pattern: /(^|[^\\])#\{[^}]+\}/m,
+              lookbehind: true,
+              inside: {
+                "interpolation-punctuation": {
+                  pattern: /^#\{|\}$/,
+                  alias: "variable"
+                }
+                // See rest below
+              }
+            },
+            string: /[\s\S]+/
+          }
+        },
+        string: [
+          {
+            pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+            greedy: true
+          },
+          {
+            pattern: /<\[[\s\S]*?\]>/,
+            greedy: true
+          },
+          /\\[^\s,;\])}]+/
+        ],
+        regex: [
+          {
+            pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,
+            greedy: true,
+            inside: {
+              comment: {
+                pattern: /(^|[^\\])#.*/,
+                lookbehind: true
+              }
+            }
+          },
+          {
+            pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,
+            greedy: true
+          }
+        ],
+        keyword: {
+          pattern: /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m,
+          lookbehind: true
+        },
+        "keyword-operator": {
+          pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
+          lookbehind: true,
+          alias: "operator"
+        },
+        boolean: {
+          pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m,
+          lookbehind: true
+        },
+        argument: {
+          // Don't match .&. nor &&
+          pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m,
+          lookbehind: true,
+          alias: "variable"
+        },
+        number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i,
+        identifier: /[a-z_](?:-?[a-z]|[\d_])*/i,
+        operator: [
+          // Spaced .
+          {
+            pattern: /( )\.(?= )/,
+            lookbehind: true
+          },
+          // Full list, in order:
+          // .= .~ .. ...
+          // .&. .^. .<<. .>>. .>>>.
+          // := :: ::=
+          // &&
+          // || |>
+          // < << <<< <<<<
+          // <- <-- <-! <--!
+          // <~ <~~ <~! <~~!
+          // <| <= <?
+          // > >> >= >?
+          // - -- -> -->
+          // + ++
+          // @ @@
+          // % %%
+          // * **
+          // ! != !~=
+          // !~> !~~>
+          // !-> !-->
+          // ~ ~> ~~> ~=
+          // = ==
+          // ^ ^^
+          // / ?
+          /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/
+        ],
+        punctuation: /[(){}\[\]|.,:;`]/
+      };
+      Prism.languages.livescript["interpolated-string"].inside["interpolation"].inside.rest = Prism.languages.livescript;
+    }
+  }
+});
+
+export {
+  require_livescript
+};

package/dist/chunk-K7N3TO3V.js

@@ -0,0 +1,57 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/smalltalk.js
+var require_smalltalk = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/smalltalk.js"(exports, module) {
+    module.exports = smalltalk;
+    smalltalk.displayName = "smalltalk";
+    smalltalk.aliases = [];
+    function smalltalk(Prism) {
+      Prism.languages.smalltalk = {
+        comment: {
+          pattern: /"(?:""|[^"])*"/,
+          greedy: true
+        },
+        char: {
+          pattern: /\$./,
+          greedy: true
+        },
+        string: {
+          pattern: /'(?:''|[^'])*'/,
+          greedy: true
+        },
+        symbol: /#[\da-z]+|#(?:-|([+\/\\*~<>=@%|&?!])\1?)|#(?=\()/i,
+        "block-arguments": {
+          pattern: /(\[\s*):[^\[|]*\|/,
+          lookbehind: true,
+          inside: {
+            variable: /:[\da-z]+/i,
+            punctuation: /\|/
+          }
+        },
+        "temporary-variables": {
+          pattern: /\|[^|]+\|/,
+          inside: {
+            variable: /[\da-z]+/i,
+            punctuation: /\|/
+          }
+        },
+        keyword: /\b(?:new|nil|self|super)\b/,
+        boolean: /\b(?:false|true)\b/,
+        number: [
+          /\d+r-?[\dA-Z]+(?:\.[\dA-Z]+)?(?:e-?\d+)?/,
+          /\b\d+(?:\.\d+)?(?:e-?\d+)?/
+        ],
+        operator: /[<=]=?|:=|~[~=]|\/\/?|\\\\|>[>=]?|[!^+\-*&|,@]/,
+        punctuation: /[.;:?\[\](){}]/
+      };
+    }
+  }
+});
+
+export {
+  require_smalltalk
+};

package/dist/chunk-KDLA7HDC.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-KEWYGECE.js

@@ -0,0 +1,82 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/python.js
+var require_python = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/python.js"(exports, module) {
+    module.exports = python;
+    python.displayName = "python";
+    python.aliases = ["py"];
+    function python(Prism) {
+      Prism.languages.python = {
+        comment: {
+          pattern: /(^|[^\\])#.*/,
+          lookbehind: true,
+          greedy: true
+        },
+        "string-interpolation": {
+          pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+          greedy: true,
+          inside: {
+            interpolation: {
+              // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+              pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+              lookbehind: true,
+              inside: {
+                "format-spec": {
+                  pattern: /(:)[^:(){}]+(?=\}$)/,
+                  lookbehind: true
+                },
+                "conversion-option": {
+                  pattern: /![sra](?=[:}]$)/,
+                  alias: "punctuation"
+                },
+                rest: null
+              }
+            },
+            string: /[\s\S]+/
+          }
+        },
+        "triple-quoted-string": {
+          pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+          greedy: true,
+          alias: "string"
+        },
+        string: {
+          pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+          greedy: true
+        },
+        function: {
+          pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+          lookbehind: true
+        },
+        "class-name": {
+          pattern: /(\bclass\s+)\w+/i,
+          lookbehind: true
+        },
+        decorator: {
+          pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+          lookbehind: true,
+          alias: ["annotation", "punctuation"],
+          inside: {
+            punctuation: /\./
+          }
+        },
+        keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+        builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+        boolean: /\b(?:False|None|True)\b/,
+        number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+        operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+        punctuation: /[{}[\];(),.:]/
+      };
+      Prism.languages.python["string-interpolation"].inside["interpolation"].inside.rest = Prism.languages.python;
+      Prism.languages.py = Prism.languages.python;
+    }
+  }
+});
+
+export {
+  require_python
+};

package/dist/chunk-KFN445LW.js

@@ -0,0 +1,67 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/uorazor.js
+var require_uorazor = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/uorazor.js"(exports, module) {
+    module.exports = uorazor;
+    uorazor.displayName = "uorazor";
+    uorazor.aliases = [];
+    function uorazor(Prism) {
+      Prism.languages.uorazor = {
+        "comment-hash": {
+          pattern: /#.*/,
+          alias: "comment",
+          greedy: true
+        },
+        "comment-slash": {
+          pattern: /\/\/.*/,
+          alias: "comment",
+          greedy: true
+        },
+        string: {
+          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          inside: {
+            punctuation: /^['"]|['"]$/
+          },
+          greedy: true
+        },
+        "source-layers": {
+          pattern: /\b(?:arms|backpack|blue|bracelet|cancel|clear|cloak|criminal|earrings|enemy|facialhair|friend|friendly|gloves|gray|grey|ground|hair|head|innerlegs|innertorso|innocent|lefthand|middletorso|murderer|neck|nonfriendly|onehandedsecondary|outerlegs|outertorso|pants|red|righthand|ring|self|shirt|shoes|talisman|waist)\b/i,
+          alias: "function"
+        },
+        "source-commands": {
+          pattern: /\b(?:alliance|attack|cast|clearall|clearignore|clearjournal|clearlist|clearsysmsg|createlist|createtimer|dclick|dclicktype|dclickvar|dress|dressconfig|drop|droprelloc|emote|getlabel|guild|gumpclose|gumpresponse|hotkey|ignore|lasttarget|lift|lifttype|menu|menuresponse|msg|org|organize|organizer|overhead|pause|poplist|potion|promptresponse|pushlist|removelist|removetimer|rename|restock|say|scav|scavenger|script|setability|setlasttarget|setskill|settimer|setvar|sysmsg|target|targetloc|targetrelloc|targettype|undress|unignore|unsetvar|useobject|useonce|useskill|usetype|virtue|wait|waitforgump|waitformenu|waitforprompt|waitforstat|waitforsysmsg|waitfortarget|walk|wfsysmsg|wft|whisper|yell)\b/,
+          alias: "function"
+        },
+        "tag-name": {
+          pattern: /(^\{%-?\s*)\w+/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        delimiter: {
+          pattern: /^\{[{%]-?|-?[%}]\}$/,
+          alias: "punctuation"
+        },
+        function: /\b(?:atlist|close|closest|count|counter|counttype|dead|dex|diffhits|diffmana|diffstam|diffweight|find|findbuff|finddebuff|findlayer|findtype|findtypelist|followers|gumpexists|hidden|hits|hp|hue|human|humanoid|ingump|inlist|insysmessage|insysmsg|int|invul|lhandempty|list|listexists|mana|maxhits|maxhp|maxmana|maxstam|maxweight|monster|mounted|name|next|noto|paralyzed|poisoned|position|prev|previous|queued|rand|random|rhandempty|skill|stam|str|targetexists|timer|timerexists|varexist|warmode|weight)\b/,
+        keyword: /\b(?:and|as|break|continue|else|elseif|endfor|endif|endwhile|for|if|loop|not|or|replay|stop|while)\b/,
+        boolean: /\b(?:false|null|true)\b/,
+        number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+        operator: [
+          {
+            pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
+            lookbehind: true
+          },
+          /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/
+        ],
+        punctuation: /[()\[\]{}:.,]/
+      };
+    }
+  }
+});
+
+export {
+  require_uorazor
+};

package/dist/chunk-KKSPKZZM.js

@@ -0,0 +1,82 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/excel-formula.js
+var require_excel_formula = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/excel-formula.js"(exports, module) {
+    module.exports = excelFormula;
+    excelFormula.displayName = "excelFormula";
+    excelFormula.aliases = [];
+    function excelFormula(Prism) {
+      Prism.languages["excel-formula"] = {
+        comment: {
+          pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
+          lookbehind: true,
+          greedy: true
+        },
+        string: {
+          pattern: /"(?:[^"]|"")*"(?!")/,
+          greedy: true
+        },
+        reference: {
+          // https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/
+          // Sales!B2
+          // 'Winter sales'!B2
+          // [Sales.xlsx]Jan!B2:B5
+          // D:\Reports\[Sales.xlsx]Jan!B2:B5
+          // '[Sales.xlsx]Jan sales'!B2:B5
+          // 'D:\Reports\[Sales.xlsx]Jan sales'!B2:B5
+          pattern: /(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,
+          greedy: true,
+          alias: "string",
+          inside: {
+            operator: /!$/,
+            punctuation: /'/,
+            sheet: {
+              pattern: /[^[\]]+$/,
+              alias: "function"
+            },
+            file: {
+              pattern: /\[[^[\]]+\]$/,
+              inside: {
+                punctuation: /[[\]]/
+              }
+            },
+            path: /[\s\S]+/
+          }
+        },
+        "function-name": {
+          pattern: /\b[A-Z]\w*(?=\()/i,
+          alias: "keyword"
+        },
+        range: {
+          pattern: /\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,
+          alias: "property",
+          inside: {
+            operator: /:/,
+            cell: /\$?[A-Z]+\$?\d+/i,
+            column: /\$?[A-Z]+/i,
+            row: /\$?\d+/
+          }
+        },
+        cell: {
+          // Excel is case insensitive, so the string "foo1" could be either a variable or a cell.
+          // To combat this, we match cells case insensitive, if the contain at least one "$", and case sensitive otherwise.
+          pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,
+          alias: "property"
+        },
+        number: /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,
+        boolean: /\b(?:FALSE|TRUE)\b/i,
+        operator: /[-+*/^%=&,]|<[=>]?|>=?/,
+        punctuation: /[[\]();{}|]/
+      };
+      Prism.languages["xlsx"] = Prism.languages["xls"] = Prism.languages["excel-formula"];
+    }
+  }
+});
+
+export {
+  require_excel_formula
+};