@distri/react 0.3.1 → 0.3.3

package/dist/chunk-RDF5QBXB.js

@@ -0,0 +1,44 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/json.js
+var require_json = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/json.js"(exports, module) {
+    module.exports = json;
+    json.displayName = "json";
+    json.aliases = ["webmanifest"];
+    function json(Prism) {
+      Prism.languages.json = {
+        property: {
+          pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+          lookbehind: true,
+          greedy: true
+        },
+        string: {
+          pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+          lookbehind: true,
+          greedy: true
+        },
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+          greedy: true
+        },
+        number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        punctuation: /[{}[\],]/,
+        operator: /:/,
+        boolean: /\b(?:false|true)\b/,
+        null: {
+          pattern: /\bnull\b/,
+          alias: "keyword"
+        }
+      };
+      Prism.languages.webmanifest = Prism.languages.json;
+    }
+  }
+});
+
+export {
+  require_json
+};

package/dist/chunk-RGS24K3W.js

@@ -0,0 +1,116 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/elixir.js
+var require_elixir = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/elixir.js"(exports, module) {
+    module.exports = elixir;
+    elixir.displayName = "elixir";
+    elixir.aliases = [];
+    function elixir(Prism) {
+      Prism.languages.elixir = {
+        doc: {
+          pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
+          inside: {
+            attribute: /^@\w+/,
+            string: /['"][\s\S]+/
+          }
+        },
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
+        regex: {
+          pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
+          greedy: true
+        },
+        string: [
+          {
+            // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
+            pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
+            greedy: true,
+            inside: {
+              // See interpolation below
+            }
+          },
+          {
+            pattern: /("""|''')[\s\S]*?\1/,
+            greedy: true,
+            inside: {
+              // See interpolation below
+            }
+          },
+          {
+            // Multi-line strings are allowed
+            pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+            greedy: true,
+            inside: {
+              // See interpolation below
+            }
+          }
+        ],
+        atom: {
+          // Look-behind prevents bad highlighting of the :: operator
+          pattern: /(^|[^:]):\w+/,
+          lookbehind: true,
+          alias: "symbol"
+        },
+        module: {
+          pattern: /\b[A-Z]\w*\b/,
+          alias: "class-name"
+        },
+        // Look-ahead prevents bad highlighting of the :: operator
+        "attr-name": /\b\w+\??:(?!:)/,
+        argument: {
+          // Look-behind prevents bad highlighting of the && operator
+          pattern: /(^|[^&])&\d+/,
+          lookbehind: true,
+          alias: "variable"
+        },
+        attribute: {
+          pattern: /@\w+/,
+          alias: "variable"
+        },
+        function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
+        number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
+        keyword: /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
+        boolean: /\b(?:false|nil|true)\b/,
+        operator: [
+          /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
+          {
+            // We don't want to match <<
+            pattern: /([^<])<(?!<)/,
+            lookbehind: true
+          },
+          {
+            // We don't want to match >>
+            pattern: /([^>])>(?!>)/,
+            lookbehind: true
+          }
+        ],
+        punctuation: /<<|>>|[.,%\[\]{}()]/
+      };
+      Prism.languages.elixir.string.forEach(function(o) {
+        o.inside = {
+          interpolation: {
+            pattern: /#\{[^}]+\}/,
+            inside: {
+              delimiter: {
+                pattern: /^#\{|\}$/,
+                alias: "punctuation"
+              },
+              rest: Prism.languages.elixir
+            }
+          }
+        };
+      });
+    }
+  }
+});
+
+export {
+  require_elixir
+};

package/dist/chunk-RKDF6JST.js

@@ -0,0 +1,30 @@
+"use client";
+import {
+  require_json
+} from "./chunk-RDF5QBXB.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsonp.js
+var require_jsonp = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsonp.js"(exports, module) {
+    var refractorJson = require_json();
+    module.exports = jsonp;
+    jsonp.displayName = "jsonp";
+    jsonp.aliases = [];
+    function jsonp(Prism) {
+      Prism.register(refractorJson);
+      Prism.languages.jsonp = Prism.languages.extend("json", {
+        punctuation: /[{}[\]();,.]/
+      });
+      Prism.languages.insertBefore("jsonp", "punctuation", {
+        function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/
+      });
+    }
+  }
+});
+
+export {
+  require_jsonp
+};

package/dist/chunk-RM2ULDSD.js

@@ -0,0 +1,94 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/fsharp.js
+var require_fsharp = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/fsharp.js"(exports, module) {
+    module.exports = fsharp;
+    fsharp.displayName = "fsharp";
+    fsharp.aliases = [];
+    function fsharp(Prism) {
+      Prism.languages.fsharp = Prism.languages.extend("clike", {
+        comment: [
+          {
+            pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(\b(?:exception|inherit|interface|new|of|type)\s+|\w\s*:\s*|\s:\??>\s*)[.\w]+\b(?:\s*(?:->|\*)\s*[.\w]+\b)*(?!\s*[:.])/,
+          lookbehind: true,
+          inside: {
+            operator: /->|\*/,
+            punctuation: /\./
+          }
+        },
+        keyword: /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/,
+        number: [
+          /\b0x[\da-fA-F]+(?:LF|lf|un)?\b/,
+          /\b0b[01]+(?:uy|y)?\b/,
+          /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
+          /\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
+        ],
+        operator: /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
+      });
+      Prism.languages.insertBefore("fsharp", "keyword", {
+        preprocessor: {
+          pattern: /(^[\t ]*)#.*/m,
+          lookbehind: true,
+          alias: "property",
+          inside: {
+            directive: {
+              pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/,
+              lookbehind: true,
+              alias: "keyword"
+            }
+          }
+        }
+      });
+      Prism.languages.insertBefore("fsharp", "punctuation", {
+        "computation-expression": {
+          pattern: /\b[_a-z]\w*(?=\s*\{)/i,
+          alias: "keyword"
+        }
+      });
+      Prism.languages.insertBefore("fsharp", "string", {
+        annotation: {
+          pattern: /\[<.+?>\]/,
+          greedy: true,
+          inside: {
+            punctuation: /^\[<|>\]$/,
+            "class-name": {
+              pattern: /^\w+$|(^|;\s*)[A-Z]\w*(?=\()/,
+              lookbehind: true
+            },
+            "annotation-content": {
+              pattern: /[\s\S]+/,
+              inside: Prism.languages.fsharp
+            }
+          }
+        },
+        char: {
+          pattern: /'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
+          greedy: true
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_fsharp
+};

package/dist/chunk-RNK6SZJU.js

@@ -0,0 +1,47 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/visual-basic.js
+var require_visual_basic = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/visual-basic.js"(exports, module) {
+    module.exports = visualBasic;
+    visualBasic.displayName = "visualBasic";
+    visualBasic.aliases = [];
+    function visualBasic(Prism) {
+      Prism.languages["visual-basic"] = {
+        comment: {
+          pattern: /(?:['‘’]|REM\b)(?:[^\r\n_]|_(?:\r\n?|\n)?)*/i,
+          inside: {
+            keyword: /^REM/i
+          }
+        },
+        directive: {
+          pattern: /#(?:Const|Else|ElseIf|End|ExternalChecksum|ExternalSource|If|Region)(?:\b_[ \t]*(?:\r\n?|\n)|.)+/i,
+          alias: "property",
+          greedy: true
+        },
+        string: {
+          pattern: /\$?["“”](?:["“”]{2}|[^"“”])*["“”]C?/i,
+          greedy: true
+        },
+        date: {
+          pattern: /#[ \t]*(?:\d+([/-])\d+\1\d+(?:[ \t]+(?:\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?))?|\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?)[ \t]*#/i,
+          alias: "number"
+        },
+        number: /(?:(?:\b\d+(?:\.\d+)?|\.\d+)(?:E[+-]?\d+)?|&[HO][\dA-F]+)(?:[FRD]|U?[ILS])?/i,
+        boolean: /\b(?:False|Nothing|True)\b/i,
+        keyword: /\b(?:AddHandler|AddressOf|Alias|And(?:Also)?|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|C(?:Bool|Byte|Char|Date|Dbl|Dec|Int|Lng|Obj|SByte|Short|Sng|Str|Type|UInt|ULng|UShort)|Char|Class|Const|Continue|Currency|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else(?:If)?|End(?:If)?|Enum|Erase|Error|Event|Exit|Finally|For|Friend|Function|Get(?:Type|XMLNamespace)?|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|Must(?:Inherit|Override)|My(?:Base|Class)|Namespace|Narrowing|New|Next|Not(?:Inheritable|Overridable)?|Object|Of|On|Operator|Option(?:al)?|Or(?:Else)?|Out|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|Try|TryCast|Type|TypeOf|U(?:Integer|Long|Short)|Until|Using|Variant|Wend|When|While|Widening|With(?:Events)?|WriteOnly|Xor)\b/i,
+        operator: /[+\-*/\\^<=>&#@$%!]|\b_(?=[ \t]*[\r\n])/,
+        punctuation: /[{}().,:?]/
+      };
+      Prism.languages.vb = Prism.languages["visual-basic"];
+      Prism.languages.vba = Prism.languages["visual-basic"];
+    }
+  }
+});
+
+export {
+  require_visual_basic
+};

package/dist/chunk-RRRLL4DX.js

@@ -0,0 +1,82 @@
+"use client";
+import {
+  require_bash
+} from "./chunk-UXDI4352.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/shell-session.js
+var require_shell_session = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/shell-session.js"(exports, module) {
+    var refractorBash = require_bash();
+    module.exports = shellSession;
+    shellSession.displayName = "shellSession";
+    shellSession.aliases = [];
+    function shellSession(Prism) {
+      Prism.register(refractorBash);
+      (function(Prism2) {
+        var strings = [
+          // normal string
+          /"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source,
+          /'[^']*'/.source,
+          /\$'(?:[^'\\]|\\[\s\S])*'/.source,
+          // here doc
+          // 2 capturing groups
+          /<<-?\s*(["']?)(\w+)\1\s[\s\S]*?[\r\n]\2/.source
+        ].join("|");
+        Prism2.languages["shell-session"] = {
+          command: {
+            pattern: RegExp(
+              // user info
+              /^/.source + "(?:" + // <user> ":" ( <path> )?
+              (/[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+(?::[^\0-\x1F$#%*?"<>:;|]+)?/.source + "|" + // <path>
+              // Since the path pattern is quite general, we will require it to start with a special character to
+              // prevent false positives.
+              /[/~.][^\0-\x1F$#%*?"<>@:;|]*/.source) + ")?" + // shell symbol
+              /[$#%](?=\s)/.source + // bash command
+              /(?:[^\\\r\n \t'"<$]|[ \t](?:(?!#)|#.*$)|\\(?:[^\r]|\r\n?)|\$(?!')|<(?!<)|<<str>>)+/.source.replace(
+                /<<str>>/g,
+                function() {
+                  return strings;
+                }
+              ),
+              "m"
+            ),
+            greedy: true,
+            inside: {
+              info: {
+                // foo@bar:~/files$ exit
+                // foo@bar$ exit
+                // ~/files$ exit
+                pattern: /^[^#$%]+/,
+                alias: "punctuation",
+                inside: {
+                  user: /^[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+/,
+                  punctuation: /:/,
+                  path: /[\s\S]+/
+                }
+              },
+              bash: {
+                pattern: /(^[$#%]\s*)\S[\s\S]*/,
+                lookbehind: true,
+                alias: "language-bash",
+                inside: Prism2.languages.bash
+              },
+              "shell-symbol": {
+                pattern: /^[$#%]/,
+                alias: "important"
+              }
+            }
+          },
+          output: /.(?:.*(?:[\r\n]|.$))*/
+        };
+        Prism2.languages["sh-session"] = Prism2.languages["shellsession"] = Prism2.languages["shell-session"];
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_shell_session
+};

package/dist/chunk-RRXZFUCR.js

@@ -0,0 +1,39 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/qore.js
+var require_qore = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/qore.js"(exports, module) {
+    module.exports = qore;
+    qore.displayName = "qore";
+    qore.aliases = [];
+    function qore(Prism) {
+      Prism.languages.qore = Prism.languages.extend("clike", {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
+          lookbehind: true
+        },
+        // Overridden to allow unescaped multi-line strings
+        string: {
+          pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+          greedy: true
+        },
+        keyword: /\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\b/,
+        boolean: /\b(?:false|true)\b/i,
+        function: /\$?\b(?!\d)\w+(?=\()/,
+        number: /\b(?:0b[01]+|0x(?:[\da-f]*\.)?[\da-fp\-]+|(?:\d+(?:\.\d+)?|\.\d+)(?:e\d+)?[df]|(?:\d+(?:\.\d+)?|\.\d+))\b/i,
+        operator: {
+          pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
+          lookbehind: true
+        },
+        variable: /\$(?!\d)\w+\b/
+      });
+    }
+  }
+});
+
+export {
+  require_qore
+};

package/dist/chunk-SIUAQ32X.js

@@ -0,0 +1,53 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/eiffel.js
+var require_eiffel = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/eiffel.js"(exports, module) {
+    module.exports = eiffel;
+    eiffel.displayName = "eiffel";
+    eiffel.aliases = [];
+    function eiffel(Prism) {
+      Prism.languages.eiffel = {
+        comment: /--.*/,
+        string: [
+          // Aligned-verbatim-strings
+          {
+            pattern: /"([^[]*)\[[\s\S]*?\]\1"/,
+            greedy: true
+          },
+          // Non-aligned-verbatim-strings
+          {
+            pattern: /"([^{]*)\{[\s\S]*?\}\1"/,
+            greedy: true
+          },
+          // Single-line string
+          {
+            pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
+            greedy: true
+          }
+        ],
+        // normal char | special char | char code
+        char: /'(?:%.|[^%'\r\n])+'/,
+        keyword: /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
+        boolean: /\b(?:False|True)\b/i,
+        // Convention: class-names are always all upper-case characters
+        "class-name": /\b[A-Z][\dA-Z_]*\b/,
+        number: [
+          // hexa | octal | bin
+          /\b0[xcb][\da-f](?:_*[\da-f])*\b/i,
+          // Decimal
+          /(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
+        ],
+        punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
+        operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/
+      };
+    }
+  }
+});
+
+export {
+  require_eiffel
+};

package/dist/chunk-SKD2A5KV.js

@@ -0,0 +1,54 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-XUQ4ZZPG.js";
+import {
+  require_ruby
+} from "./chunk-C2AUXPBE.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/erb.js
+var require_erb = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/erb.js"(exports, module) {
+    var refractorRuby = require_ruby();
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = erb;
+    erb.displayName = "erb";
+    erb.aliases = [];
+    function erb(Prism) {
+      Prism.register(refractorRuby);
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        Prism2.languages.erb = {
+          delimiter: {
+            pattern: /^(\s*)<%=?|%>(?=\s*$)/,
+            lookbehind: true,
+            alias: "punctuation"
+          },
+          ruby: {
+            pattern: /\s*\S[\s\S]*/,
+            alias: "language-ruby",
+            inside: Prism2.languages.ruby
+          }
+        };
+        Prism2.hooks.add("before-tokenize", function(env) {
+          var erbPattern = /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "erb",
+            erbPattern
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "erb");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_erb
+};

package/dist/chunk-SROV7A53.js

@@ -0,0 +1,61 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/peoplecode.js
+var require_peoplecode = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/peoplecode.js"(exports, module) {
+    module.exports = peoplecode;
+    peoplecode.displayName = "peoplecode";
+    peoplecode.aliases = ["pcode"];
+    function peoplecode(Prism) {
+      Prism.languages.peoplecode = {
+        comment: RegExp(
+          [
+            // C-style multiline comments
+            /\/\*[\s\S]*?\*\//.source,
+            // REM comments
+            /\bREM[^;]*;/.source,
+            // Nested <* *> comments
+            /<\*(?:[^<*]|\*(?!>)|<(?!\*)|<\*(?:(?!\*>)[\s\S])*\*>)*\*>/.source,
+            // /+ +/ comments
+            /\/\+[\s\S]*?\+\//.source
+          ].join("|")
+        ),
+        string: {
+          pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+          greedy: true
+        },
+        variable: /%\w+/,
+        "function-definition": {
+          pattern: /((?:^|[^\w-])(?:function|method)\s+)\w+/i,
+          lookbehind: true,
+          alias: "function"
+        },
+        "class-name": {
+          pattern: /((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,
+          lookbehind: true,
+          inside: {
+            punctuation: /:/
+          }
+        },
+        keyword: /\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\b/i,
+        "operator-keyword": {
+          pattern: /\b(?:and|not|or)\b/i,
+          alias: "operator"
+        },
+        function: /[_a-z]\w*(?=\s*\()/i,
+        boolean: /\b(?:false|true)\b/i,
+        number: /\b\d+(?:\.\d+)?\b/,
+        operator: /<>|[<>]=?|!=|\*\*|[-+*/|=@]/,
+        punctuation: /[:.;,()[\]]/
+      };
+      Prism.languages.pcode = Prism.languages.peoplecode;
+    }
+  }
+});
+
+export {
+  require_peoplecode
+};