@distri/react 0.3.0 → 0.3.1

package/dist/chunk-VPWIZK3L.js

@@ -1,38 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cil.js
-var require_cil = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cil.js"(exports, module) {
-    module.exports = cil;
-    cil.displayName = "cil";
-    cil.aliases = [];
-    function cil(Prism) {
-      Prism.languages.cil = {
-        comment: /\/\/.*/,
-        string: {
-          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-          greedy: true
-        },
-        directive: {
-          pattern: /(^|\W)\.[a-z]+(?=\s)/,
-          lookbehind: true,
-          alias: "class-name"
-        },
-        // Actually an assembly reference
-        variable: /\[[\w\.]+\]/,
-        keyword: /\b(?:abstract|ansi|assembly|auto|autochar|beforefieldinit|bool|bstr|byvalstr|catch|char|cil|class|currency|date|decimal|default|enum|error|explicit|extends|extern|famandassem|family|famorassem|final(?:ly)?|float32|float64|hidebysig|u?int(?:8|16|32|64)?|iant|idispatch|implements|import|initonly|instance|interface|iunknown|literal|lpstr|lpstruct|lptstr|lpwstr|managed|method|native(?:Type)?|nested|newslot|object(?:ref)?|pinvokeimpl|private|privatescope|public|reqsecobj|rtspecialname|runtime|sealed|sequential|serializable|specialname|static|string|struct|syschar|tbstr|unicode|unmanagedexp|unsigned|value(?:type)?|variant|virtual|void)\b/,
-        function: /\b(?:(?:constrained|no|readonly|tail|unaligned|volatile)\.)?(?:conv\.(?:[iu][1248]?|ovf\.[iu][1248]?(?:\.un)?|r\.un|r4|r8)|ldc\.(?:i4(?:\.\d+|\.[mM]1|\.s)?|i8|r4|r8)|ldelem(?:\.[iu][1248]?|\.r[48]|\.ref|a)?|ldind\.(?:[iu][1248]?|r[48]|ref)|stelem\.?(?:i[1248]?|r[48]|ref)?|stind\.(?:i[1248]?|r[48]|ref)?|end(?:fault|filter|finally)|ldarg(?:\.[0-3s]|a(?:\.s)?)?|ldloc(?:\.\d+|\.s)?|sub(?:\.ovf(?:\.un)?)?|mul(?:\.ovf(?:\.un)?)?|add(?:\.ovf(?:\.un)?)?|stloc(?:\.[0-3s])?|refany(?:type|val)|blt(?:\.un)?(?:\.s)?|ble(?:\.un)?(?:\.s)?|bgt(?:\.un)?(?:\.s)?|bge(?:\.un)?(?:\.s)?|unbox(?:\.any)?|init(?:blk|obj)|call(?:i|virt)?|brfalse(?:\.s)?|bne\.un(?:\.s)?|ldloca(?:\.s)?|brzero(?:\.s)?|brtrue(?:\.s)?|brnull(?:\.s)?|brinst(?:\.s)?|starg(?:\.s)?|leave(?:\.s)?|shr(?:\.un)?|rem(?:\.un)?|div(?:\.un)?|clt(?:\.un)?|alignment|castclass|ldvirtftn|beq(?:\.s)?|ckfinite|ldsflda|ldtoken|localloc|mkrefany|rethrow|cgt\.un|arglist|switch|stsfld|sizeof|newobj|newarr|ldsfld|ldnull|ldflda|isinst|throw|stobj|stfld|ldstr|ldobj|ldlen|ldftn|ldfld|cpobj|cpblk|break|br\.s|xor|shl|ret|pop|not|nop|neg|jmp|dup|cgt|ceq|box|and|or|br)\b/,
-        boolean: /\b(?:false|true)\b/,
-        number: /\b-?(?:0x[0-9a-f]+|\d+)(?:\.[0-9a-f]+)?\b/i,
-        punctuation: /[{}[\];(),:=]|IL_[0-9A-Za-z]+/
-      };
-    }
-  }
-});
-
-export {
-  require_cil
-};

package/dist/chunk-VPYZQMFC.js

@@ -1,41 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/r.js
-var require_r = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/r.js"(exports, module) {
-    module.exports = r;
-    r.displayName = "r";
-    r.aliases = [];
-    function r(Prism) {
-      Prism.languages.r = {
-        comment: /#.*/,
-        string: {
-          pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-          greedy: true
-        },
-        "percent-operator": {
-          // Includes user-defined operators
-          // and %%, %*%, %/%, %in%, %o%, %x%
-          pattern: /%[^%\s]*%/,
-          alias: "operator"
-        },
-        boolean: /\b(?:FALSE|TRUE)\b/,
-        ellipsis: /\.\.(?:\.|\d+)/,
-        number: [
-          /\b(?:Inf|NaN)\b/,
-          /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/
-        ],
-        keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
-        operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
-        punctuation: /[(){}\[\],;]/
-      };
-    }
-  }
-});
-
-export {
-  require_r
-};

package/dist/chunk-VTG5OLQE.js

@@ -1,23 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/csv.js
-var require_csv = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/csv.js"(exports, module) {
-    module.exports = csv;
-    csv.displayName = "csv";
-    csv.aliases = [];
-    function csv(Prism) {
-      Prism.languages.csv = {
-        value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
-        punctuation: /,/
-      };
-    }
-  }
-});
-
-export {
-  require_csv
-};

package/dist/chunk-VW26B25E.js

@@ -1,27 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/hpkp.js
-var require_hpkp = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/hpkp.js"(exports, module) {
-    module.exports = hpkp;
-    hpkp.displayName = "hpkp";
-    hpkp.aliases = [];
-    function hpkp(Prism) {
-      Prism.languages.hpkp = {
-        directive: {
-          pattern: /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i,
-          alias: "property"
-        },
-        operator: /=/,
-        punctuation: /;/
-      };
-    }
-  }
-});
-
-export {
-  require_hpkp
-};

package/dist/chunk-VWKIXPFH.js

@@ -1,150 +0,0 @@
-"use client";
-import {
-  require_markup_templating
-} from "./chunk-DYCT6UGG.js";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/smarty.js
-var require_smarty = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/smarty.js"(exports, module) {
-    var refractorMarkupTemplating = require_markup_templating();
-    module.exports = smarty;
-    smarty.displayName = "smarty";
-    smarty.aliases = [];
-    function smarty(Prism) {
-      Prism.register(refractorMarkupTemplating);
-      (function(Prism2) {
-        Prism2.languages.smarty = {
-          comment: {
-            pattern: /^\{\*[\s\S]*?\*\}/,
-            greedy: true
-          },
-          "embedded-php": {
-            pattern: /^\{php\}[\s\S]*?\{\/php\}/,
-            greedy: true,
-            inside: {
-              smarty: {
-                pattern: /^\{php\}|\{\/php\}$/,
-                inside: null
-                // see below
-              },
-              php: {
-                pattern: /[\s\S]+/,
-                alias: "language-php",
-                inside: Prism2.languages.php
-              }
-            }
-          },
-          string: [
-            {
-              pattern: /"(?:\\.|[^"\\\r\n])*"/,
-              greedy: true,
-              inside: {
-                interpolation: {
-                  pattern: /\{[^{}]*\}|`[^`]*`/,
-                  inside: {
-                    "interpolation-punctuation": {
-                      pattern: /^[{`]|[`}]$/,
-                      alias: "punctuation"
-                    },
-                    expression: {
-                      pattern: /[\s\S]+/,
-                      inside: null
-                      // see below
-                    }
-                  }
-                },
-                variable: /\$\w+/
-              }
-            },
-            {
-              pattern: /'(?:\\.|[^'\\\r\n])*'/,
-              greedy: true
-            }
-          ],
-          keyword: {
-            pattern: /(^\{\/?)[a-z_]\w*\b(?!\()/i,
-            lookbehind: true,
-            greedy: true
-          },
-          delimiter: {
-            pattern: /^\{\/?|\}$/,
-            greedy: true,
-            alias: "punctuation"
-          },
-          number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
-          variable: [
-            /\$(?!\d)\w+/,
-            /#(?!\d)\w+#/,
-            {
-              pattern: /(\.|->|\w\s*=)(?!\d)\w+\b(?!\()/,
-              lookbehind: true
-            },
-            {
-              pattern: /(\[)(?!\d)\w+(?=\])/,
-              lookbehind: true
-            }
-          ],
-          function: {
-            pattern: /(\|\s*)@?[a-z_]\w*|\b[a-z_]\w*(?=\()/i,
-            lookbehind: true
-          },
-          "attr-name": /\b[a-z_]\w*(?=\s*=)/i,
-          boolean: /\b(?:false|no|off|on|true|yes)\b/,
-          punctuation: /[\[\](){}.,:`]|->/,
-          operator: [
-            /[+\-*\/%]|==?=?|[!<>]=?|&&|\|\|?/,
-            /\bis\s+(?:not\s+)?(?:div|even|odd)(?:\s+by)?\b/,
-            /\b(?:and|eq|gt?e|gt|lt?e|lt|mod|neq?|not|or)\b/
-          ]
-        };
-        Prism2.languages.smarty["embedded-php"].inside.smarty.inside = Prism2.languages.smarty;
-        Prism2.languages.smarty.string[0].inside.interpolation.inside.expression.inside = Prism2.languages.smarty;
-        var string = /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/;
-        var smartyPattern = RegExp(
-          // comments
-          /\{\*[\s\S]*?\*\}/.source + "|" + // php tags
-          /\{php\}[\s\S]*?\{\/php\}/.source + "|" + // smarty blocks
-          /\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>)*\})*\})*\}/.source.replace(
-            /<str>/g,
-            function() {
-              return string.source;
-            }
-          ),
-          "g"
-        );
-        Prism2.hooks.add("before-tokenize", function(env) {
-          var smartyLiteralStart = "{literal}";
-          var smartyLiteralEnd = "{/literal}";
-          var smartyLiteralMode = false;
-          Prism2.languages["markup-templating"].buildPlaceholders(
-            env,
-            "smarty",
-            smartyPattern,
-            function(match) {
-              if (match === smartyLiteralEnd) {
-                smartyLiteralMode = false;
-              }
-              if (!smartyLiteralMode) {
-                if (match === smartyLiteralStart) {
-                  smartyLiteralMode = true;
-                }
-                return true;
-              }
-              return false;
-            }
-          );
-        });
-        Prism2.hooks.add("after-tokenize", function(env) {
-          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "smarty");
-        });
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_smarty
-};

package/dist/chunk-VXO6WZ3Z.js

@@ -1,352 +0,0 @@
-"use client";
-import {
-  require_markup_templating
-} from "./chunk-DYCT6UGG.js";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/php.js
-var require_php = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/php.js"(exports, module) {
-    var refractorMarkupTemplating = require_markup_templating();
-    module.exports = php;
-    php.displayName = "php";
-    php.aliases = [];
-    function php(Prism) {
-      Prism.register(refractorMarkupTemplating);
-      (function(Prism2) {
-        var comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/;
-        var constant = [
-          {
-            pattern: /\b(?:false|true)\b/i,
-            alias: "boolean"
-          },
-          {
-            pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
-            greedy: true,
-            lookbehind: true
-          },
-          {
-            pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
-            greedy: true,
-            lookbehind: true
-          },
-          /\b(?:null)\b/i,
-          /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
-        ];
-        var number = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i;
-        var operator = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/;
-        var punctuation = /[{}\[\](),:;]/;
-        Prism2.languages.php = {
-          delimiter: {
-            pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
-            alias: "important"
-          },
-          comment,
-          variable: /\$+(?:\w+\b|(?=\{))/,
-          package: {
-            pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-            lookbehind: true,
-            inside: {
-              punctuation: /\\/
-            }
-          },
-          "class-name-definition": {
-            pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
-            lookbehind: true,
-            alias: "class-name"
-          },
-          "function-definition": {
-            pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
-            lookbehind: true,
-            alias: "function"
-          },
-          keyword: [
-            {
-              pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
-              alias: "type-casting",
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
-              alias: "type-hint",
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string|void)\b/i,
-              alias: "return-type",
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
-              alias: "type-declaration",
-              greedy: true
-            },
-            {
-              pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
-              alias: "type-declaration",
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /\b(?:parent|self|static)(?=\s*::)/i,
-              alias: "static-context",
-              greedy: true
-            },
-            {
-              // yield from
-              pattern: /(\byield\s+)from\b/i,
-              lookbehind: true
-            },
-            // `class` is always a keyword unlike other keywords
-            /\bclass\b/i,
-            {
-              // https://www.php.net/manual/en/reserved.keywords.php
-              //
-              // keywords cannot be preceded by "->"
-              // the complex lookbehind means `(?<!(?:->|::)\s*)`
-              pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|new|or|parent|print|private|protected|public|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
-              lookbehind: true
-            }
-          ],
-          "argument-name": {
-            pattern: /([(,]\s+)\b[a-z_]\w*(?=\s*:(?!:))/i,
-            lookbehind: true
-          },
-          "class-name": [
-            {
-              pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
-              greedy: true
-            },
-            {
-              pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
-              alias: "class-name-fully-qualified",
-              greedy: true,
-              lookbehind: true,
-              inside: {
-                punctuation: /\\/
-              }
-            },
-            {
-              pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
-              alias: "class-name-fully-qualified",
-              greedy: true,
-              inside: {
-                punctuation: /\\/
-              }
-            },
-            {
-              pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-              alias: "class-name-fully-qualified",
-              greedy: true,
-              lookbehind: true,
-              inside: {
-                punctuation: /\\/
-              }
-            },
-            {
-              pattern: /\b[a-z_]\w*(?=\s*\$)/i,
-              alias: "type-declaration",
-              greedy: true
-            },
-            {
-              pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
-              alias: ["class-name-fully-qualified", "type-declaration"],
-              greedy: true,
-              inside: {
-                punctuation: /\\/
-              }
-            },
-            {
-              pattern: /\b[a-z_]\w*(?=\s*::)/i,
-              alias: "static-context",
-              greedy: true
-            },
-            {
-              pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
-              alias: ["class-name-fully-qualified", "static-context"],
-              greedy: true,
-              inside: {
-                punctuation: /\\/
-              }
-            },
-            {
-              pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
-              alias: "type-hint",
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
-              alias: ["class-name-fully-qualified", "type-hint"],
-              greedy: true,
-              lookbehind: true,
-              inside: {
-                punctuation: /\\/
-              }
-            },
-            {
-              pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
-              alias: "return-type",
-              greedy: true,
-              lookbehind: true
-            },
-            {
-              pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-              alias: ["class-name-fully-qualified", "return-type"],
-              greedy: true,
-              lookbehind: true,
-              inside: {
-                punctuation: /\\/
-              }
-            }
-          ],
-          constant,
-          function: {
-            pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
-            lookbehind: true,
-            inside: {
-              punctuation: /\\/
-            }
-          },
-          property: {
-            pattern: /(->\s*)\w+/,
-            lookbehind: true
-          },
-          number,
-          operator,
-          punctuation
-        };
-        var string_interpolation = {
-          pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
-          lookbehind: true,
-          inside: Prism2.languages.php
-        };
-        var string = [
-          {
-            pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
-            alias: "nowdoc-string",
-            greedy: true,
-            inside: {
-              delimiter: {
-                pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
-                alias: "symbol",
-                inside: {
-                  punctuation: /^<<<'?|[';]$/
-                }
-              }
-            }
-          },
-          {
-            pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
-            alias: "heredoc-string",
-            greedy: true,
-            inside: {
-              delimiter: {
-                pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
-                alias: "symbol",
-                inside: {
-                  punctuation: /^<<<"?|[";]$/
-                }
-              },
-              interpolation: string_interpolation
-            }
-          },
-          {
-            pattern: /`(?:\\[\s\S]|[^\\`])*`/,
-            alias: "backtick-quoted-string",
-            greedy: true
-          },
-          {
-            pattern: /'(?:\\[\s\S]|[^\\'])*'/,
-            alias: "single-quoted-string",
-            greedy: true
-          },
-          {
-            pattern: /"(?:\\[\s\S]|[^\\"])*"/,
-            alias: "double-quoted-string",
-            greedy: true,
-            inside: {
-              interpolation: string_interpolation
-            }
-          }
-        ];
-        Prism2.languages.insertBefore("php", "variable", {
-          string,
-          attribute: {
-            pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
-            greedy: true,
-            inside: {
-              "attribute-content": {
-                pattern: /^(#\[)[\s\S]+(?=\]$)/,
-                lookbehind: true,
-                // inside can appear subset of php
-                inside: {
-                  comment,
-                  string,
-                  "attribute-class-name": [
-                    {
-                      pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
-                      alias: "class-name",
-                      greedy: true,
-                      lookbehind: true
-                    },
-                    {
-                      pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
-                      alias: ["class-name", "class-name-fully-qualified"],
-                      greedy: true,
-                      lookbehind: true,
-                      inside: {
-                        punctuation: /\\/
-                      }
-                    }
-                  ],
-                  constant,
-                  number,
-                  operator,
-                  punctuation
-                }
-              },
-              delimiter: {
-                pattern: /^#\[|\]$/,
-                alias: "punctuation"
-              }
-            }
-          }
-        });
-        Prism2.hooks.add("before-tokenize", function(env) {
-          if (!/<\?/.test(env.code)) {
-            return;
-          }
-          var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
-          Prism2.languages["markup-templating"].buildPlaceholders(
-            env,
-            "php",
-            phpPattern
-          );
-        });
-        Prism2.hooks.add("after-tokenize", function(env) {
-          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "php");
-        });
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_php
-};

package/dist/chunk-VYRJGD3W.js

@@ -1,44 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rego.js
-var require_rego = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rego.js"(exports, module) {
-    module.exports = rego;
-    rego.displayName = "rego";
-    rego.aliases = [];
-    function rego(Prism) {
-      Prism.languages.rego = {
-        comment: /#.*/,
-        property: {
-          pattern: /(^|[^\\.])(?:"(?:\\.|[^\\"\r\n])*"|`[^`]*`|\b[a-z_]\w*\b)(?=\s*:(?!=))/i,
-          lookbehind: true,
-          greedy: true
-        },
-        string: {
-          pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"|`[^`]*`/,
-          lookbehind: true,
-          greedy: true
-        },
-        keyword: /\b(?:as|default|else|import|not|null|package|set(?=\s*\()|some|with)\b/,
-        boolean: /\b(?:false|true)\b/,
-        function: {
-          pattern: /\b[a-z_]\w*\b(?:\s*\.\s*\b[a-z_]\w*\b)*(?=\s*\()/i,
-          inside: {
-            namespace: /\b\w+\b(?=\s*\.)/,
-            punctuation: /\./
-          }
-        },
-        number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
-        operator: /[-+*/%|&]|[<>:=]=?|!=|\b_\b/,
-        punctuation: /[,;.\[\]{}()]/
-      };
-    }
-  }
-});
-
-export {
-  require_rego
-};