@distri/react 0.3.3 → 0.3.4

package/dist/chunk-2JUB4ICW.js

@@ -1,88 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/velocity.js
-var require_velocity = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/velocity.js"(exports, module) {
-    module.exports = velocity;
-    velocity.displayName = "velocity";
-    velocity.aliases = [];
-    function velocity(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.velocity = Prism2.languages.extend("markup", {});
-        var velocity2 = {
-          variable: {
-            pattern: /(^|[^\\](?:\\\\)*)\$!?(?:[a-z][\w-]*(?:\([^)]*\))?(?:\.[a-z][\w-]*(?:\([^)]*\))?|\[[^\]]+\])*|\{[^}]+\})/i,
-            lookbehind: true,
-            inside: {}
-            // See below
-          },
-          string: {
-            pattern: /"[^"]*"|'[^']*'/,
-            greedy: true
-          },
-          number: /\b\d+\b/,
-          boolean: /\b(?:false|true)\b/,
-          operator: /[=!<>]=?|[+*/%-]|&&|\|\||\.\.|\b(?:eq|g[et]|l[et]|n(?:e|ot))\b/,
-          punctuation: /[(){}[\]:,.]/
-        };
-        velocity2.variable.inside = {
-          string: velocity2["string"],
-          function: {
-            pattern: /([^\w-])[a-z][\w-]*(?=\()/,
-            lookbehind: true
-          },
-          number: velocity2["number"],
-          boolean: velocity2["boolean"],
-          punctuation: velocity2["punctuation"]
-        };
-        Prism2.languages.insertBefore("velocity", "comment", {
-          unparsed: {
-            pattern: /(^|[^\\])#\[\[[\s\S]*?\]\]#/,
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              punctuation: /^#\[\[|\]\]#$/
-            }
-          },
-          "velocity-comment": [
-            {
-              pattern: /(^|[^\\])#\*[\s\S]*?\*#/,
-              lookbehind: true,
-              greedy: true,
-              alias: "comment"
-            },
-            {
-              pattern: /(^|[^\\])##.*/,
-              lookbehind: true,
-              greedy: true,
-              alias: "comment"
-            }
-          ],
-          directive: {
-            pattern: /(^|[^\\](?:\\\\)*)#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})(?:\s*\((?:[^()]|\([^()]*\))*\))?/i,
-            lookbehind: true,
-            inside: {
-              keyword: {
-                pattern: /^#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})|\bin\b/,
-                inside: {
-                  punctuation: /[{}]/
-                }
-              },
-              rest: velocity2
-            }
-          },
-          variable: velocity2["variable"]
-        });
-        Prism2.languages.velocity["tag"].inside["attr-value"].inside.rest = Prism2.languages.velocity;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_velocity
-};

package/dist/chunk-2OZIJ3G7.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-2Q77FUPY.js

@@ -1,39 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bnf.js
-var require_bnf = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bnf.js"(exports, module) {
-    module.exports = bnf;
-    bnf.displayName = "bnf";
-    bnf.aliases = ["rbnf"];
-    function bnf(Prism) {
-      Prism.languages.bnf = {
-        string: {
-          pattern: /"[^\r\n"]*"|'[^\r\n']*'/
-        },
-        definition: {
-          pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
-          alias: ["rule", "keyword"],
-          inside: {
-            punctuation: /^<|>$/
-          }
-        },
-        rule: {
-          pattern: /<[^<>\r\n\t]+>/,
-          inside: {
-            punctuation: /^<|>$/
-          }
-        },
-        operator: /::=|[|()[\]{}*+?]|\.{3}/
-      };
-      Prism.languages.rbnf = Prism.languages.bnf;
-    }
-  }
-});
-
-export {
-  require_bnf
-};

package/dist/chunk-2RJEAAD5.js

@@ -1,132 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scheme.js
-var require_scheme = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scheme.js"(exports, module) {
-    module.exports = scheme;
-    scheme.displayName = "scheme";
-    scheme.aliases = [];
-    function scheme(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.scheme = {
-          // this supports "normal" single-line comments:
-          //   ; comment
-          // and (potentially nested) multiline comments:
-          //   #| comment #| nested |# still comment |#
-          // (only 1 level of nesting is supported)
-          comment: /;.*|#;\s*(?:\((?:[^()]|\([^()]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\])|#\|(?:[^#|]|#(?!\|)|\|(?!#)|#\|(?:[^#|]|#(?!\|)|\|(?!#))*\|#)*\|#/,
-          string: {
-            pattern: /"(?:[^"\\]|\\.)*"/,
-            greedy: true
-          },
-          symbol: {
-            pattern: /'[^()\[\]#'\s]+/,
-            greedy: true
-          },
-          char: {
-            pattern: /#\\(?:[ux][a-fA-F\d]+\b|[-a-zA-Z]+\b|[\uD800-\uDBFF][\uDC00-\uDFFF]|\S)/,
-            greedy: true
-          },
-          "lambda-parameter": [
-            // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30
-            {
-              pattern: /((?:^|[^'`#])[(\[]lambda\s+)(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)/,
-              lookbehind: true
-            },
-            {
-              pattern: /((?:^|[^'`#])[(\[]lambda\s+[(\[])[^()\[\]']+/,
-              lookbehind: true
-            }
-          ],
-          keyword: {
-            pattern: /((?:^|[^'`#])[(\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\*)?|let\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          builtin: {
-            // all functions of the base library of R7RS plus some of built-ins of R5Rs
-            pattern: /((?:^|[^'`#])[(\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\?|boolean=?\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\?|\?|<\?|<=\?|=\?|>\?|>=\?)|close-(?:input-port|output-port|port)|complex\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\??|eq\?|equal\?|eqv\?|error|error-object(?:-irritants|-message|\?)|eval|even\?|exact(?:-integer-sqrt|-integer\?|\?)?|expt|features|file-error\?|floor(?:-quotient|-remainder|\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\??|input-port(?:-open\?|\?)|integer(?:->char|\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\?|newline|not|null\?|number(?:->string|\?)|numerator|odd\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\?|\?)|pair\?|peek-char|peek-u8|port\?|positive\?|procedure\?|quotient|raise|raise-continuable|rational\?|rationalize|read-(?:bytevector|bytevector!|char|error\?|line|string|u8)|real\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?|<\?|<=\?|=\?|>\?|>=\?)?|substring|symbol(?:->string|\?|=\?)|syntax-error|textual-port\?|truncate(?:-quotient|-remainder|\/)?|u8-ready\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\?)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          operator: {
-            pattern: /((?:^|[^'`#])[(\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          number: {
-            // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).
-            //
-            // <number>      := <num 2>|<num 8>|<num 10>|<num 16>
-            // <num R>       := <prefix R><complex R>
-            // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>
-            // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\.0)?i
-            // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\.0
-            // <ureal R>     := <uint R>(?:\/<uint R>)?
-            //                | <decimal R>
-            //
-            // <decimal 10>  := (?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?
-            // <uint R>      := <digit R>+
-            // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>
-            // <radix 2>     := #b
-            // <radix 8>     := #o
-            // <radix 10>    := (?:#d)?
-            // <radix 16>    := #x
-            // <digit 2>     := [01]
-            // <digit 8>     := [0-7]
-            // <digit 10>    := \d
-            // <digit 16>    := [0-9a-f]
-            //
-            // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all
-            // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)
-            // pattern:
-            pattern: RegExp(
-              SortedBNF({
-                "<ureal dec>": /\d+(?:\/\d+)|(?:\d+(?:\.\d*)?|\.\d+)(?:[esfdl][+-]?\d+)?/.source,
-                "<real dec>": /[+-]?<ureal dec>|[+-](?:inf|nan)\.0/.source,
-                "<imaginary dec>": /[+-](?:<ureal dec>|(?:inf|nan)\.0)?i/.source,
-                "<complex dec>": /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/.source,
-                "<num dec>": /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,
-                "<ureal box>": /[0-9a-f]+(?:\/[0-9a-f]+)?/.source,
-                "<real box>": /[+-]?<ureal box>|[+-](?:inf|nan)\.0/.source,
-                "<imaginary box>": /[+-](?:<ureal box>|(?:inf|nan)\.0)?i/.source,
-                "<complex box>": /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/.source,
-                "<num box>": /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/.source,
-                "<number>": /(^|[()\[\]\s])(?:<num dec>|<num box>)(?=[()\[\]\s]|$)/.source
-              }),
-              "i"
-            ),
-            lookbehind: true
-          },
-          boolean: {
-            pattern: /(^|[()\[\]\s])#(?:[ft]|false|true)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          function: {
-            pattern: /((?:^|[^'`#])[(\[])(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          identifier: {
-            pattern: /(^|[()\[\]\s])\|(?:[^\\|]|\\.)*\|(?=[()\[\]\s]|$)/,
-            lookbehind: true,
-            greedy: true
-          },
-          punctuation: /[()\[\]']/
-        };
-        function SortedBNF(grammar) {
-          for (var key in grammar) {
-            grammar[key] = grammar[key].replace(/<[\w\s]+>/g, function(key2) {
-              return "(?:" + grammar[key2].trim() + ")";
-            });
-          }
-          return grammar[key];
-        }
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_scheme
-};

package/dist/chunk-2WWHQC2T.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-32BGMHI3.js

@@ -1,75 +0,0 @@
-"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/aspnet.js
-var require_aspnet = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/aspnet.js"(exports, module) {
-    var refractorCsharp = require_csharp();
-    module.exports = aspnet;
-    aspnet.displayName = "aspnet";
-    aspnet.aliases = [];
-    function aspnet(Prism) {
-      Prism.register(refractorCsharp);
-      Prism.languages.aspnet = Prism.languages.extend("markup", {
-        "page-directive": {
-          pattern: /<%\s*@.*%>/,
-          alias: "tag",
-          inside: {
-            "page-directive": {
-              pattern: /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
-              alias: "tag"
-            },
-            rest: Prism.languages.markup.tag.inside
-          }
-        },
-        directive: {
-          pattern: /<%.*%>/,
-          alias: "tag",
-          inside: {
-            directive: {
-              pattern: /<%\s*?[$=%#:]{0,2}|%>/,
-              alias: "tag"
-            },
-            rest: Prism.languages.csharp
-          }
-        }
-      });
-      Prism.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
-      Prism.languages.insertBefore(
-        "inside",
-        "punctuation",
-        {
-          directive: Prism.languages.aspnet["directive"]
-        },
-        Prism.languages.aspnet.tag.inside["attr-value"]
-      );
-      Prism.languages.insertBefore("aspnet", "comment", {
-        "asp-comment": {
-          pattern: /<%--[\s\S]*?--%>/,
-          alias: ["asp", "comment"]
-        }
-      });
-      Prism.languages.insertBefore(
-        "aspnet",
-        Prism.languages.javascript ? "script" : "tag",
-        {
-          "asp-script": {
-            pattern: /(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
-            lookbehind: true,
-            alias: ["asp", "script"],
-            inside: Prism.languages.csharp || {}
-          }
-        }
-      );
-    }
-  }
-});
-
-export {
-  require_aspnet
-};

package/dist/chunk-33ATF6VZ.js

@@ -1,71 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/typescript.js
-var require_typescript = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/typescript.js"(exports, module) {
-    module.exports = typescript;
-    typescript.displayName = "typescript";
-    typescript.aliases = ["ts"];
-    function typescript(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.typescript = Prism2.languages.extend("javascript", {
-          "class-name": {
-            pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
-            lookbehind: true,
-            greedy: true,
-            inside: null
-            // see below
-          },
-          builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
-        });
-        Prism2.languages.typescript.keyword.push(
-          /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
-          // keywords that have to be followed by an identifier
-          /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
-          // This is for `import type *, {}`
-          /\btype\b(?=\s*(?:[\{*]|$))/
-        );
-        delete Prism2.languages.typescript["parameter"];
-        delete Prism2.languages.typescript["literal-property"];
-        var typeInside = Prism2.languages.extend("typescript", {});
-        delete typeInside["class-name"];
-        Prism2.languages.typescript["class-name"].inside = typeInside;
-        Prism2.languages.insertBefore("typescript", "function", {
-          decorator: {
-            pattern: /@[$\w\xA0-\uFFFF]+/,
-            inside: {
-              at: {
-                pattern: /^@/,
-                alias: "operator"
-              },
-              function: /^[\s\S]+/
-            }
-          },
-          "generic-function": {
-            // e.g. foo<T extends "bar" | "baz">( ...
-            pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
-            greedy: true,
-            inside: {
-              function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
-              generic: {
-                pattern: /<[\s\S]+/,
-                // everything after the first <
-                alias: "class-name",
-                inside: typeInside
-              }
-            }
-          }
-        });
-        Prism2.languages.ts = Prism2.languages.typescript;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_typescript
-};