@distri/react 0.3.1 → 0.3.2

package/dist/chunk-KOMNWMW6.js

@@ -0,0 +1,50 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wasm.js
+var require_wasm = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wasm.js"(exports, module) {
+    module.exports = wasm;
+    wasm.displayName = "wasm";
+    wasm.aliases = [];
+    function wasm(Prism) {
+      Prism.languages.wasm = {
+        comment: [
+          /\(;[\s\S]*?;\)/,
+          {
+            pattern: /;;.*/,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /"(?:\\[\s\S]|[^"\\])*"/,
+          greedy: true
+        },
+        keyword: [
+          {
+            pattern: /\b(?:align|offset)=/,
+            inside: {
+              operator: /=/
+            }
+          },
+          {
+            pattern: /\b(?:(?:f32|f64|i32|i64)(?:\.(?:abs|add|and|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|or|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|xor))?|memory\.(?:grow|size))\b/,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          /\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\b/
+        ],
+        variable: /\$[\w!#$%&'*+\-./:<=>?@\\^`|~]+/,
+        number: /[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[\da-fA-F](?:_?[\da-fA-F])*(?:\.[\da-fA-F](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[\da-fA-F](?:_?[\da-fA-D])*)?\b/,
+        punctuation: /[()]/
+      };
+    }
+  }
+});
+
+export {
+  require_wasm
+};

package/dist/chunk-KVLLQAIY.js

@@ -0,0 +1,132 @@
+"use client";
+import {
+  require_csharp
+} from "./chunk-TR5CHC4X.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cshtml.js
+var require_cshtml = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cshtml.js"(exports, module) {
+    var refractorCsharp = require_csharp();
+    module.exports = cshtml;
+    cshtml.displayName = "cshtml";
+    cshtml.aliases = ["razor"];
+    function cshtml(Prism) {
+      Prism.register(refractorCsharp);
+      (function(Prism2) {
+        var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source;
+        var stringLike = /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source + "|" + /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
+        function nested(pattern, depthLog2) {
+          for (var i = 0; i < depthLog2; i++) {
+            pattern = pattern.replace(/<self>/g, function() {
+              return "(?:" + pattern + ")";
+            });
+          }
+          return pattern.replace(/<self>/g, "[^\\s\\S]").replace(/<str>/g, "(?:" + stringLike + ")").replace(/<comment>/g, "(?:" + commentLike + ")");
+        }
+        var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
+        var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2);
+        var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
+        var angle = nested(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2);
+        var tagAttrs = /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/.source;
+        var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
+        var tagRegion = /\B@?/.source + "(?:" + /<([a-zA-Z][\w:]*)/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
+        // eslint-disable-next-line regexp/strict
+        /<\/?(?!\1\b)/.source + tagContent + "|" + // nested start tag
+        nested(
+          // eslint-disable-next-line regexp/strict
+          /<\1/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
+          // eslint-disable-next-line regexp/strict
+          /<\/?(?!\1\b)/.source + tagContent + "|<self>") + ")*" + // eslint-disable-next-line regexp/strict
+          /<\/\1\s*>/.source,
+          2
+        )) + ")*" + // eslint-disable-next-line regexp/strict
+        /<\/\1\s*>/.source + "|" + /</.source + tagContent + ")";
+        Prism2.languages.cshtml = Prism2.languages.extend("markup", {});
+        var csharpWithHtml = Prism2.languages.insertBefore(
+          "csharp",
+          "string",
+          {
+            html: {
+              pattern: RegExp(tagRegion),
+              greedy: true,
+              inside: Prism2.languages.cshtml
+            }
+          },
+          {
+            csharp: Prism2.languages.extend("csharp", {})
+          }
+        );
+        var cs = {
+          pattern: /\S[\s\S]*/,
+          alias: "language-csharp",
+          inside: csharpWithHtml
+        };
+        Prism2.languages.insertBefore("cshtml", "prolog", {
+          "razor-comment": {
+            pattern: /@\*[\s\S]*?\*@/,
+            greedy: true,
+            alias: "comment"
+          },
+          block: {
+            pattern: RegExp(
+              /(^|[^@])@/.source + "(?:" + [
+                // @{ ... }
+                curly,
+                // @code{ ... }
+                /(?:code|functions)\s*/.source + curly,
+                // @for (...) { ... }
+                /(?:for|foreach|lock|switch|using|while)\s*/.source + round + /\s*/.source + curly,
+                // @do { ... } while (...);
+                /do\s*/.source + curly + /\s*while\s*/.source + round + /(?:\s*;)?/.source,
+                // @try { ... } catch (...) { ... } finally { ... }
+                /try\s*/.source + curly + /\s*catch\s*/.source + round + /\s*/.source + curly + /\s*finally\s*/.source + curly,
+                // @if (...) {...} else if (...) {...} else {...}
+                /if\s*/.source + round + /\s*/.source + curly + "(?:" + /\s*else/.source + "(?:" + /\s+if\s*/.source + round + ")?" + /\s*/.source + curly + ")*"
+              ].join("|") + ")"
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              keyword: /^@\w*/,
+              csharp: cs
+            }
+          },
+          directive: {
+            pattern: /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              keyword: /^@\w+/,
+              csharp: cs
+            }
+          },
+          value: {
+            pattern: RegExp(
+              /(^|[^@])@/.source + /(?:await\b\s*)?/.source + "(?:" + /\w+\b/.source + "|" + round + ")(?:" + /[?!]?\.\w+\b/.source + "|" + round + "|" + square + "|" + angle + round + ")*"
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "variable",
+            inside: {
+              keyword: /^@/,
+              csharp: cs
+            }
+          },
+          "delegate-operator": {
+            pattern: /(^|[^@])@(?=<)/,
+            lookbehind: true,
+            alias: "operator"
+          }
+        });
+        Prism2.languages.razor = Prism2.languages.cshtml;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_cshtml
+};

package/dist/chunk-LAIV7V4D.js

@@ -0,0 +1,72 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-XUQ4ZZPG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tt2.js
+var require_tt2 = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tt2.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = tt2;
+    tt2.displayName = "tt2";
+    tt2.aliases = [];
+    function tt2(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        Prism2.languages.tt2 = Prism2.languages.extend("clike", {
+          comment: /#.*|\[%#[\s\S]*?%\]/,
+          keyword: /\b(?:BLOCK|CALL|CASE|CATCH|CLEAR|DEBUG|DEFAULT|ELSE|ELSIF|END|FILTER|FINAL|FOREACH|GET|IF|IN|INCLUDE|INSERT|LAST|MACRO|META|NEXT|PERL|PROCESS|RAWPERL|RETURN|SET|STOP|SWITCH|TAGS|THROW|TRY|UNLESS|USE|WHILE|WRAPPER)\b/,
+          punctuation: /[[\]{},()]/
+        });
+        Prism2.languages.insertBefore("tt2", "number", {
+          operator: /=[>=]?|!=?|<=?|>=?|&&|\|\|?|\b(?:and|not|or)\b/,
+          variable: {
+            pattern: /\b[a-z]\w*(?:\s*\.\s*(?:\d+|\$?[a-z]\w*))*\b/i
+          }
+        });
+        Prism2.languages.insertBefore("tt2", "keyword", {
+          delimiter: {
+            pattern: /^(?:\[%|%%)-?|-?%\]$/,
+            alias: "punctuation"
+          }
+        });
+        Prism2.languages.insertBefore("tt2", "string", {
+          "single-quoted-string": {
+            pattern: /'[^\\']*(?:\\[\s\S][^\\']*)*'/,
+            greedy: true,
+            alias: "string"
+          },
+          "double-quoted-string": {
+            pattern: /"[^\\"]*(?:\\[\s\S][^\\"]*)*"/,
+            greedy: true,
+            alias: "string",
+            inside: {
+              variable: {
+                pattern: /\$(?:[a-z]\w*(?:\.(?:\d+|\$?[a-z]\w*))*)/i
+              }
+            }
+          }
+        });
+        delete Prism2.languages.tt2.string;
+        Prism2.hooks.add("before-tokenize", function(env) {
+          var tt2Pattern = /\[%[\s\S]+?%\]/g;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "tt2",
+            tt2Pattern
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "tt2");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_tt2
+};

package/dist/chunk-LB3N6HYU.js

@@ -0,0 +1,60 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsstacktrace.js
+var require_jsstacktrace = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsstacktrace.js"(exports, module) {
+    module.exports = jsstacktrace;
+    jsstacktrace.displayName = "jsstacktrace";
+    jsstacktrace.aliases = [];
+    function jsstacktrace(Prism) {
+      Prism.languages.jsstacktrace = {
+        "error-message": {
+          pattern: /^\S.*/m,
+          alias: "string"
+        },
+        "stack-frame": {
+          pattern: /(^[ \t]+)at[ \t].*/m,
+          lookbehind: true,
+          inside: {
+            "not-my-code": {
+              pattern: /^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m,
+              alias: "comment"
+            },
+            filename: {
+              pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
+              lookbehind: true,
+              alias: "url"
+            },
+            function: {
+              pattern: /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
+              lookbehind: true,
+              inside: {
+                punctuation: /\./
+              }
+            },
+            punctuation: /[()]/,
+            keyword: /\b(?:at|new)\b/,
+            alias: {
+              pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
+              alias: "variable"
+            },
+            "line-number": {
+              pattern: /:\d+(?::\d+)?\b/,
+              alias: "number",
+              inside: {
+                punctuation: /:/
+              }
+            }
+          }
+        }
+      };
+    }
+  }
+});
+
+export {
+  require_jsstacktrace
+};

package/dist/chunk-LDSSSJQI.js

@@ -0,0 +1,38 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/prolog.js
+var require_prolog = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/prolog.js"(exports, module) {
+    module.exports = prolog;
+    prolog.displayName = "prolog";
+    prolog.aliases = [];
+    function prolog(Prism) {
+      Prism.languages.prolog = {
+        // Syntax depends on the implementation
+        comment: {
+          pattern: /\/\*[\s\S]*?\*\/|%.*/,
+          greedy: true
+        },
+        // Depending on the implementation, strings may allow escaped newlines and quote-escape
+        string: {
+          pattern: /(["'])(?:\1\1|\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1(?!\1)/,
+          greedy: true
+        },
+        builtin: /\b(?:fx|fy|xf[xy]?|yfx?)\b/,
+        // FIXME: Should we list all null-ary predicates (not followed by a parenthesis) like halt, trace, etc.?
+        function: /\b[a-z]\w*(?:(?=\()|\/\d+)/,
+        number: /\b\d+(?:\.\d*)?/,
+        // Custom operators are allowed
+        operator: /[:\\=><\-?*@\/;+^|!$.]+|\b(?:is|mod|not|xor)\b/,
+        punctuation: /[(){}\[\],]/
+      };
+    }
+  }
+});
+
+export {
+  require_prolog
+};

package/dist/chunk-LKU2HB7I.js

@@ -0,0 +1,108 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pure.js
+var require_pure = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pure.js"(exports, module) {
+    module.exports = pure;
+    pure.displayName = "pure";
+    pure.aliases = [];
+    function pure(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.pure = {
+          comment: [
+            {
+              pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+              lookbehind: true
+            },
+            {
+              pattern: /(^|[^\\:])\/\/.*/,
+              lookbehind: true
+            },
+            /#!.+/
+          ],
+          "inline-lang": {
+            pattern: /%<[\s\S]+?%>/,
+            greedy: true,
+            inside: {
+              lang: {
+                pattern: /(^%< *)-\*-.+?-\*-/,
+                lookbehind: true,
+                alias: "comment"
+              },
+              delimiter: {
+                pattern: /^%<.*|%>$/,
+                alias: "punctuation"
+              }
+            }
+          },
+          string: {
+            pattern: /"(?:\\.|[^"\\\r\n])*"/,
+            greedy: true
+          },
+          number: {
+            // The look-behind prevents wrong highlighting of the .. operator
+            pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?L?)/i,
+            lookbehind: true
+          },
+          keyword: /\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\b/,
+          function: /\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\b/,
+          special: {
+            pattern: /\b__[a-z]+__\b/i,
+            alias: "builtin"
+          },
+          // Any combination of operator chars can be an operator
+          // eslint-disable-next-line no-misleading-character-class
+          operator: /(?:[!"#$%&'*+,\-.\/:<=>?@\\^`|~\u00a1-\u00bf\u00d7-\u00f7\u20d0-\u2bff]|\b_+\b)+|\b(?:and|div|mod|not|or)\b/,
+          // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?
+          punctuation: /[(){}\[\];,|]/
+        };
+        var inlineLanguages = [
+          "c",
+          {
+            lang: "c++",
+            alias: "cpp"
+          },
+          "fortran"
+        ];
+        var inlineLanguageRe = /%< *-\*- *<lang>\d* *-\*-[\s\S]+?%>/.source;
+        inlineLanguages.forEach(function(lang) {
+          var alias = lang;
+          if (typeof lang !== "string") {
+            alias = lang.alias;
+            lang = lang.lang;
+          }
+          if (Prism2.languages[alias]) {
+            var o = {};
+            o["inline-lang-" + alias] = {
+              pattern: RegExp(
+                inlineLanguageRe.replace(
+                  "<lang>",
+                  lang.replace(/([.+*?\/\\(){}\[\]])/g, "\\$1")
+                ),
+                "i"
+              ),
+              inside: Prism2.util.clone(Prism2.languages.pure["inline-lang"].inside)
+            };
+            o["inline-lang-" + alias].inside.rest = Prism2.util.clone(
+              Prism2.languages[alias]
+            );
+            Prism2.languages.insertBefore("pure", "inline-lang", o);
+          }
+        });
+        if (Prism2.languages.c) {
+          Prism2.languages.pure["inline-lang"].inside.rest = Prism2.util.clone(
+            Prism2.languages.c
+          );
+        }
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_pure
+};

package/dist/chunk-LONXLQIZ.js

@@ -0,0 +1,66 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apacheconf.js
+var require_apacheconf = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apacheconf.js"(exports, module) {
+    module.exports = apacheconf;
+    apacheconf.displayName = "apacheconf";
+    apacheconf.aliases = [];
+    function apacheconf(Prism) {
+      Prism.languages.apacheconf = {
+        comment: /#.*/,
+        "directive-inline": {
+          pattern: /(^[\t ]*)\b(?:AcceptFilter|AcceptPathInfo|AccessFileName|Action|Add(?:Alt|AltByEncoding|AltByType|Charset|DefaultCharset|Description|Encoding|Handler|Icon|IconByEncoding|IconByType|InputFilter|Language|ModuleInfo|OutputFilter|OutputFilterByType|Type)|Alias|AliasMatch|Allow(?:CONNECT|EncodedSlashes|Methods|Override|OverrideList)?|Anonymous(?:_LogEmail|_MustGiveEmail|_NoUserID|_VerifyEmail)?|AsyncRequestWorkerFactor|Auth(?:BasicAuthoritative|BasicFake|BasicProvider|BasicUseDigestAlgorithm|DBDUserPWQuery|DBDUserRealmQuery|DBMGroupFile|DBMType|DBMUserFile|Digest(?:Algorithm|Domain|NonceLifetime|Provider|Qop|ShmemSize)|Form(?:Authoritative|Body|DisableNoStore|FakeBasicAuth|Location|LoginRequiredLocation|LoginSuccessLocation|LogoutLocation|Method|Mimetype|Password|Provider|SitePassphrase|Size|Username)|GroupFile|LDAP(?:AuthorizePrefix|BindAuthoritative|BindDN|BindPassword|CharsetConfig|CompareAsUser|CompareDNOnServer|DereferenceAliases|GroupAttribute|GroupAttributeIsDN|InitialBindAsUser|InitialBindPattern|MaxSubGroupDepth|RemoteUserAttribute|RemoteUserIsDN|SearchAsUser|SubGroupAttribute|SubGroupClass|Url)|Merging|Name|nCache(?:Context|Enable|ProvideFor|SOCache|Timeout)|nzFcgiCheckAuthnProvider|nzFcgiDefineProvider|Type|UserFile|zDBDLoginToReferer|zDBDQuery|zDBDRedirectQuery|zDBMType|zSendForbiddenOnFailure)|BalancerGrowth|BalancerInherit|BalancerMember|BalancerPersist|BrowserMatch|BrowserMatchNoCase|BufferedLogs|BufferSize|Cache(?:DefaultExpire|DetailHeader|DirLength|DirLevels|Disable|Enable|File|Header|IgnoreCacheControl|IgnoreHeaders|IgnoreNoLastMod|IgnoreQueryString|IgnoreURLSessionIdentifiers|KeyBaseURL|LastModifiedFactor|Lock|LockMaxAge|LockPath|MaxExpire|MaxFileSize|MinExpire|MinFileSize|NegotiatedDocs|QuickHandler|ReadSize|ReadTime|Root|Socache(?:MaxSize|MaxTime|MinTime|ReadSize|ReadTime)?|StaleOnError|StoreExpired|StoreNoStore|StorePrivate)|CGIDScriptTimeout|CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckCaseOnly|CheckSpelling|ChrootDir|ContentDigest|CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavGenericLockDB|DavLockDB|DavMinTimeout|DBDExptime|DBDInitSQL|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver|DefaultIcon|DefaultLanguage|DefaultRuntimeDir|DefaultType|Define|Deflate(?:BufferSize|CompressionLevel|FilterNote|InflateLimitRequestBody|InflateRatio(?:Burst|Limit)|MemLevel|WindowSize)|Deny|DirectoryCheckHandler|DirectoryIndex|DirectoryIndexRedirect|DirectorySlash|DocumentRoot|DTracePrivileges|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|Error|ErrorDocument|ErrorLog|ErrorLogFormat|Example|ExpiresActive|ExpiresByType|ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FallbackResource|FileETag|FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace|ForceLanguagePriority|ForceType|ForensicLog|GprofDir|GracefulShutdownTimeout|Group|Header|HeaderName|Heartbeat(?:Address|Listen|MaxServers|Storage)|HostnameLookups|IdentityCheck|IdentityCheckTimeout|ImapBase|ImapDefault|ImapMenu|Include|IncludeOptional|Index(?:HeadInsert|Ignore|IgnoreReset|Options|OrderDefault|StyleSheet)|InputSed|ISAPI(?:AppendLogToErrors|AppendLogToQuery|CacheFile|FakeAsync|LogNotSupported|ReadAheadBuffer)|KeepAlive|KeepAliveTimeout|KeptBodySize|LanguagePriority|LDAP(?:CacheEntries|CacheTTL|ConnectionPoolTTL|ConnectionTimeout|LibraryDebug|OpCacheEntries|OpCacheTTL|ReferralHopLimit|Referrals|Retries|RetryDelay|SharedCacheFile|SharedCacheSize|Timeout|TrustedClientCert|TrustedGlobalCert|TrustedMode|VerifyServerCert)|Limit(?:InternalRecursion|Request(?:Body|Fields|FieldSize|Line)|XMLRequestBody)|Listen|ListenBackLog|LoadFile|LoadModule|LogFormat|LogLevel|LogMessage|LuaAuthzProvider|LuaCodeCache|Lua(?:Hook(?:AccessChecker|AuthChecker|CheckUserID|Fixups|InsertFilter|Log|MapToStorage|TranslateName|TypeChecker)|Inherit|InputFilter|MapHandler|OutputFilter|PackageCPath|PackagePath|QuickHandler|Root|Scope)|Max(?:ConnectionsPerChild|KeepAliveRequests|MemFree|RangeOverlaps|RangeReversals|Ranges|RequestWorkers|SpareServers|SpareThreads|Threads)|MergeTrailers|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads|MMapFile|ModemStandard|ModMimeUsePathInfo|MultiviewsMatch|Mutex|NameVirtualHost|NoProxy|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|OutputSed|PassEnv|PidFile|PrivilegesMode|Protocol|ProtocolEcho|Proxy(?:AddHeaders|BadHeader|Block|Domain|ErrorOverride|ExpressDBMFile|ExpressDBMType|ExpressEnable|FtpDirCharset|FtpEscapeWildcards|FtpListOnWildcard|HTML(?:BufSize|CharsetOut|DocType|Enable|Events|Extended|Fixups|Interp|Links|Meta|StripComments|URLMap)|IOBufferSize|MaxForwards|Pass(?:Inherit|InterpolateEnv|Match|Reverse|ReverseCookieDomain|ReverseCookiePath)?|PreserveHost|ReceiveBufferSize|Remote|RemoteMatch|Requests|SCGIInternalRedirect|SCGISendfile|Set|SourceAddress|Status|Timeout|Via)|ReadmeName|ReceiveBufferSize|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ReflectorHeader|RemoteIP(?:Header|InternalProxy|InternalProxyList|ProxiesHeader|TrustedProxy|TrustedProxyList)|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader|RequestReadTimeout|Require|Rewrite(?:Base|Cond|Engine|Map|Options|Rule)|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScoreBoardFile|Script(?:Alias|AliasMatch|InterpreterSource|Log|LogBuffer|LogLength|Sock)?|SecureListen|SeeRequestTail|SendBufferSize|Server(?:Admin|Alias|Limit|Name|Path|Root|Signature|Tokens)|Session(?:Cookie(?:Name|Name2|Remove)|Crypto(?:Cipher|Driver|Passphrase|PassphraseFile)|DBD(?:CookieName|CookieName2|CookieRemove|DeleteLabel|InsertLabel|PerUser|SelectLabel|UpdateLabel)|Env|Exclude|Header|Include|MaxAge)?|SetEnv|SetEnvIf|SetEnvIfExpr|SetEnvIfNoCase|SetHandler|SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIETag|SSILastModified|SSILegacyExprParser|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSL(?:CACertificateFile|CACertificatePath|CADNRequestFile|CADNRequestPath|CARevocationCheck|CARevocationFile|CARevocationPath|CertificateChainFile|CertificateFile|CertificateKeyFile|CipherSuite|Compression|CryptoDevice|Engine|FIPS|HonorCipherOrder|InsecureRenegotiation|OCSP(?:DefaultResponder|Enable|OverrideResponder|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|UseRequestNonce)|OpenSSLConfCmd|Options|PassPhraseDialog|Protocol|Proxy(?:CACertificateFile|CACertificatePath|CARevocation(?:Check|File|Path)|CheckPeer(?:CN|Expire|Name)|CipherSuite|Engine|MachineCertificate(?:ChainFile|File|Path)|Protocol|Verify|VerifyDepth)|RandomSeed|RenegBufferSize|Require|RequireSSL|Session(?:Cache|CacheTimeout|TicketKeyFile|Tickets)|SRPUnknownUserSeed|SRPVerifierFile|Stapling(?:Cache|ErrorCacheTimeout|FakeTryLater|ForceURL|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|ReturnResponderErrors|StandardCacheTimeout)|StrictSNIVHostCheck|UserName|UseStapling|VerifyClient|VerifyDepth)|StartServers|StartThreads|Substitute|Suexec|SuexecUserGroup|ThreadLimit|ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnDefine|UndefMacro|UnsetEnv|Use|UseCanonicalName|UseCanonicalPhysicalPort|User|UserDir|VHostCGIMode|VHostCGIPrivs|VHostGroup|VHostPrivs|VHostSecure|VHostUser|Virtual(?:DocumentRoot|ScriptAlias)(?:IP)?|WatchdogInterval|XBitHack|xml2EncAlias|xml2EncDefault|xml2StartParse)\b/im,
+          lookbehind: true,
+          alias: "property"
+        },
+        "directive-block": {
+          pattern: /<\/?\b(?:Auth[nz]ProviderAlias|Directory|DirectoryMatch|Else|ElseIf|Files|FilesMatch|If|IfDefine|IfModule|IfVersion|Limit|LimitExcept|Location|LocationMatch|Macro|Proxy|Require(?:All|Any|None)|VirtualHost)\b.*>/i,
+          inside: {
+            "directive-block": {
+              pattern: /^<\/?\w+/,
+              inside: {
+                punctuation: /^<\/?/
+              },
+              alias: "tag"
+            },
+            "directive-block-parameter": {
+              pattern: /.*[^>]/,
+              inside: {
+                punctuation: /:/,
+                string: {
+                  pattern: /("|').*\1/,
+                  inside: {
+                    variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/
+                  }
+                }
+              },
+              alias: "attr-value"
+            },
+            punctuation: />/
+          },
+          alias: "tag"
+        },
+        "directive-flags": {
+          pattern: /\[(?:[\w=],?)+\]/,
+          alias: "keyword"
+        },
+        string: {
+          pattern: /("|').*\1/,
+          inside: {
+            variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/
+          }
+        },
+        variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/,
+        regex: /\^?.*\$|\^.*\$?/
+      };
+    }
+  }
+});
+
+export {
+  require_apacheconf
+};

package/dist/chunk-LSGY64ZA.js

@@ -0,0 +1,59 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/protobuf.js
+var require_protobuf = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/protobuf.js"(exports, module) {
+    module.exports = protobuf;
+    protobuf.displayName = "protobuf";
+    protobuf.aliases = [];
+    function protobuf(Prism) {
+      ;
+      (function(Prism2) {
+        var builtinTypes = /\b(?:bool|bytes|double|s?fixed(?:32|64)|float|[su]?int(?:32|64)|string)\b/;
+        Prism2.languages.protobuf = Prism2.languages.extend("clike", {
+          "class-name": [
+            {
+              pattern: /(\b(?:enum|extend|message|service)\s+)[A-Za-z_]\w*(?=\s*\{)/,
+              lookbehind: true
+            },
+            {
+              pattern: /(\b(?:rpc\s+\w+|returns)\s*\(\s*(?:stream\s+)?)\.?[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?=\s*\))/,
+              lookbehind: true
+            }
+          ],
+          keyword: /\b(?:enum|extend|extensions|import|message|oneof|option|optional|package|public|repeated|required|reserved|returns|rpc(?=\s+\w)|service|stream|syntax|to)\b(?!\s*=\s*\d)/,
+          function: /\b[a-z_]\w*(?=\s*\()/i
+        });
+        Prism2.languages.insertBefore("protobuf", "operator", {
+          map: {
+            pattern: /\bmap<\s*[\w.]+\s*,\s*[\w.]+\s*>(?=\s+[a-z_]\w*\s*[=;])/i,
+            alias: "class-name",
+            inside: {
+              punctuation: /[<>.,]/,
+              builtin: builtinTypes
+            }
+          },
+          builtin: builtinTypes,
+          "positional-class-name": {
+            pattern: /(?:\b|\B\.)[a-z_]\w*(?:\.[a-z_]\w*)*(?=\s+[a-z_]\w*\s*[=;])/i,
+            alias: "class-name",
+            inside: {
+              punctuation: /\./
+            }
+          },
+          annotation: {
+            pattern: /(\[\s*)[a-z_]\w*(?=\s*=)/i,
+            lookbehind: true
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_protobuf
+};

package/dist/chunk-M36ANKM4.js

@@ -0,0 +1,63 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-XUQ4ZZPG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/twig.js
+var require_twig = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/twig.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = twig;
+    twig.displayName = "twig";
+    twig.aliases = [];
+    function twig(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      Prism.languages.twig = {
+        comment: /^\{#[\s\S]*?#\}$/,
+        "tag-name": {
+          pattern: /(^\{%-?\s*)\w+/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        delimiter: {
+          pattern: /^\{[{%]-?|-?[%}]\}$/,
+          alias: "punctuation"
+        },
+        string: {
+          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          inside: {
+            punctuation: /^['"]|['"]$/
+          }
+        },
+        keyword: /\b(?:even|if|odd)\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: /[()\[\]{}:.,]/
+      };
+      Prism.hooks.add("before-tokenize", function(env) {
+        if (env.language !== "twig") {
+          return;
+        }
+        var pattern = /\{(?:#[\s\S]*?#|%[\s\S]*?%|\{[\s\S]*?\})\}/g;
+        Prism.languages["markup-templating"].buildPlaceholders(env, "twig", pattern);
+      });
+      Prism.hooks.add("after-tokenize", function(env) {
+        Prism.languages["markup-templating"].tokenizePlaceholders(env, "twig");
+      });
+    }
+  }
+});
+
+export {
+  require_twig
+};