@distri/react 0.2.8 → 0.3.1

package/dist/chunk-75PP7PI6.js

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

package/dist/chunk-76OIATWI.js

@@ -1,82 +0,0 @@
-"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-7GX444GM.js

@@ -1,46 +0,0 @@
-"use client";
-import {
-  require_basic
-} from "./chunk-DSAUO3FT.js";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vbnet.js
-var require_vbnet = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vbnet.js"(exports, module) {
-    var refractorBasic = require_basic();
-    module.exports = vbnet;
-    vbnet.displayName = "vbnet";
-    vbnet.aliases = [];
-    function vbnet(Prism) {
-      Prism.register(refractorBasic);
-      Prism.languages.vbnet = Prism.languages.extend("basic", {
-        comment: [
-          {
-            pattern: /(?:!|REM\b).+/i,
-            inside: {
-              keyword: /^REM/i
-            }
-          },
-          {
-            pattern: /(^|[^\\:])'.*/,
-            lookbehind: true,
-            greedy: true
-          }
-        ],
-        string: {
-          pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
-          lookbehind: true,
-          greedy: true
-        },
-        keyword: /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
-        punctuation: /[,;:(){}]/
-      });
-    }
-  }
-});
-
-export {
-  require_vbnet
-};

package/dist/chunk-7VWJOW6P.js

@@ -1,62 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/keyman.js
-var require_keyman = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/keyman.js"(exports, module) {
-    module.exports = keyman;
-    keyman.displayName = "keyman";
-    keyman.aliases = [];
-    function keyman(Prism) {
-      Prism.languages.keyman = {
-        comment: {
-          pattern: /\bc .*/i,
-          greedy: true
-        },
-        string: {
-          pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
-          greedy: true
-        },
-        "virtual-key": {
-          pattern: /\[\s*(?:(?:ALT|CAPS|CTRL|LALT|LCTRL|NCAPS|RALT|RCTRL|SHIFT)\s+)*(?:[TKU]_[\w?]+|[A-E]\d\d?|"[^"\r\n]*"|'[^'\r\n]*')\s*\]/i,
-          greedy: true,
-          alias: "function"
-          // alias for styles
-        },
-        // https://help.keyman.com/developer/language/guide/headers
-        "header-keyword": {
-          pattern: /&\w+/,
-          alias: "bold"
-          // alias for styles
-        },
-        "header-statement": {
-          pattern: /\b(?:bitmap|bitmaps|caps always off|caps on only|copyright|hotkey|language|layout|message|name|shift frees caps|version)\b/i,
-          alias: "bold"
-          // alias for styles
-        },
-        "rule-keyword": {
-          pattern: /\b(?:any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|reset|return|save|set|store|use)\b/i,
-          alias: "keyword"
-        },
-        "structural-keyword": {
-          pattern: /\b(?:ansi|begin|group|match|nomatch|unicode|using keys)\b/i,
-          alias: "keyword"
-        },
-        "compile-target": {
-          pattern: /\$(?:keyman|keymanonly|keymanweb|kmfl|weaver):/i,
-          alias: "property"
-        },
-        // U+####, x###, d### characters and numbers
-        number: /\b(?:U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i,
-        operator: /[+>\\$]|\.\./,
-        punctuation: /[()=,]/
-      };
-    }
-  }
-});
-
-export {
-  require_keyman
-};

package/dist/chunk-7WBWN6D5.js

@@ -1,94 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/haxe.js
-var require_haxe = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/haxe.js"(exports, module) {
-    module.exports = haxe;
-    haxe.displayName = "haxe";
-    haxe.aliases = [];
-    function haxe(Prism) {
-      Prism.languages.haxe = Prism.languages.extend("clike", {
-        string: {
-          // Strings can be multi-line
-          pattern: /"(?:[^"\\]|\\[\s\S])*"/,
-          greedy: true
-        },
-        "class-name": [
-          {
-            pattern: /(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
-            lookbehind: true
-          },
-          // based on naming convention
-          /\b[A-Z]\w*/
-        ],
-        // The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
-        keyword: /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
-        function: {
-          pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
-          greedy: true
-        },
-        operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
-      });
-      Prism.languages.insertBefore("haxe", "string", {
-        "string-interpolation": {
-          pattern: /'(?:[^'\\]|\\[\s\S])*'/,
-          greedy: true,
-          inside: {
-            interpolation: {
-              pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
-              lookbehind: true,
-              inside: {
-                "interpolation-punctuation": {
-                  pattern: /^\$\{?|\}$/,
-                  alias: "punctuation"
-                },
-                expression: {
-                  pattern: /[\s\S]+/,
-                  inside: Prism.languages.haxe
-                }
-              }
-            },
-            string: /[\s\S]+/
-          }
-        }
-      });
-      Prism.languages.insertBefore("haxe", "class-name", {
-        regex: {
-          pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
-          greedy: true,
-          inside: {
-            "regex-flags": /\b[a-z]+$/,
-            "regex-source": {
-              pattern: /^(~\/)[\s\S]+(?=\/$)/,
-              lookbehind: true,
-              alias: "language-regex",
-              inside: Prism.languages.regex
-            },
-            "regex-delimiter": /^~\/|\/$/
-          }
-        }
-      });
-      Prism.languages.insertBefore("haxe", "keyword", {
-        preprocessor: {
-          pattern: /#(?:else|elseif|end|if)\b.*/,
-          alias: "property"
-        },
-        metadata: {
-          pattern: /@:?[\w.]+/,
-          alias: "symbol"
-        },
-        reification: {
-          pattern: /\$(?:\w+|(?=\{))/,
-          alias: "important"
-        }
-      });
-    }
-  }
-});
-
-export {
-  require_haxe
-};

package/dist/chunk-A2TJMJHB.js

@@ -1,155 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/puppet.js
-var require_puppet = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/puppet.js"(exports, module) {
-    module.exports = puppet;
-    puppet.displayName = "puppet";
-    puppet.aliases = [];
-    function puppet(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.puppet = {
-          heredoc: [
-            // Matches the content of a quoted heredoc string (subject to interpolation)
-            {
-              pattern: /(@\("([^"\r\n\/):]+)"(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
-              lookbehind: true,
-              alias: "string",
-              inside: {
-                // Matches the end tag
-                punctuation: /(?=\S).*\S(?= *$)/
-                // See interpolation below
-              }
-            },
-            // Matches the content of an unquoted heredoc string (no interpolation)
-            {
-              pattern: /(@\(([^"\r\n\/):]+)(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
-              lookbehind: true,
-              greedy: true,
-              alias: "string",
-              inside: {
-                // Matches the end tag
-                punctuation: /(?=\S).*\S(?= *$)/
-              }
-            },
-            // Matches the start tag of heredoc strings
-            {
-              pattern: /@\("?(?:[^"\r\n\/):]+)"?(?:\/[nrts$uL]*)?\)/,
-              alias: "string",
-              inside: {
-                punctuation: {
-                  pattern: /(\().+?(?=\))/,
-                  lookbehind: true
-                }
-              }
-            }
-          ],
-          "multiline-comment": {
-            pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
-            lookbehind: true,
-            greedy: true,
-            alias: "comment"
-          },
-          regex: {
-            // Must be prefixed with the keyword "node" or a non-word char
-            pattern: /((?:\bnode\s+|[~=\(\[\{,]\s*|[=+]>\s*|^\s*))\/(?:[^\/\\]|\\[\s\S])+\/(?:[imx]+\b|\B)/,
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              // Extended regexes must have the x flag. They can contain single-line comments.
-              "extended-regex": {
-                pattern: /^\/(?:[^\/\\]|\\[\s\S])+\/[im]*x[im]*$/,
-                inside: {
-                  comment: /#.*/
-                }
-              }
-            }
-          },
-          comment: {
-            pattern: /(^|[^\\])#.*/,
-            lookbehind: true,
-            greedy: true
-          },
-          string: {
-            // Allow for one nested level of double quotes inside interpolation
-            pattern: /(["'])(?:\$\{(?:[^'"}]|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}|\$(?!\{)|(?!\1)[^\\$]|\\[\s\S])*\1/,
-            greedy: true,
-            inside: {
-              "double-quoted": {
-                pattern: /^"[\s\S]*"$/,
-                inside: {
-                  // See interpolation below
-                }
-              }
-            }
-          },
-          variable: {
-            pattern: /\$(?:::)?\w+(?:::\w+)*/,
-            inside: {
-              punctuation: /::/
-            }
-          },
-          "attr-name": /(?:\b\w+|\*)(?=\s*=>)/,
-          function: [
-            {
-              pattern: /(\.)(?!\d)\w+/,
-              lookbehind: true
-            },
-            /\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\b|\b(?!\d)\w+(?=\()/
-          ],
-          number: /\b(?:0x[a-f\d]+|\d+(?:\.\d+)?(?:e-?\d+)?)\b/i,
-          boolean: /\b(?:false|true)\b/,
-          // Includes words reserved for future use
-          keyword: /\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\b/,
-          datatype: {
-            pattern: /\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\b/,
-            alias: "symbol"
-          },
-          operator: /=[=~>]?|![=~]?|<(?:<\|?|[=~|-])?|>[>=]?|->?|~>|\|>?>?|[*\/%+?]|\b(?:and|in|or)\b/,
-          punctuation: /[\[\]{}().,;]|:+/
-        };
-        var interpolation = [
-          {
-            // Allow for one nested level of braces inside interpolation
-            pattern: /(^|[^\\])\$\{(?:[^'"{}]|\{[^}]*\}|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}/,
-            lookbehind: true,
-            inside: {
-              "short-variable": {
-                // Negative look-ahead prevent wrong highlighting of functions
-                pattern: /(^\$\{)(?!\w+\()(?:::)?\w+(?:::\w+)*/,
-                lookbehind: true,
-                alias: "variable",
-                inside: {
-                  punctuation: /::/
-                }
-              },
-              delimiter: {
-                pattern: /^\$/,
-                alias: "variable"
-              },
-              rest: Prism2.languages.puppet
-            }
-          },
-          {
-            pattern: /(^|[^\\])\$(?:::)?\w+(?:::\w+)*/,
-            lookbehind: true,
-            alias: "variable",
-            inside: {
-              punctuation: /::/
-            }
-          }
-        ];
-        Prism2.languages.puppet["heredoc"][0].inside.interpolation = interpolation;
-        Prism2.languages.puppet["string"].inside["double-quoted"].inside.interpolation = interpolation;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_puppet
-};

package/dist/chunk-ADKDXJMX.js

@@ -1,119 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/log.js
-var require_log = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/log.js"(exports, module) {
-    module.exports = log;
-    log.displayName = "log";
-    log.aliases = [];
-    function log(Prism) {
-      Prism.languages.log = {
-        string: {
-          // Single-quoted strings must not be confused with plain text. E.g. Can't isn't Susan's Chris' toy
-          pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/,
-          greedy: true
-        },
-        exception: {
-          pattern: /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/,
-          lookbehind: true,
-          greedy: true,
-          alias: ["javastacktrace", "language-javastacktrace"],
-          inside: Prism.languages["javastacktrace"] || {
-            keyword: /\bat\b/,
-            function: /[a-z_][\w$]*(?=\()/,
-            punctuation: /[.:()]/
-          }
-        },
-        level: [
-          {
-            pattern: /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/,
-            alias: ["error", "important"]
-          },
-          {
-            pattern: /\b(?:WARN|WARNING|WRN)\b/,
-            alias: ["warning", "important"]
-          },
-          {
-            pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/,
-            alias: ["info", "keyword"]
-          },
-          {
-            pattern: /\b(?:DBG|DEBUG|FINE)\b/,
-            alias: ["debug", "keyword"]
-          },
-          {
-            pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/,
-            alias: ["trace", "comment"]
-          }
-        ],
-        property: {
-          pattern: /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im,
-          lookbehind: true
-        },
-        separator: {
-          pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m,
-          lookbehind: true,
-          alias: "comment"
-        },
-        url: /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/,
-        email: {
-          pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/,
-          lookbehind: true,
-          alias: "url"
-        },
-        "ip-address": {
-          pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/,
-          alias: "constant"
-        },
-        "mac-address": {
-          pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i,
-          alias: "constant"
-        },
-        domain: {
-          pattern: /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/,
-          lookbehind: true,
-          alias: "constant"
-        },
-        uuid: {
-          pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i,
-          alias: "constant"
-        },
-        hash: {
-          pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i,
-          alias: "constant"
-        },
-        "file-path": {
-          pattern: /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i,
-          lookbehind: true,
-          greedy: true,
-          alias: "string"
-        },
-        date: {
-          pattern: RegExp(
-            /\b\d{4}[-/]\d{2}[-/]\d{2}(?:T(?=\d{1,2}:)|(?=\s\d{1,2}:))/.source + "|" + /\b\d{1,4}[-/ ](?:\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\d{2,4}T?\b/.source + "|" + /\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\s{1,2}\d{1,2}\b/.source,
-            "i"
-          ),
-          alias: "number"
-        },
-        time: {
-          pattern: /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/,
-          alias: "number"
-        },
-        boolean: /\b(?:false|null|true)\b/i,
-        number: {
-          pattern: /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i,
-          lookbehind: true
-        },
-        operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/,
-        punctuation: /[\[\].,]/
-      };
-    }
-  }
-});
-
-export {
-  require_log
-};