@distri/react 0.2.7 → 0.3.0

package/dist/chunk-YPI6DSCZ.js

@@ -0,0 +1,70 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/turtle.js
+var require_turtle = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/turtle.js"(exports, module) {
+    module.exports = turtle;
+    turtle.displayName = "turtle";
+    turtle.aliases = [];
+    function turtle(Prism) {
+      Prism.languages.turtle = {
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        "multiline-string": {
+          pattern: /"""(?:(?:""?)?(?:[^"\\]|\\.))*"""|'''(?:(?:''?)?(?:[^'\\]|\\.))*'''/,
+          greedy: true,
+          alias: "string",
+          inside: {
+            comment: /#.*/
+          }
+        },
+        string: {
+          pattern: /"(?:[^\\"\r\n]|\\.)*"|'(?:[^\\'\r\n]|\\.)*'/,
+          greedy: true
+        },
+        url: {
+          pattern: /<(?:[^\x00-\x20<>"{}|^`\\]|\\(?:u[\da-fA-F]{4}|U[\da-fA-F]{8}))*>/,
+          greedy: true,
+          inside: {
+            punctuation: /[<>]/
+          }
+        },
+        function: {
+          pattern: /(?:(?![-.\d\xB7])[-.\w\xB7\xC0-\uFFFD]+)?:(?:(?![-.])(?:[-.:\w\xC0-\uFFFD]|%[\da-f]{2}|\\.)+)?/i,
+          inside: {
+            "local-name": {
+              pattern: /([^:]*:)[\s\S]+/,
+              lookbehind: true
+            },
+            prefix: {
+              pattern: /[\s\S]+/,
+              inside: {
+                punctuation: /:/
+              }
+            }
+          }
+        },
+        number: /[+-]?\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+        punctuation: /[{}.,;()[\]]|\^\^/,
+        boolean: /\b(?:false|true)\b/,
+        keyword: [/(?:\ba|@prefix|@base)\b|=/, /\b(?:base|graph|prefix)\b/i],
+        tag: {
+          pattern: /@[a-z]+(?:-[a-z\d]+)*/i,
+          inside: {
+            punctuation: /@/
+          }
+        }
+      };
+      Prism.languages.trig = Prism.languages["turtle"];
+    }
+  }
+});
+
+export {
+  require_turtle
+};

package/dist/chunk-YRU55K5G.js

@@ -0,0 +1,84 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/maxscript.js
+var require_maxscript = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/maxscript.js"(exports, module) {
+    module.exports = maxscript;
+    maxscript.displayName = "maxscript";
+    maxscript.aliases = [];
+    function maxscript(Prism) {
+      ;
+      (function(Prism2) {
+        var keywords = /\b(?:about|and|animate|as|at|attributes|by|case|catch|collect|continue|coordsys|do|else|exit|fn|for|from|function|global|if|in|local|macroscript|mapped|max|not|of|off|on|or|parameters|persistent|plugin|rcmenu|return|rollout|set|struct|then|throw|to|tool|try|undo|utility|when|where|while|with)\b/i;
+        Prism2.languages.maxscript = {
+          comment: {
+            pattern: /\/\*[\s\S]*?(?:\*\/|$)|--.*/,
+            greedy: true
+          },
+          string: {
+            pattern: /(^|[^"\\@])(?:"(?:[^"\\]|\\[\s\S])*"|@"[^"]*")/,
+            lookbehind: true,
+            greedy: true
+          },
+          path: {
+            pattern: /\$(?:[\w/\\.*?]|'[^']*')*/,
+            greedy: true,
+            alias: "string"
+          },
+          "function-call": {
+            pattern: RegExp(
+              "((?:" + // start of line
+              (/^/.source + "|" + // operators and other language constructs
+              /[;=<>+\-*/^({\[]/.source + "|" + // keywords as part of statements
+              /\b(?:and|by|case|catch|collect|do|else|if|in|not|or|return|then|to|try|where|while|with)\b/.source) + ")[ 	]*)(?!" + keywords.source + ")" + /[a-z_]\w*\b/.source + "(?=[ 	]*(?:" + // variable
+              ("(?!" + keywords.source + ")" + /[a-z_]/.source + "|" + // number
+              /\d|-\.?\d/.source + "|" + // other expressions or literals
+              /[({'"$@#?]/.source) + "))",
+              "im"
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "function"
+          },
+          "function-definition": {
+            pattern: /(\b(?:fn|function)\s+)\w+\b/i,
+            lookbehind: true,
+            alias: "function"
+          },
+          argument: {
+            pattern: /\b[a-z_]\w*(?=:)/i,
+            alias: "attr-name"
+          },
+          keyword: keywords,
+          boolean: /\b(?:false|true)\b/,
+          time: {
+            pattern: /(^|[^\w.])(?:(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eEdD][+-]\d+|[LP])?[msft])+|\d+:\d+(?:\.\d*)?)(?![\w.:])/,
+            lookbehind: true,
+            alias: "number"
+          },
+          number: [
+            {
+              pattern: /(^|[^\w.])(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eEdD][+-]\d+|[LP])?|0x[a-fA-F0-9]+)(?![\w.:])/,
+              lookbehind: true
+            },
+            /\b(?:e|pi)\b/
+          ],
+          constant: /\b(?:dontcollect|ok|silentValue|undefined|unsupplied)\b/,
+          color: {
+            pattern: /\b(?:black|blue|brown|gray|green|orange|red|white|yellow)\b/i,
+            alias: "constant"
+          },
+          operator: /[-+*/<>=!]=?|[&^?]|#(?!\()/,
+          punctuation: /[()\[\]{}.:,;]|#(?=\()|\\$/m
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_maxscript
+};

package/dist/chunk-YS7PQUUJ.js

@@ -0,0 +1,75 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/powershell.js
+var require_powershell = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/powershell.js"(exports, module) {
+    module.exports = powershell;
+    powershell.displayName = "powershell";
+    powershell.aliases = [];
+    function powershell(Prism) {
+      ;
+      (function(Prism2) {
+        var powershell2 = Prism2.languages.powershell = {
+          comment: [
+            {
+              pattern: /(^|[^`])<#[\s\S]*?#>/,
+              lookbehind: true
+            },
+            {
+              pattern: /(^|[^`])#.*/,
+              lookbehind: true
+            }
+          ],
+          string: [
+            {
+              pattern: /"(?:`[\s\S]|[^`"])*"/,
+              greedy: true,
+              inside: null
+              // see below
+            },
+            {
+              pattern: /'(?:[^']|'')*'/,
+              greedy: true
+            }
+          ],
+          // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
+          // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)
+          namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
+          boolean: /\$(?:false|true)\b/i,
+          variable: /\$\w+\b/,
+          // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
+          // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
+          // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
+          function: [
+            /\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i,
+            /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i
+          ],
+          // per http://technet.microsoft.com/en-us/library/hh847744.aspx
+          keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
+          operator: {
+            pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
+            lookbehind: true
+          },
+          punctuation: /[|{}[\];(),.]/
+        };
+        powershell2.string[0].inside = {
+          function: {
+            // Allow for one level of nesting
+            pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
+            lookbehind: true,
+            inside: powershell2
+          },
+          boolean: powershell2.boolean,
+          variable: powershell2.variable
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_powershell
+};

package/dist/chunk-YST6AG5L.js

@@ -0,0 +1,96 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scss.js
+var require_scss = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scss.js"(exports, module) {
+    module.exports = scss;
+    scss.displayName = "scss";
+    scss.aliases = [];
+    function scss(Prism) {
+      Prism.languages.scss = Prism.languages.extend("css", {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+          lookbehind: true
+        },
+        atrule: {
+          pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+          inside: {
+            rule: /@[\w-]+/
+            // See rest below
+          }
+        },
+        // url, compassified
+        url: /(?:[-a-z]+-)?url(?=\()/i,
+        // CSS selector regex is not appropriate for Sass
+        // since there can be lot more things (var, @ directive, nesting..)
+        // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+        // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+        // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+        // can "pass" as a selector- e.g: proper#{$erty})
+        // this one was hard to do, so please be careful if you edit this one :)
+        selector: {
+          // Initial look-ahead is used to prevent matching of blank selectors
+          pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+          inside: {
+            parent: {
+              pattern: /&/,
+              alias: "important"
+            },
+            placeholder: /%[-\w]+/,
+            variable: /\$[-\w]+|#\{\$[-\w]+\}/
+          }
+        },
+        property: {
+          pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+          inside: {
+            variable: /\$[-\w]+|#\{\$[-\w]+\}/
+          }
+        }
+      });
+      Prism.languages.insertBefore("scss", "atrule", {
+        keyword: [
+          /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
+          {
+            pattern: /( )(?:from|through)(?= )/,
+            lookbehind: true
+          }
+        ]
+      });
+      Prism.languages.insertBefore("scss", "important", {
+        // var and interpolated vars
+        variable: /\$[-\w]+|#\{\$[-\w]+\}/
+      });
+      Prism.languages.insertBefore("scss", "function", {
+        "module-modifier": {
+          pattern: /\b(?:as|hide|show|with)\b/i,
+          alias: "keyword"
+        },
+        placeholder: {
+          pattern: /%[-\w]+/,
+          alias: "selector"
+        },
+        statement: {
+          pattern: /\B!(?:default|optional)\b/i,
+          alias: "keyword"
+        },
+        boolean: /\b(?:false|true)\b/,
+        null: {
+          pattern: /\bnull\b/,
+          alias: "keyword"
+        },
+        operator: {
+          pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
+          lookbehind: true
+        }
+      });
+      Prism.languages.scss["atrule"].inside.rest = Prism.languages.scss;
+    }
+  }
+});
+
+export {
+  require_scss
+};

package/dist/chunk-YTXJD5GL.js

@@ -0,0 +1,115 @@
+"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/soy.js
+var require_soy = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/soy.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = soy;
+    soy.displayName = "soy";
+    soy.aliases = [];
+    function soy(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        var stringPattern = /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+        var numberPattern = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-F]+\b/;
+        Prism2.languages.soy = {
+          comment: [
+            /\/\*[\s\S]*?\*\//,
+            {
+              pattern: /(\s)\/\/.*/,
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          "command-arg": {
+            pattern: /(\{+\/?\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\s+)\.?[\w.]+/,
+            lookbehind: true,
+            alias: "string",
+            inside: {
+              punctuation: /\./
+            }
+          },
+          parameter: {
+            pattern: /(\{+\/?\s*@?param\??\s+)\.?[\w.]+/,
+            lookbehind: true,
+            alias: "variable"
+          },
+          keyword: [
+            {
+              pattern: /(\{+\/?[^\S\r\n]*)(?:\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\??|rb|sp|switch|template|xid)/,
+              lookbehind: true
+            },
+            /\b(?:any|as|attributes|bool|css|float|html|in|int|js|list|map|null|number|string|uri)\b/
+          ],
+          delimiter: {
+            pattern: /^\{+\/?|\/?\}+$/,
+            alias: "punctuation"
+          },
+          property: /\w+(?==)/,
+          variable: {
+            pattern: /\$[^\W\d]\w*(?:\??(?:\.\w+|\[[^\]]+\]))*/,
+            inside: {
+              string: {
+                pattern: stringPattern,
+                greedy: true
+              },
+              number: numberPattern,
+              punctuation: /[\[\].?]/
+            }
+          },
+          string: {
+            pattern: stringPattern,
+            greedy: true
+          },
+          function: [
+            /\w+(?=\()/,
+            {
+              pattern: /(\|[^\S\r\n]*)\w+/,
+              lookbehind: true
+            }
+          ],
+          boolean: /\b(?:false|true)\b/,
+          number: numberPattern,
+          operator: /\?:?|<=?|>=?|==?|!=|[+*/%-]|\b(?:and|not|or)\b/,
+          punctuation: /[{}()\[\]|.,:]/
+        };
+        Prism2.hooks.add("before-tokenize", function(env) {
+          var soyPattern = /\{\{.+?\}\}|\{.+?\}|\s\/\/.*|\/\*[\s\S]*?\*\//g;
+          var soyLitteralStart = "{literal}";
+          var soyLitteralEnd = "{/literal}";
+          var soyLitteralMode = false;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "soy",
+            soyPattern,
+            function(match) {
+              if (match === soyLitteralEnd) {
+                soyLitteralMode = false;
+              }
+              if (!soyLitteralMode) {
+                if (match === soyLitteralStart) {
+                  soyLitteralMode = true;
+                }
+                return true;
+              }
+              return false;
+            }
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "soy");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_soy
+};

package/dist/chunk-YX5EOMYE.js

@@ -0,0 +1,146 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsx.js
+var require_jsx = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsx.js"(exports, module) {
+    module.exports = jsx;
+    jsx.displayName = "jsx";
+    jsx.aliases = [];
+    function jsx(Prism) {
+      ;
+      (function(Prism2) {
+        var javascript = Prism2.util.clone(Prism2.languages.javascript);
+        var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
+        var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
+        var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+        function re(source, flags) {
+          source = source.replace(/<S>/g, function() {
+            return space;
+          }).replace(/<BRACES>/g, function() {
+            return braces;
+          }).replace(/<SPREAD>/g, function() {
+            return spread;
+          });
+          return RegExp(source, flags);
+        }
+        spread = re(spread).source;
+        Prism2.languages.jsx = Prism2.languages.extend("markup", javascript);
+        Prism2.languages.jsx.tag.pattern = re(
+          /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
+        );
+        Prism2.languages.jsx.tag.inside["tag"].pattern = /^<\/?[^\s>\/]*/;
+        Prism2.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
+        Prism2.languages.jsx.tag.inside["tag"].inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
+        Prism2.languages.jsx.tag.inside["comment"] = javascript["comment"];
+        Prism2.languages.insertBefore(
+          "inside",
+          "attr-name",
+          {
+            spread: {
+              pattern: re(/<SPREAD>/.source),
+              inside: Prism2.languages.jsx
+            }
+          },
+          Prism2.languages.jsx.tag
+        );
+        Prism2.languages.insertBefore(
+          "inside",
+          "special-attr",
+          {
+            script: {
+              // Allow for two levels of nesting
+              pattern: re(/=<BRACES>/.source),
+              alias: "language-javascript",
+              inside: {
+                "script-punctuation": {
+                  pattern: /^=(?=\{)/,
+                  alias: "punctuation"
+                },
+                rest: Prism2.languages.jsx
+              }
+            }
+          },
+          Prism2.languages.jsx.tag
+        );
+        var stringifyToken = function(token) {
+          if (!token) {
+            return "";
+          }
+          if (typeof token === "string") {
+            return token;
+          }
+          if (typeof token.content === "string") {
+            return token.content;
+          }
+          return token.content.map(stringifyToken).join("");
+        };
+        var walkTokens = function(tokens) {
+          var openedTags = [];
+          for (var i = 0; i < tokens.length; i++) {
+            var token = tokens[i];
+            var notTagNorBrace = false;
+            if (typeof token !== "string") {
+              if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") {
+                if (token.content[0].content[0].content === "</") {
+                  if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
+                    openedTags.pop();
+                  }
+                } else {
+                  if (token.content[token.content.length - 1].content === "/>") {
+                  } else {
+                    openedTags.push({
+                      tagName: stringifyToken(token.content[0].content[1]),
+                      openedBraces: 0
+                    });
+                  }
+                }
+              } else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{") {
+                openedTags[openedTags.length - 1].openedBraces++;
+              } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") {
+                openedTags[openedTags.length - 1].openedBraces--;
+              } else {
+                notTagNorBrace = true;
+              }
+            }
+            if (notTagNorBrace || typeof token === "string") {
+              if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+                var plainText = stringifyToken(token);
+                if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
+                  plainText += stringifyToken(tokens[i + 1]);
+                  tokens.splice(i + 1, 1);
+                }
+                if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
+                  plainText = stringifyToken(tokens[i - 1]) + plainText;
+                  tokens.splice(i - 1, 1);
+                  i--;
+                }
+                tokens[i] = new Prism2.Token(
+                  "plain-text",
+                  plainText,
+                  null,
+                  plainText
+                );
+              }
+            }
+            if (token.content && typeof token.content !== "string") {
+              walkTokens(token.content);
+            }
+          }
+        };
+        Prism2.hooks.add("after-tokenize", function(env) {
+          if (env.language !== "jsx" && env.language !== "tsx") {
+            return;
+          }
+          walkTokens(env.tokens);
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_jsx
+};

package/dist/chunk-YY7FQURC.js

@@ -0,0 +1,49 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/makefile.js
+var require_makefile = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/makefile.js"(exports, module) {
+    module.exports = makefile;
+    makefile.displayName = "makefile";
+    makefile.aliases = [];
+    function makefile(Prism) {
+      Prism.languages.makefile = {
+        comment: {
+          pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+          lookbehind: true
+        },
+        string: {
+          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        },
+        "builtin-target": {
+          pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+          alias: "builtin"
+        },
+        target: {
+          pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+          alias: "symbol",
+          inside: {
+            variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+          }
+        },
+        variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+        // Directives
+        keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+        function: {
+          pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+          lookbehind: true
+        },
+        operator: /(?:::|[?:+!])?=|[|@]/,
+        punctuation: /[:;(){}]/
+      };
+    }
+  }
+});
+
+export {
+  require_makefile
+};

package/dist/chunk-Z7PWFZG5.js

@@ -0,0 +1,31 @@
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};