@distri/react 0.3.1 → 0.3.3

package/dist/chunk-TR5CHC4X.js

@@ -0,0 +1,427 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/csharp.js
+var require_csharp = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/csharp.js"(exports, module) {
+    module.exports = csharp;
+    csharp.displayName = "csharp";
+    csharp.aliases = ["dotnet", "cs"];
+    function csharp(Prism) {
+      ;
+      (function(Prism2) {
+        function replace(pattern, replacements) {
+          return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+            return "(?:" + replacements[+index] + ")";
+          });
+        }
+        function re(pattern, replacements, flags) {
+          return RegExp(replace(pattern, replacements), flags || "");
+        }
+        function nested(pattern, depthLog2) {
+          for (var i = 0; i < depthLog2; i++) {
+            pattern = pattern.replace(/<<self>>/g, function() {
+              return "(?:" + pattern + ")";
+            });
+          }
+          return pattern.replace(/<<self>>/g, "[^\\s\\S]");
+        }
+        var keywordKinds = {
+          // keywords which represent a return or variable type
+          type: "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+          // keywords which are used to declare a type
+          typeDeclaration: "class enum interface record struct",
+          // contextual keywords
+          // ("var" and "dynamic" are missing because they are used like types)
+          contextual: "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
+          // all other keywords
+          other: "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield"
+        };
+        function keywordsToPattern(words) {
+          return "\\b(?:" + words.trim().replace(/ /g, "|") + ")\\b";
+        }
+        var typeDeclarationKeywords = keywordsToPattern(
+          keywordKinds.typeDeclaration
+        );
+        var keywords = RegExp(
+          keywordsToPattern(
+            keywordKinds.type + " " + keywordKinds.typeDeclaration + " " + keywordKinds.contextual + " " + keywordKinds.other
+          )
+        );
+        var nonTypeKeywords = keywordsToPattern(
+          keywordKinds.typeDeclaration + " " + keywordKinds.contextual + " " + keywordKinds.other
+        );
+        var nonContextualKeywords = keywordsToPattern(
+          keywordKinds.type + " " + keywordKinds.typeDeclaration + " " + keywordKinds.other
+        );
+        var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2);
+        var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
+        var name = /@?\b[A-Za-z_]\w*\b/.source;
+        var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [name, generic]);
+        var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [
+          nonTypeKeywords,
+          genericName
+        ]);
+        var array = /\[\s*(?:,\s*)*\]/.source;
+        var typeExpressionWithoutTuple = replace(
+          /<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source,
+          [identifier, array]
+        );
+        var tupleElement = replace(
+          /[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,
+          [generic, nestedRound, array]
+        );
+        var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
+        var typeExpression = replace(
+          /(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source,
+          [tuple, identifier, array]
+        );
+        var typeInside = {
+          keyword: keywords,
+          punctuation: /[<>()?,.:[\]]/
+        };
+        var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source;
+        var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
+        var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
+        Prism2.languages.csharp = Prism2.languages.extend("clike", {
+          string: [
+            {
+              pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          "class-name": [
+            {
+              // Using static
+              // using static System.Math;
+              pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [
+                identifier
+              ]),
+              lookbehind: true,
+              inside: typeInside
+            },
+            {
+              // Using alias (type)
+              // using Project = PC.MyCompany.Project;
+              pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
+                name,
+                typeExpression
+              ]),
+              lookbehind: true,
+              inside: typeInside
+            },
+            {
+              // Using alias (alias)
+              // using Project = PC.MyCompany.Project;
+              pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
+              lookbehind: true
+            },
+            {
+              // Type declarations
+              // class Foo<A, B>
+              // interface Foo<out A, B>
+              pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
+                typeDeclarationKeywords,
+                genericName
+              ]),
+              lookbehind: true,
+              inside: typeInside
+            },
+            {
+              // Single catch exception declaration
+              // catch(Foo)
+              // (things like catch(Foo e) is covered by variable declaration)
+              pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
+              lookbehind: true,
+              inside: typeInside
+            },
+            {
+              // Name of the type parameter of generic constraints
+              // where Foo : class
+              pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
+              lookbehind: true
+            },
+            {
+              // Casts and checks via as and is.
+              // as Foo<A>, is Bar<B>
+              // (things like if(a is Foo b) is covered by variable declaration)
+              pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [
+                typeExpressionWithoutTuple
+              ]),
+              lookbehind: true,
+              inside: typeInside
+            },
+            {
+              // Variable, field and parameter declaration
+              // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
+              pattern: re(
+                /\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source,
+                [typeExpression, nonContextualKeywords, name]
+              ),
+              inside: typeInside
+            }
+          ],
+          keyword: keywords,
+          // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
+          number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+          operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+          punctuation: /\?\.?|::|[{}[\];(),.:]/
+        });
+        Prism2.languages.insertBefore("csharp", "number", {
+          range: {
+            pattern: /\.\./,
+            alias: "operator"
+          }
+        });
+        Prism2.languages.insertBefore("csharp", "punctuation", {
+          "named-parameter": {
+            pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
+            lookbehind: true,
+            alias: "punctuation"
+          }
+        });
+        Prism2.languages.insertBefore("csharp", "class-name", {
+          namespace: {
+            // namespace Foo.Bar {}
+            // using Foo.Bar;
+            pattern: re(
+              /(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,
+              [name]
+            ),
+            lookbehind: true,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          "type-expression": {
+            // default(Foo), typeof(Foo<Bar>), sizeof(int)
+            pattern: re(
+              /(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source,
+              [nestedRound]
+            ),
+            lookbehind: true,
+            alias: "class-name",
+            inside: typeInside
+          },
+          "return-type": {
+            // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+            // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+            // int Foo => 0; int Foo { get; set } = 0;
+            pattern: re(
+              /<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,
+              [typeExpression, identifier]
+            ),
+            inside: typeInside,
+            alias: "class-name"
+          },
+          "constructor-invocation": {
+            // new List<Foo<Bar[]>> { }
+            pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
+            lookbehind: true,
+            inside: typeInside,
+            alias: "class-name"
+          },
+          /*'explicit-implementation': {
+          // int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+          pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
+          inside: classNameInside,
+          alias: 'class-name'
+          },*/
+          "generic-method": {
+            // foo<Bar>()
+            pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [name, generic]),
+            inside: {
+              function: re(/^<<0>>/.source, [name]),
+              generic: {
+                pattern: RegExp(generic),
+                alias: "class-name",
+                inside: typeInside
+              }
+            }
+          },
+          "type-list": {
+            // The list of types inherited or of generic constraints
+            // class Foo<F> : Bar, IList<FooBar>
+            // where F : Bar, IList<int>
+            pattern: re(
+              /\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source,
+              [
+                typeDeclarationKeywords,
+                genericName,
+                name,
+                typeExpression,
+                keywords.source,
+                nestedRound,
+                /\bnew\s*\(\s*\)/.source
+              ]
+            ),
+            lookbehind: true,
+            inside: {
+              "record-arguments": {
+                pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [
+                  genericName,
+                  nestedRound
+                ]),
+                lookbehind: true,
+                greedy: true,
+                inside: Prism2.languages.csharp
+              },
+              keyword: keywords,
+              "class-name": {
+                pattern: RegExp(typeExpression),
+                greedy: true,
+                inside: typeInside
+              },
+              punctuation: /[,()]/
+            }
+          },
+          preprocessor: {
+            pattern: /(^[\t ]*)#.*/m,
+            lookbehind: true,
+            alias: "property",
+            inside: {
+              // highlight preprocessor directives as keywords
+              directive: {
+                pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+                lookbehind: true,
+                alias: "keyword"
+              }
+            }
+          }
+        });
+        var regularStringOrCharacter = regularString + "|" + character;
+        var regularStringCharacterOrComment = replace(
+          /\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,
+          [regularStringOrCharacter]
+        );
+        var roundExpression = nested(
+          replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+            regularStringCharacterOrComment
+          ]),
+          2
+        );
+        var attrTarget = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source;
+        var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
+          identifier,
+          roundExpression
+        ]);
+        Prism2.languages.insertBefore("csharp", "class-name", {
+          attribute: {
+            // Attributes
+            // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
+            pattern: re(
+              /((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source,
+              [attrTarget, attr]
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              target: {
+                pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
+                alias: "keyword"
+              },
+              "attribute-arguments": {
+                pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
+                inside: Prism2.languages.csharp
+              },
+              "class-name": {
+                pattern: RegExp(identifier),
+                inside: {
+                  punctuation: /\./
+                }
+              },
+              punctuation: /[:,]/
+            }
+          }
+        });
+        var formatString = /:[^}\r\n]+/.source;
+        var mInterpolationRound = nested(
+          replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+            regularStringCharacterOrComment
+          ]),
+          2
+        );
+        var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+          mInterpolationRound,
+          formatString
+        ]);
+        var sInterpolationRound = nested(
+          replace(
+            /[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source,
+            [regularStringOrCharacter]
+          ),
+          2
+        );
+        var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+          sInterpolationRound,
+          formatString
+        ]);
+        function createInterpolationInside(interpolation, interpolationRound) {
+          return {
+            interpolation: {
+              pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
+              lookbehind: true,
+              inside: {
+                "format-string": {
+                  pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
+                    interpolationRound,
+                    formatString
+                  ]),
+                  lookbehind: true,
+                  inside: {
+                    punctuation: /^:/
+                  }
+                },
+                punctuation: /^\{|\}$/,
+                expression: {
+                  pattern: /[\s\S]+/,
+                  alias: "language-csharp",
+                  inside: Prism2.languages.csharp
+                }
+              }
+            },
+            string: /[\s\S]+/
+          };
+        }
+        Prism2.languages.insertBefore("csharp", "string", {
+          "interpolation-string": [
+            {
+              pattern: re(
+                /(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source,
+                [mInterpolation]
+              ),
+              lookbehind: true,
+              greedy: true,
+              inside: createInterpolationInside(mInterpolation, mInterpolationRound)
+            },
+            {
+              pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [
+                sInterpolation
+              ]),
+              lookbehind: true,
+              greedy: true,
+              inside: createInterpolationInside(sInterpolation, sInterpolationRound)
+            }
+          ],
+          char: {
+            pattern: RegExp(character),
+            greedy: true
+          }
+        });
+        Prism2.languages.dotnet = Prism2.languages.cs = Prism2.languages.csharp;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_csharp
+};

package/dist/chunk-U5SCPMNY.js

@@ -0,0 +1,82 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/latex.js
+var require_latex = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/latex.js"(exports, module) {
+    module.exports = latex;
+    latex.displayName = "latex";
+    latex.aliases = ["tex", "context"];
+    function latex(Prism) {
+      ;
+      (function(Prism2) {
+        var funcPattern = /\\(?:[^a-z()[\]]|[a-z*]+)/i;
+        var insideEqu = {
+          "equation-command": {
+            pattern: funcPattern,
+            alias: "regex"
+          }
+        };
+        Prism2.languages.latex = {
+          comment: /%.*/,
+          // the verbatim environment prints whitespace to the document
+          cdata: {
+            pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+            lookbehind: true
+          },
+          /*
+           * equations can be between $$ $$ or $ $ or \( \) or \[ \]
+           * (all are multiline)
+           */
+          equation: [
+            {
+              pattern: /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/,
+              inside: insideEqu,
+              alias: "string"
+            },
+            {
+              pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+              lookbehind: true,
+              inside: insideEqu,
+              alias: "string"
+            }
+          ],
+          /*
+           * arguments which are keywords or references are highlighted
+           * as keywords
+           */
+          keyword: {
+            pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+            lookbehind: true
+          },
+          url: {
+            pattern: /(\\url\{)[^}]+(?=\})/,
+            lookbehind: true
+          },
+          /*
+           * section or chapter headlines are highlighted as bold so that
+           * they stand out more
+           */
+          headline: {
+            pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+            lookbehind: true,
+            alias: "class-name"
+          },
+          function: {
+            pattern: funcPattern,
+            alias: "selector"
+          },
+          punctuation: /[[\]{}&]/
+        };
+        Prism2.languages.tex = Prism2.languages.latex;
+        Prism2.languages.context = Prism2.languages.latex;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_latex
+};

package/dist/chunk-UDWMCI4M.js

@@ -0,0 +1,26 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gml.js
+var require_gml = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gml.js"(exports, module) {
+    module.exports = gml;
+    gml.displayName = "gml";
+    gml.aliases = [];
+    function gml(Prism) {
+      Prism.languages.gamemakerlanguage = Prism.languages.gml = Prism.languages.extend("clike", {
+        keyword: /\b(?:break|case|continue|default|do|else|enum|exit|for|globalvar|if|repeat|return|switch|until|var|while)\b/,
+        number: /(?:\b0x[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ulf]{0,4}/i,
+        operator: /--|\+\+|[-+%/=]=?|!=|\*\*?=?|<[<=>]?|>[=>]?|&&?|\^\^?|\|\|?|~|\b(?:and|at|not|or|with|xor)\b/,
+        constant: /\b(?:GM_build_date|GM_version|action_(?:continue|restart|reverse|stop)|all|gamespeed_(?:fps|microseconds)|global|local|noone|other|pi|pointer_(?:invalid|null)|self|timezone_(?:local|utc)|undefined|ev_(?:create|destroy|step|alarm|keyboard|mouse|collision|other|draw|draw_(?:begin|end|post|pre)|keypress|keyrelease|trigger|(?:left|middle|no|right)_button|(?:left|middle|right)_press|(?:left|middle|right)_release|mouse_(?:enter|leave|wheel_down|wheel_up)|global_(?:left|middle|right)_button|global_(?:left|middle|right)_press|global_(?:left|middle|right)_release|joystick(?:1|2)_(?:button1|button2|button3|button4|button5|button6|button7|button8|down|left|right|up)|outside|boundary|game_start|game_end|room_start|room_end|no_more_lives|animation_end|end_of_path|no_more_health|user\d|gui|gui_begin|gui_end|step_(?:begin|end|normal))|vk_(?:alt|anykey|backspace|control|delete|down|end|enter|escape|home|insert|left|nokey|pagedown|pageup|pause|printscreen|return|right|shift|space|tab|up|f\d|numpad\d|add|decimal|divide|lalt|lcontrol|lshift|multiply|ralt|rcontrol|rshift|subtract)|achievement_(?:filter_(?:all_players|favorites_only|friends_only)|friends_info|info|leaderboard_info|our_info|pic_loaded|show_(?:achievement|bank|friend_picker|leaderboard|profile|purchase_prompt|ui)|type_challenge|type_score_challenge)|asset_(?:font|object|path|room|script|shader|sound|sprite|tiles|timeline|unknown)|audio_(?:3d|falloff_(?:exponent_distance|exponent_distance_clamped|inverse_distance|inverse_distance_clamped|linear_distance|linear_distance_clamped|none)|mono|new_system|old_system|stereo)|bm_(?:add|complex|dest_alpha|dest_color|dest_colour|inv_dest_alpha|inv_dest_color|inv_dest_colour|inv_src_alpha|inv_src_color|inv_src_colour|max|normal|one|src_alpha|src_alpha_sat|src_color|src_colour|subtract|zero)|browser_(?:chrome|firefox|ie|ie_mobile|not_a_browser|opera|safari|safari_mobile|tizen|unknown|windows_store)|buffer_(?:bool|f16|f32|f64|fast|fixed|generalerror|grow|invalidtype|network|outofbounds|outofspace|s16|s32|s8|seek_end|seek_relative|seek_start|string|text|u16|u32|u64|u8|vbuffer|wrap)|c_(?:aqua|black|blue|dkgray|fuchsia|gray|green|lime|ltgray|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)|cmpfunc_(?:always|equal|greater|greaterequal|less|lessequal|never|notequal)|cr_(?:appstart|arrow|beam|cross|default|drag|handpoint|hourglass|none|size_all|size_nesw|size_ns|size_nwse|size_we|uparrow)|cull_(?:clockwise|counterclockwise|noculling)|device_(?:emulator|tablet)|device_ios_(?:ipad|ipad_retina|iphone|iphone5|iphone6|iphone6plus|iphone_retina|unknown)|display_(?:landscape|landscape_flipped|portrait|portrait_flipped)|dll_(?:cdecl|cdel|stdcall)|ds_type_(?:grid|list|map|priority|queue|stack)|ef_(?:cloud|ellipse|explosion|firework|flare|rain|ring|smoke|smokeup|snow|spark|star)|fa_(?:archive|bottom|center|directory|hidden|left|middle|readonly|right|sysfile|top|volumeid)|fb_login_(?:default|fallback_to_webview|forcing_safari|forcing_webview|no_fallback_to_webview|use_system_account)|iap_(?:available|canceled|ev_consume|ev_product|ev_purchase|ev_restore|ev_storeload|failed|purchased|refunded|status_available|status_loading|status_processing|status_restoring|status_unavailable|status_uninitialised|storeload_failed|storeload_ok|unavailable)|leaderboard_type_(?:number|time_mins_secs)|lighttype_(?:dir|point)|matrix_(?:projection|view|world)|mb_(?:any|left|middle|none|right)|network_(?:config_(?:connect_timeout|disable_reliable_udp|enable_reliable_udp|use_non_blocking_socket)|socket_(?:bluetooth|tcp|udp)|type_(?:connect|data|disconnect|non_blocking_connect))|of_challenge_(?:lose|tie|win)|os_(?:android|ios|linux|macosx|ps3|ps4|psvita|unknown|uwp|win32|win8native|windows|winphone|xboxone)|phy_debug_render_(?:aabb|collision_pairs|coms|core_shapes|joints|obb|shapes)|phy_joint_(?:anchor_1_x|anchor_1_y|anchor_2_x|anchor_2_y|angle|angle_limits|damping_ratio|frequency|length_1|length_2|lower_angle_limit|max_force|max_length|max_motor_force|max_motor_torque|max_torque|motor_force|motor_speed|motor_torque|reaction_force_x|reaction_force_y|reaction_torque|speed|translation|upper_angle_limit)|phy_particle_data_flag_(?:category|color|colour|position|typeflags|velocity)|phy_particle_flag_(?:colormixing|colourmixing|elastic|powder|spring|tensile|viscous|wall|water|zombie)|phy_particle_group_flag_(?:rigid|solid)|pr_(?:linelist|linestrip|pointlist|trianglefan|trianglelist|trianglestrip)|ps_(?:distr|shape)_(?:diamond|ellipse|gaussian|invgaussian|line|linear|rectangle)|pt_shape_(?:circle|cloud|disk|explosion|flare|line|pixel|ring|smoke|snow|spark|sphere|square|star)|ty_(?:real|string)|gp_(?:face\d|axislh|axislv|axisrh|axisrv|padd|padl|padr|padu|select|shoulderl|shoulderlb|shoulderr|shoulderrb|start|stickl|stickr)|lb_disp_(?:none|numeric|time_ms|time_sec)|lb_sort_(?:ascending|descending|none)|ov_(?:achievements|community|friends|gamegroup|players|settings)|ugc_(?:filetype_(?:community|microtrans)|list_(?:Favorited|Followed|Published|Subscribed|UsedOrPlayed|VotedDown|VotedOn|VotedUp|WillVoteLater)|match_(?:AllGuides|Artwork|Collections|ControllerBindings|IntegratedGuides|Items|Items_Mtx|Items_ReadyToUse|Screenshots|UsableInGame|Videos|WebGuides)|query_(?:AcceptedForGameRankedByAcceptanceDate|CreatedByFriendsRankedByPublicationDate|FavoritedByFriendsRankedByPublicationDate|NotYetRated)|query_RankedBy(?:NumTimesReported|PublicationDate|TextSearch|TotalVotesAsc|Trend|Vote|VotesUp)|result_success|sortorder_CreationOrder(?:Asc|Desc)|sortorder_(?:ForModeration|LastUpdatedDesc|SubscriptionDateDesc|TitleAsc|VoteScoreDesc)|visibility_(?:friends_only|private|public))|vertex_usage_(?:binormal|blendindices|blendweight|color|colour|depth|fog|normal|position|psize|sample|tangent|texcoord|textcoord)|vertex_type_(?:float\d|color|colour|ubyte4)|input_type|layerelementtype_(?:background|instance|oldtilemap|particlesystem|sprite|tile|tilemap|undefined)|se_(?:chorus|compressor|echo|equalizer|flanger|gargle|none|reverb)|text_type|tile_(?:flip|index_mask|mirror|rotate)|(?:obj|rm|scr|spr)\w+)\b/,
+        variable: /\b(?:alarm|application_surface|async_load|background_(?:alpha|blend|color|colour|foreground|height|hspeed|htiled|index|showcolor|showcolour|visible|vspeed|vtiled|width|x|xscale|y|yscale)|bbox_(?:bottom|left|right|top)|browser_(?:height|width)|caption_(?:health|lives|score)|current_(?:day|hour|minute|month|second|time|weekday|year)|cursor_sprite|debug_mode|delta_time|direction|display_aa|error_(?:last|occurred)|event_(?:action|number|object|type)|fps|fps_real|friction|game_(?:display|project|save)_(?:id|name)|gamemaker_(?:pro|registered|version)|gravity|gravity_direction|(?:h|v)speed|health|iap_data|id|image_(?:alpha|angle|blend|depth|index|number|speed|xscale|yscale)|instance_(?:count|id)|keyboard_(?:key|lastchar|lastkey|string)|layer|lives|mask_index|mouse_(?:button|lastbutton|x|y)|object_index|os_(?:browser|device|type|version)|path_(?:endaction|index|orientation|position|positionprevious|scale|speed)|persistent|phy_(?:rotation|(?:col_normal|collision|com|linear_velocity|position|speed)_(?:x|y)|angular_(?:damping|velocity)|position_(?:x|y)previous|speed|linear_damping|bullet|fixed_rotation|active|mass|inertia|dynamic|kinematic|sleeping|collision_points)|pointer_(?:invalid|null)|room|room_(?:caption|first|height|last|persistent|speed|width)|score|secure_mode|show_(?:health|lives|score)|solid|speed|sprite_(?:height|index|width|xoffset|yoffset)|temp_directory|timeline_(?:index|loop|position|running|speed)|transition_(?:color|kind|steps)|undefined|view_(?:angle|current|enabled|(?:h|v)(?:border|speed)|(?:h|w|x|y)port|(?:h|w|x|y)view|object|surface_id|visible)|visible|webgl_enabled|working_directory|(?:x|y)(?:previous|start)|x|y|argument(?:_relitive|_count|\d)|argument|global|local|other|self)\b/
+      });
+    }
+  }
+});
+
+export {
+  require_gml
+};

package/dist/chunk-UFBSSE4W.js

@@ -0,0 +1,112 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/zig.js
+var require_zig = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/zig.js"(exports, module) {
+    module.exports = zig;
+    zig.displayName = "zig";
+    zig.aliases = [];
+    function zig(Prism) {
+      ;
+      (function(Prism2) {
+        function literal(str) {
+          return function() {
+            return str;
+          };
+        }
+        var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
+        var IDENTIFIER = "\\b(?!" + keyword.source + ")(?!\\d)\\w+\\b";
+        var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source;
+        var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(
+          /<ALIGN>/g,
+          literal(ALIGN)
+        );
+        var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(
+          /<ID>/g,
+          literal(IDENTIFIER)
+        );
+        var TYPE = "(?!\\s)(?:!?\\s*(?:" + PREFIX_TYPE_OP + "\\s*)*" + SUFFIX_EXPR + ")+";
+        Prism2.languages.zig = {
+          comment: [
+            {
+              pattern: /\/\/[/!].*/,
+              alias: "doc-comment"
+            },
+            /\/{2}.*/
+          ],
+          string: [
+            {
+              // "string" and c"string"
+              pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/,
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              // multiline strings and c-strings
+              pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/,
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          char: {
+            // characters 'a', '\n', '\xFF', '\u{10FFFF}'
+            pattern: /(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/,
+            lookbehind: true,
+            greedy: true
+          },
+          builtin: /\B@(?!\d)\w+(?=\s*\()/,
+          label: {
+            pattern: /(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/,
+            lookbehind: true
+          },
+          "class-name": [
+            // const Foo = struct {};
+            /\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/,
+            {
+              // const x: i32 = 9;
+              // var x: Bar;
+              // fn foo(x: bool, y: f32) void {}
+              pattern: RegExp(
+                /(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))
+              ),
+              lookbehind: true,
+              inside: null
+              // see below
+            },
+            {
+              // extern fn foo(x: f64) f64; (optional alignment)
+              pattern: RegExp(
+                /(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))
+              ),
+              lookbehind: true,
+              inside: null
+              // see below
+            }
+          ],
+          "builtin-type": {
+            pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,
+            alias: "keyword"
+          },
+          keyword,
+          function: /\b(?!\d)\w+(?=\s*\()/,
+          number: /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,
+          boolean: /\b(?:false|true)\b/,
+          operator: /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,
+          punctuation: /[.:,;(){}[\]]/
+        };
+        Prism2.languages.zig["class-name"].forEach(function(obj) {
+          if (obj.inside === null) {
+            obj.inside = Prism2.languages.zig;
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_zig
+};