@distri/react 0.3.3 → 0.3.4

package/dist/chunk-TR5CHC4X.js

@@ -1,427 +0,0 @@
-"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

@@ -1,82 +0,0 @@
-"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

@@ -1,26 +0,0 @@
-"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

@@ -1,112 +0,0 @@
-"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
-};