@distri/react 0.3.1 → 0.3.2

package/dist/chunk-B2OKL64P.js

@@ -0,0 +1,37 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xojo.js
+var require_xojo = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xojo.js"(exports, module) {
+    module.exports = xojo;
+    xojo.displayName = "xojo";
+    xojo.aliases = [];
+    function xojo(Prism) {
+      Prism.languages.xojo = {
+        comment: {
+          pattern: /(?:'|\/\/|Rem\b).+/i,
+          greedy: true
+        },
+        string: {
+          pattern: /"(?:""|[^"])*"/,
+          greedy: true
+        },
+        number: [/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i, /&[bchou][a-z\d]+/i],
+        directive: {
+          pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\b/i,
+          alias: "property"
+        },
+        keyword: /\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\b/i,
+        operator: /<[=>]?|>=?|[+\-*\/\\^=]|\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\b/i,
+        punctuation: /[.,;:()]/
+      };
+    }
+  }
+});
+
+export {
+  require_xojo
+};

package/dist/chunk-B3AXIWKC.js

@@ -0,0 +1,44 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nsis.js
+var require_nsis = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nsis.js"(exports, module) {
+    module.exports = nsis;
+    nsis.displayName = "nsis";
+    nsis.aliases = [];
+    function nsis(Prism) {
+      Prism.languages.nsis = {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|[#;].*)/,
+          lookbehind: true,
+          greedy: true
+        },
+        string: {
+          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        },
+        keyword: {
+          pattern: /(^[\t ]*)(?:Abort|Add(?:BrandingImage|Size)|AdvSplash|Allow(?:RootDirInstall|SkipFiles)|AutoCloseWindow|BG(?:Font|Gradient|Image)|Banner|BrandingText|BringToFront|CRCCheck|Call(?:InstDLL)?|Caption|ChangeUI|CheckBitmap|ClearErrors|CompletedText|ComponentText|CopyFiles|Create(?:Directory|Font|ShortCut)|Delete(?:INISec|INIStr|RegKey|RegValue)?|Detail(?:Print|sButtonText)|Dialer|Dir(?:Text|Var|Verify)|EnableWindow|Enum(?:RegKey|RegValue)|Exch|Exec(?:Shell(?:Wait)?|Wait)?|ExpandEnvStrings|File(?:BufSize|Close|ErrorText|Open|Read|ReadByte|ReadUTF16LE|ReadWord|Seek|Write|WriteByte|WriteUTF16LE|WriteWord)?|Find(?:Close|First|Next|Window)|FlushINI|Get(?:CurInstType|CurrentAddress|DLLVersion(?:Local)?|DlgItem|ErrorLevel|FileTime(?:Local)?|FullPathName|Function(?:Address|End)?|InstDirError|LabelAddress|TempFileName)|Goto|HideWindow|Icon|If(?:Abort|Errors|FileExists|RebootFlag|Silent)|InitPluginsDir|InstProgressFlags|Inst(?:Type(?:GetText|SetText)?)|Install(?:ButtonText|Colors|Dir(?:RegKey)?)|Int(?:64|Ptr)?CmpU?|Int(?:64)?Fmt|Int(?:Ptr)?Op|IsWindow|Lang(?:DLL|String)|License(?:BkColor|Data|ForceSelection|LangString|Text)|LoadLanguageFile|LockWindow|Log(?:Set|Text)|Manifest(?:DPIAware|SupportedOS)|Math|MessageBox|MiscButtonText|NSISdl|Name|Nop|OutFile|PE(?:DllCharacteristics|SubsysVer)|Page(?:Callbacks)?|Pop|Push|Quit|RMDir|Read(?:EnvStr|INIStr|RegDWORD|RegStr)|Reboot|RegDLL|Rename|RequestExecutionLevel|ReserveFile|Return|SearchPath|Section(?:End|GetFlags|GetInstTypes|GetSize|GetText|Group|In|SetFlags|SetInstTypes|SetSize|SetText)?|SendMessage|Set(?:AutoClose|BrandingImage|Compress|Compressor(?:DictSize)?|CtlColors|CurInstType|DatablockOptimize|DateSave|Details(?:Print|View)|ErrorLevel|Errors|FileAttributes|Font|OutPath|Overwrite|PluginUnload|RebootFlag|RegView|ShellVarContext|Silent)|Show(?:InstDetails|UninstDetails|Window)|Silent(?:Install|UnInstall)|Sleep|SpaceTexts|Splash|StartMenu|Str(?:CmpS?|Cpy|Len)|SubCaption|System|UnRegDLL|Unicode|UninstPage|Uninstall(?:ButtonText|Caption|Icon|SubCaption|Text)|UserInfo|VI(?:AddVersionKey|FileVersion|ProductVersion)|VPatch|Var|WindowIcon|Write(?:INIStr|Reg(?:Bin|DWORD|ExpandStr|MultiStr|None|Str)|Uninstaller)|XPStyle|ns(?:Dialogs|Exec))\b/m,
+          lookbehind: true
+        },
+        property: /\b(?:ARCHIVE|FILE_(?:ATTRIBUTE_ARCHIVE|ATTRIBUTE_NORMAL|ATTRIBUTE_OFFLINE|ATTRIBUTE_READONLY|ATTRIBUTE_SYSTEM|ATTRIBUTE_TEMPORARY)|HK(?:(?:CR|CU|LM)(?:32|64)?|DD|PD|U)|HKEY_(?:CLASSES_ROOT|CURRENT_CONFIG|CURRENT_USER|DYN_DATA|LOCAL_MACHINE|PERFORMANCE_DATA|USERS)|ID(?:ABORT|CANCEL|IGNORE|NO|OK|RETRY|YES)|MB_(?:ABORTRETRYIGNORE|DEFBUTTON1|DEFBUTTON2|DEFBUTTON3|DEFBUTTON4|ICONEXCLAMATION|ICONINFORMATION|ICONQUESTION|ICONSTOP|OK|OKCANCEL|RETRYCANCEL|RIGHT|RTLREADING|SETFOREGROUND|TOPMOST|USERICON|YESNO)|NORMAL|OFFLINE|READONLY|SHCTX|SHELL_CONTEXT|SYSTEM|TEMPORARY|admin|all|auto|both|colored|false|force|hide|highest|lastused|leave|listonly|none|normal|notset|off|on|open|print|show|silent|silentlog|smooth|textonly|true|user)\b/,
+        constant: /\$\{[!\w\.:\^-]+\}|\$\([!\w\.:\^-]+\)/,
+        variable: /\$\w[\w\.]*/,
+        number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+        operator: /--?|\+\+?|<=?|>=?|==?=?|&&?|\|\|?|[?*\/~^%]/,
+        punctuation: /[{}[\];(),.:]/,
+        important: {
+          pattern: /(^[\t ]*)!(?:addincludedir|addplugindir|appendfile|cd|define|delfile|echo|else|endif|error|execute|finalize|getdllversion|gettlbversion|if|ifdef|ifmacrodef|ifmacrondef|ifndef|include|insertmacro|macro|macroend|makensis|packhdr|pragma|searchparse|searchreplace|system|tempfile|undef|verbose|warning)\b/im,
+          lookbehind: true
+        }
+      };
+    }
+  }
+});
+
+export {
+  require_nsis
+};

package/dist/chunk-B46PX26X.js

@@ -0,0 +1,46 @@
+"use client";
+import {
+  require_basic
+} from "./chunk-C74WNJ2N.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vbnet.js
+var require_vbnet = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vbnet.js"(exports, module) {
+    var refractorBasic = require_basic();
+    module.exports = vbnet;
+    vbnet.displayName = "vbnet";
+    vbnet.aliases = [];
+    function vbnet(Prism) {
+      Prism.register(refractorBasic);
+      Prism.languages.vbnet = Prism.languages.extend("basic", {
+        comment: [
+          {
+            pattern: /(?:!|REM\b).+/i,
+            inside: {
+              keyword: /^REM/i
+            }
+          },
+          {
+            pattern: /(^|[^\\:])'.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
+          lookbehind: true,
+          greedy: true
+        },
+        keyword: /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
+        punctuation: /[,;:(){}]/
+      });
+    }
+  }
+});
+
+export {
+  require_vbnet
+};

package/dist/chunk-B473FUV4.js

@@ -0,0 +1,48 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rip.js
+var require_rip = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rip.js"(exports, module) {
+    module.exports = rip;
+    rip.displayName = "rip";
+    rip.aliases = [];
+    function rip(Prism) {
+      Prism.languages.rip = {
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        char: {
+          pattern: /\B`[^\s`'",.:;#\/\\()<>\[\]{}]\b/,
+          greedy: true
+        },
+        string: {
+          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        },
+        regex: {
+          pattern: /(^|[^/])\/(?!\/)(?:\[[^\n\r\]]*\]|\\.|[^/\\\r\n\[])+\/(?=\s*(?:$|[\r\n,.;})]))/,
+          lookbehind: true,
+          greedy: true
+        },
+        keyword: /(?:=>|->)|\b(?:case|catch|class|else|exit|finally|if|raise|return|switch|try)\b/,
+        builtin: /@|\bSystem\b/,
+        boolean: /\b(?:false|true)\b/,
+        date: /\b\d{4}-\d{2}-\d{2}\b/,
+        time: /\b\d{2}:\d{2}:\d{2}\b/,
+        datetime: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\b/,
+        symbol: /:[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/,
+        number: /[+-]?\b(?:\d+\.\d+|\d+)\b/,
+        punctuation: /(?:\.{2,3})|[`,.:;=\/\\()<>\[\]{}]/,
+        reference: /[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/
+      };
+    }
+  }
+});
+
+export {
+  require_rip
+};

package/dist/chunk-B4R5D6RX.js

@@ -0,0 +1,61 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/avro-idl.js
+var require_avro_idl = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/avro-idl.js"(exports, module) {
+    module.exports = avroIdl;
+    avroIdl.displayName = "avroIdl";
+    avroIdl.aliases = [];
+    function avroIdl(Prism) {
+      Prism.languages["avro-idl"] = {
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: true
+        },
+        string: {
+          pattern: /(^|[^\\])"(?:[^\r\n"\\]|\\.)*"/,
+          lookbehind: true,
+          greedy: true
+        },
+        annotation: {
+          pattern: /@(?:[$\w.-]|`[^\r\n`]+`)+/,
+          greedy: true,
+          alias: "function"
+        },
+        "function-identifier": {
+          pattern: /`[^\r\n`]+`(?=\s*\()/,
+          greedy: true,
+          alias: "function"
+        },
+        identifier: {
+          pattern: /`[^\r\n`]+`/,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(\b(?:enum|error|protocol|record|throws)\b\s+)[$\w]+/,
+          lookbehind: true,
+          greedy: true
+        },
+        keyword: /\b(?:array|boolean|bytes|date|decimal|double|enum|error|false|fixed|float|idl|import|int|local_timestamp_ms|long|map|null|oneway|protocol|record|schema|string|throws|time_ms|timestamp_ms|true|union|uuid|void)\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: [
+          {
+            pattern: /(^|[^\w.])-?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|0x(?:[a-f0-9]+(?:\.[a-f0-9]*)?|\.[a-f0-9]+)(?:p[+-]?\d+)?)[dfl]?(?![\w.])/i,
+            lookbehind: true
+          },
+          /-?\b(?:Infinity|NaN)\b/
+        ],
+        operator: /=/,
+        punctuation: /[()\[\]{}<>.:,;-]/
+      };
+      Prism.languages.avdl = Prism.languages["avro-idl"];
+    }
+  }
+});
+
+export {
+  require_avro_idl
+};

package/dist/chunk-B6FTZZUW.js

@@ -0,0 +1,141 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rust.js
+var require_rust = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rust.js"(exports, module) {
+    module.exports = rust;
+    rust.displayName = "rust";
+    rust.aliases = [];
+    function rust(Prism) {
+      ;
+      (function(Prism2) {
+        var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
+        for (var i = 0; i < 2; i++) {
+          multilineComment = multilineComment.replace(/<self>/g, function() {
+            return multilineComment;
+          });
+        }
+        multilineComment = multilineComment.replace(/<self>/g, function() {
+          return /[^\s\S]/.source;
+        });
+        Prism2.languages.rust = {
+          comment: [
+            {
+              pattern: RegExp(/(^|[^\\])/.source + multilineComment),
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              pattern: /(^|[^\\:])\/\/.*/,
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          string: {
+            pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+            greedy: true
+          },
+          char: {
+            pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+            greedy: true
+          },
+          attribute: {
+            pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+            greedy: true,
+            alias: "attr-name",
+            inside: {
+              string: null
+              // see below
+            }
+          },
+          // Closure params should not be confused with bitwise OR |
+          "closure-params": {
+            pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              "closure-punctuation": {
+                pattern: /^\||\|$/,
+                alias: "punctuation"
+              },
+              rest: null
+              // see below
+            }
+          },
+          "lifetime-annotation": {
+            pattern: /'\w+/,
+            alias: "symbol"
+          },
+          "fragment-specifier": {
+            pattern: /(\$\w+:)[a-z]+/,
+            lookbehind: true,
+            alias: "punctuation"
+          },
+          variable: /\$\w+/,
+          "function-definition": {
+            pattern: /(\bfn\s+)\w+/,
+            lookbehind: true,
+            alias: "function"
+          },
+          "type-definition": {
+            pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+            lookbehind: true,
+            alias: "class-name"
+          },
+          "module-declaration": [
+            {
+              pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+              lookbehind: true,
+              alias: "namespace"
+            },
+            {
+              pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+              lookbehind: true,
+              alias: "namespace",
+              inside: {
+                punctuation: /::/
+              }
+            }
+          ],
+          keyword: [
+            // https://github.com/rust-lang/reference/blob/master/src/keywords.md
+            /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+            // primitives and str
+            // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
+            /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
+          ],
+          // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+          // and Rust's naming conventions recommend snake_case anyway.
+          // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
+          function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+          macro: {
+            pattern: /\b\w+!/,
+            alias: "property"
+          },
+          constant: /\b[A-Z_][A-Z_\d]+\b/,
+          "class-name": /\b[A-Z]\w*\b/,
+          namespace: {
+            pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+            inside: {
+              punctuation: /::/
+            }
+          },
+          // Hex, oct, bin, dec numbers with visual separators and type suffix
+          number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+          boolean: /\b(?:false|true)\b/,
+          punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+          operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+        };
+        Prism2.languages.rust["closure-params"].inside.rest = Prism2.languages.rust;
+        Prism2.languages.rust["attribute"].inside["string"] = Prism2.languages.rust["string"];
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_rust
+};

package/dist/chunk-BADY4QJT.js

@@ -0,0 +1,108 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wren.js
+var require_wren = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wren.js"(exports, module) {
+    module.exports = wren;
+    wren.displayName = "wren";
+    wren.aliases = [];
+    function wren(Prism) {
+      Prism.languages.wren = {
+        // Multiline comments in Wren can have nested multiline comments
+        // Comments: // and /* */
+        comment: [
+          {
+            // support 3 levels of nesting
+            // regex: \/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\/
+            pattern: /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*))*\*\/)*\*\/)*\*\//,
+            greedy: true
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        // Triple quoted strings are multiline but cannot have interpolation (raw strings)
+        // Based on prism-python.js
+        "triple-quoted-string": {
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true,
+          alias: "string"
+        },
+        // see below
+        "string-literal": null,
+        // #!/usr/bin/env wren on the first line
+        hashbang: {
+          pattern: /^#!\/.+/,
+          greedy: true,
+          alias: "comment"
+        },
+        // Attributes are special keywords to add meta data to classes
+        attribute: {
+          // #! attributes are stored in class properties
+          // #!myvar = true
+          // #attributes are not stored and dismissed at compilation
+          pattern: /#!?[ \t\u3000]*\w+/,
+          alias: "keyword"
+        },
+        "class-name": [
+          {
+            // class definition
+            // class Meta {}
+            pattern: /(\bclass\s+)\w+/,
+            lookbehind: true
+          },
+          // A class must always start with an uppercase.
+          // File.read
+          /\b[A-Z][a-z\d_]*\b/
+        ],
+        // A constant can be a variable, class, property or method. Just named in all uppercase letters
+        constant: /\b[A-Z][A-Z\d_]*\b/,
+        null: {
+          pattern: /\bnull\b/,
+          alias: "keyword"
+        },
+        keyword: /\b(?:as|break|class|construct|continue|else|for|foreign|if|import|in|is|return|static|super|this|var|while)\b/,
+        boolean: /\b(?:false|true)\b/,
+        number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+        // Functions can be Class.method()
+        function: /\b[a-z_]\w*(?=\s*[({])/i,
+        operator: /<<|>>|[=!<>]=?|&&|\|\||[-+*/%~^&|?:]|\.{2,3}/,
+        punctuation: /[\[\](){}.,;]/
+      };
+      Prism.languages.wren["string-literal"] = {
+        // A single quote string is multiline and can have interpolation (similar to JS backticks ``)
+        pattern: /(^|[^\\"])"(?:[^\\"%]|\\[\s\S]|%(?!\()|%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\))*"/,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          interpolation: {
+            // "%(interpolation)"
+            pattern: /((?:^|[^\\])(?:\\{2})*)%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\)/,
+            lookbehind: true,
+            inside: {
+              expression: {
+                pattern: /^(%\()[\s\S]+(?=\)$)/,
+                lookbehind: true,
+                inside: Prism.languages.wren
+              },
+              "interpolation-punctuation": {
+                pattern: /^%\(|\)$/,
+                alias: "punctuation"
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      };
+    }
+  }
+});
+
+export {
+  require_wren
+};