@distri/react 0.2.7 → 0.3.0

package/dist/chunk-75PP7PI6.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
+};

package/dist/chunk-76OIATWI.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-7GX444GM.js

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

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

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

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

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