@distri/react 0.2.5 → 0.2.8

package/dist/chunk-3REW723S.js

@@ -0,0 +1,49 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/clojure.js
+var require_clojure = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/clojure.js"(exports, module) {
+    module.exports = clojure;
+    clojure.displayName = "clojure";
+    clojure.aliases = [];
+    function clojure(Prism) {
+      Prism.languages.clojure = {
+        comment: {
+          pattern: /;.*/,
+          greedy: true
+        },
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: true
+        },
+        char: /\\\w+/,
+        symbol: {
+          pattern: /(^|[\s()\[\]{},])::?[\w*+!?'<>=/.-]+/,
+          lookbehind: true
+        },
+        keyword: {
+          pattern: /(\()(?:-|->|->>|\.|\.\.|\*|\/|\+|<|<=|=|==|>|>=|accessor|agent|agent-errors|aget|alength|all-ns|alter|and|append-child|apply|array-map|aset|aset-boolean|aset-byte|aset-char|aset-double|aset-float|aset-int|aset-long|aset-short|assert|assoc|await|await-for|bean|binding|bit-and|bit-not|bit-or|bit-shift-left|bit-shift-right|bit-xor|boolean|branch\?|butlast|byte|cast|char|children|class|clear-agent-errors|comment|commute|comp|comparator|complement|concat|cond|conj|cons|constantly|construct-proxy|contains\?|count|create-ns|create-struct|cycle|dec|declare|def|def-|definline|definterface|defmacro|defmethod|defmulti|defn|defn-|defonce|defproject|defprotocol|defrecord|defstruct|deftype|deref|difference|disj|dissoc|distinct|do|doall|doc|dorun|doseq|dosync|dotimes|doto|double|down|drop|drop-while|edit|end\?|ensure|eval|every\?|false\?|ffirst|file-seq|filter|find|find-doc|find-ns|find-var|first|float|flush|fn|fnseq|for|frest|gensym|get|get-proxy-class|hash-map|hash-set|identical\?|identity|if|if-let|if-not|import|in-ns|inc|index|insert-child|insert-left|insert-right|inspect-table|inspect-tree|instance\?|int|interleave|intersection|into|into-array|iterate|join|key|keys|keyword|keyword\?|last|lazy-cat|lazy-cons|left|lefts|let|line-seq|list|list\*|load|load-file|locking|long|loop|macroexpand|macroexpand-1|make-array|make-node|map|map-invert|map\?|mapcat|max|max-key|memfn|merge|merge-with|meta|min|min-key|monitor-enter|name|namespace|neg\?|new|newline|next|nil\?|node|not|not-any\?|not-every\?|not=|ns|ns-imports|ns-interns|ns-map|ns-name|ns-publics|ns-refers|ns-resolve|ns-unmap|nth|nthrest|or|parse|partial|path|peek|pop|pos\?|pr|pr-str|print|print-str|println|println-str|prn|prn-str|project|proxy|proxy-mappings|quot|quote|rand|rand-int|range|re-find|re-groups|re-matcher|re-matches|re-pattern|re-seq|read|read-line|recur|reduce|ref|ref-set|refer|rem|remove|remove-method|remove-ns|rename|rename-keys|repeat|replace|replicate|resolve|rest|resultset-seq|reverse|rfirst|right|rights|root|rrest|rseq|second|select|select-keys|send|send-off|seq|seq-zip|seq\?|set|set!|short|slurp|some|sort|sort-by|sorted-map|sorted-map-by|sorted-set|special-symbol\?|split-at|split-with|str|string\?|struct|struct-map|subs|subvec|symbol|symbol\?|sync|take|take-nth|take-while|test|throw|time|to-array|to-array-2d|tree-seq|true\?|try|union|up|update-proxy|val|vals|var|var-get|var-set|var\?|vector|vector-zip|vector\?|when|when-first|when-let|when-not|with-local-vars|with-meta|with-open|with-out-str|xml-seq|xml-zip|zero\?|zipmap|zipper)(?=[\s)]|$)/,
+          lookbehind: true
+        },
+        boolean: /\b(?:false|nil|true)\b/,
+        number: {
+          pattern: /(^|[^\w$@])(?:\d+(?:[/.]\d+)?(?:e[+-]?\d+)?|0x[a-f0-9]+|[1-9]\d?r[a-z0-9]+)[lmn]?(?![\w$@])/i,
+          lookbehind: true
+        },
+        function: {
+          pattern: /((?:^|[^'])\()[\w*+!?'<>=/.-]+(?=[\s)]|$)/,
+          lookbehind: true
+        },
+        operator: /[#@^`~]/,
+        punctuation: /[{}\[\](),]/
+      };
+    }
+  }
+});
+
+export {
+  require_clojure
+};

package/dist/chunk-3WE5FOC4.js

@@ -0,0 +1,39 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bnf.js
+var require_bnf = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bnf.js"(exports, module) {
+    module.exports = bnf;
+    bnf.displayName = "bnf";
+    bnf.aliases = ["rbnf"];
+    function bnf(Prism) {
+      Prism.languages.bnf = {
+        string: {
+          pattern: /"[^\r\n"]*"|'[^\r\n']*'/
+        },
+        definition: {
+          pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
+          alias: ["rule", "keyword"],
+          inside: {
+            punctuation: /^<|>$/
+          }
+        },
+        rule: {
+          pattern: /<[^<>\r\n\t]+>/,
+          inside: {
+            punctuation: /^<|>$/
+          }
+        },
+        operator: /::=|[|()[\]{}*+?]|\.{3}/
+      };
+      Prism.languages.rbnf = Prism.languages.bnf;
+    }
+  }
+});
+
+export {
+  require_bnf
+};

package/dist/chunk-3XA6VTHO.js

@@ -0,0 +1,40 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/warpscript.js
+var require_warpscript = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/warpscript.js"(exports, module) {
+    module.exports = warpscript;
+    warpscript.displayName = "warpscript";
+    warpscript.aliases = [];
+    function warpscript(Prism) {
+      Prism.languages.warpscript = {
+        comment: /#.*|\/\/.*|\/\*[\s\S]*?\*\//,
+        string: {
+          pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'|<'(?:[^\\']|'(?!>)|\\.)*'>/,
+          greedy: true
+        },
+        variable: /\$\S+/,
+        macro: {
+          pattern: /@\S+/,
+          alias: "property"
+        },
+        // WarpScript doesn't have any keywords, these are all functions under the control category
+        // https://www.warp10.io/tags/control
+        keyword: /\b(?:BREAK|CHECKMACRO|CONTINUE|CUDF|DEFINED|DEFINEDMACRO|EVAL|FAIL|FOR|FOREACH|FORSTEP|IFT|IFTE|MSGFAIL|NRETURN|RETHROW|RETURN|SWITCH|TRY|UDF|UNTIL|WHILE)\b/,
+        number: /[+-]?\b(?:NaN|Infinity|\d+(?:\.\d*)?(?:[Ee][+-]?\d+)?|0x[\da-fA-F]+|0b[01]+)\b/,
+        boolean: /\b(?:F|T|false|true)\b/,
+        punctuation: /<%|%>|[{}[\]()]/,
+        // Some operators from the "operators" category
+        // https://www.warp10.io/tags/operators
+        operator: /==|&&?|\|\|?|\*\*?|>>>?|<<|[<>!~]=?|[-/%^]|\+!?|\b(?:AND|NOT|OR)\b/
+      };
+    }
+  }
+});
+
+export {
+  require_warpscript
+};

package/dist/chunk-3YPIA64V.js

@@ -0,0 +1,50 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wasm.js
+var require_wasm = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wasm.js"(exports, module) {
+    module.exports = wasm;
+    wasm.displayName = "wasm";
+    wasm.aliases = [];
+    function wasm(Prism) {
+      Prism.languages.wasm = {
+        comment: [
+          /\(;[\s\S]*?;\)/,
+          {
+            pattern: /;;.*/,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /"(?:\\[\s\S]|[^"\\])*"/,
+          greedy: true
+        },
+        keyword: [
+          {
+            pattern: /\b(?:align|offset)=/,
+            inside: {
+              operator: /=/
+            }
+          },
+          {
+            pattern: /\b(?:(?:f32|f64|i32|i64)(?:\.(?:abs|add|and|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|or|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|xor))?|memory\.(?:grow|size))\b/,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          /\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\b/
+        ],
+        variable: /\$[\w!#$%&'*+\-./:<=>?@\\^`|~]+/,
+        number: /[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[\da-fA-F](?:_?[\da-fA-F])*(?:\.[\da-fA-F](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[\da-fA-F](?:_?[\da-fA-D])*)?\b/,
+        punctuation: /[()]/
+      };
+    }
+  }
+});
+
+export {
+  require_wasm
+};

package/dist/chunk-426IPYWB.js

@@ -0,0 +1,158 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xquery.js
+var require_xquery = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xquery.js"(exports, module) {
+    module.exports = xquery;
+    xquery.displayName = "xquery";
+    xquery.aliases = [];
+    function xquery(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.xquery = Prism2.languages.extend("markup", {
+          "xquery-comment": {
+            pattern: /\(:[\s\S]*?:\)/,
+            greedy: true,
+            alias: "comment"
+          },
+          string: {
+            pattern: /(["'])(?:\1\1|(?!\1)[\s\S])*\1/,
+            greedy: true
+          },
+          extension: {
+            pattern: /\(#.+?#\)/,
+            alias: "symbol"
+          },
+          variable: /\$[-\w:]+/,
+          axis: {
+            pattern: /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,
+            lookbehind: true,
+            alias: "operator"
+          },
+          "keyword-operator": {
+            pattern: /(^|[^:-])\b(?:and|castable as|div|eq|except|ge|gt|idiv|instance of|intersect|is|le|lt|mod|ne|or|union)\b(?=$|[^:-])/,
+            lookbehind: true,
+            alias: "operator"
+          },
+          keyword: {
+            pattern: /(^|[^:-])\b(?:as|ascending|at|base-uri|boundary-space|case|cast as|collation|construction|copy-namespaces|declare|default|descending|else|empty (?:greatest|least)|encoding|every|external|for|function|if|import|in|inherit|lax|let|map|module|namespace|no-inherit|no-preserve|option|order(?: by|ed|ing)?|preserve|return|satisfies|schema|some|stable|strict|strip|then|to|treat as|typeswitch|unordered|validate|variable|version|where|xquery)\b(?=$|[^:-])/,
+            lookbehind: true
+          },
+          function: /[\w-]+(?::[\w-]+)*(?=\s*\()/,
+          "xquery-element": {
+            pattern: /(element\s+)[\w-]+(?::[\w-]+)*/,
+            lookbehind: true,
+            alias: "tag"
+          },
+          "xquery-attribute": {
+            pattern: /(attribute\s+)[\w-]+(?::[\w-]+)*/,
+            lookbehind: true,
+            alias: "attr-name"
+          },
+          builtin: {
+            pattern: /(^|[^:-])\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:ENTITIES|ENTITY|ID|IDREFS?|NCName|NMTOKENS?|NOTATION|Name|QName|anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|int|integer|language|long|negativeInteger|nonNegativeInteger|nonPositiveInteger|normalizedString|positiveInteger|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\b(?=$|[^:-])/,
+            lookbehind: true
+          },
+          number: /\b\d+(?:\.\d+)?(?:E[+-]?\d+)?/,
+          operator: [
+            /[+*=?|@]|\.\.?|:=|!=|<[=<]?|>[=>]?/,
+            {
+              pattern: /(\s)-(?=\s)/,
+              lookbehind: true
+            }
+          ],
+          punctuation: /[[\](){},;:/]/
+        });
+        Prism2.languages.xquery.tag.pattern = /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
+        Prism2.languages.xquery["tag"].inside["attr-value"].pattern = /=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+)/;
+        Prism2.languages.xquery["tag"].inside["attr-value"].inside["punctuation"] = /^="|"$/;
+        Prism2.languages.xquery["tag"].inside["attr-value"].inside["expression"] = {
+          // Allow for two levels of nesting
+          pattern: /\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}/,
+          inside: Prism2.languages.xquery,
+          alias: "language-xquery"
+        };
+        var stringifyToken = function(token) {
+          if (typeof token === "string") {
+            return token;
+          }
+          if (typeof token.content === "string") {
+            return token.content;
+          }
+          return token.content.map(stringifyToken).join("");
+        };
+        var walkTokens = function(tokens) {
+          var openedTags = [];
+          for (var i = 0; i < tokens.length; i++) {
+            var token = tokens[i];
+            var notTagNorBrace = false;
+            if (typeof token !== "string") {
+              if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") {
+                if (token.content[0].content[0].content === "</") {
+                  if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
+                    openedTags.pop();
+                  }
+                } else {
+                  if (token.content[token.content.length - 1].content === "/>") {
+                  } else {
+                    openedTags.push({
+                      tagName: stringifyToken(token.content[0].content[1]),
+                      openedBraces: 0
+                    });
+                  }
+                }
+              } else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{" && // Ignore `{{`
+              (!tokens[i + 1] || tokens[i + 1].type !== "punctuation" || tokens[i + 1].content !== "{") && (!tokens[i - 1] || tokens[i - 1].type !== "plain-text" || tokens[i - 1].content !== "{")) {
+                openedTags[openedTags.length - 1].openedBraces++;
+              } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") {
+                openedTags[openedTags.length - 1].openedBraces--;
+              } else if (token.type !== "comment") {
+                notTagNorBrace = true;
+              }
+            }
+            if (notTagNorBrace || typeof token === "string") {
+              if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+                var plainText = stringifyToken(token);
+                if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
+                  plainText += stringifyToken(tokens[i + 1]);
+                  tokens.splice(i + 1, 1);
+                }
+                if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
+                  plainText = stringifyToken(tokens[i - 1]) + plainText;
+                  tokens.splice(i - 1, 1);
+                  i--;
+                }
+                if (/^\s+$/.test(plainText)) {
+                  tokens[i] = plainText;
+                } else {
+                  tokens[i] = new Prism2.Token(
+                    "plain-text",
+                    plainText,
+                    null,
+                    plainText
+                  );
+                }
+              }
+            }
+            if (token.content && typeof token.content !== "string") {
+              walkTokens(token.content);
+            }
+          }
+        };
+        Prism2.hooks.add("after-tokenize", function(env) {
+          if (env.language !== "xquery") {
+            return;
+          }
+          walkTokens(env.tokens);
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_xquery
+};

package/dist/chunk-44ZZWXGU.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-45XBO57H.js

@@ -0,0 +1,75 @@
+"use client";
+import {
+  require_csharp
+} from "./chunk-IZLK5PA4.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/aspnet.js
+var require_aspnet = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/aspnet.js"(exports, module) {
+    var refractorCsharp = require_csharp();
+    module.exports = aspnet;
+    aspnet.displayName = "aspnet";
+    aspnet.aliases = [];
+    function aspnet(Prism) {
+      Prism.register(refractorCsharp);
+      Prism.languages.aspnet = Prism.languages.extend("markup", {
+        "page-directive": {
+          pattern: /<%\s*@.*%>/,
+          alias: "tag",
+          inside: {
+            "page-directive": {
+              pattern: /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
+              alias: "tag"
+            },
+            rest: Prism.languages.markup.tag.inside
+          }
+        },
+        directive: {
+          pattern: /<%.*%>/,
+          alias: "tag",
+          inside: {
+            directive: {
+              pattern: /<%\s*?[$=%#:]{0,2}|%>/,
+              alias: "tag"
+            },
+            rest: Prism.languages.csharp
+          }
+        }
+      });
+      Prism.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
+      Prism.languages.insertBefore(
+        "inside",
+        "punctuation",
+        {
+          directive: Prism.languages.aspnet["directive"]
+        },
+        Prism.languages.aspnet.tag.inside["attr-value"]
+      );
+      Prism.languages.insertBefore("aspnet", "comment", {
+        "asp-comment": {
+          pattern: /<%--[\s\S]*?--%>/,
+          alias: ["asp", "comment"]
+        }
+      });
+      Prism.languages.insertBefore(
+        "aspnet",
+        Prism.languages.javascript ? "script" : "tag",
+        {
+          "asp-script": {
+            pattern: /(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
+            lookbehind: true,
+            alias: ["asp", "script"],
+            inside: Prism.languages.csharp || {}
+          }
+        }
+      );
+    }
+  }
+});
+
+export {
+  require_aspnet
+};

package/dist/chunk-47VKELNA.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-4BINGQXR.js

@@ -0,0 +1,64 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/elm.js
+var require_elm = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/elm.js"(exports, module) {
+    module.exports = elm;
+    elm.displayName = "elm";
+    elm.aliases = [];
+    function elm(Prism) {
+      Prism.languages.elm = {
+        comment: /--.*|\{-[\s\S]*?-\}/,
+        char: {
+          pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
+          greedy: true
+        },
+        string: [
+          {
+            // Multiline strings are wrapped in triple ". Quotes may appear unescaped.
+            pattern: /"""[\s\S]*?"""/,
+            greedy: true
+          },
+          {
+            pattern: /"(?:[^\\"\r\n]|\\.)*"/,
+            greedy: true
+          }
+        ],
+        "import-statement": {
+          // The imported or hidden names are not included in this import
+          // statement. This is because we want to highlight those exactly like
+          // we do for the names in the program.
+          pattern: /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
+          lookbehind: true,
+          inside: {
+            keyword: /\b(?:as|exposing|import)\b/
+          }
+        },
+        keyword: /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
+        // These are builtin variables only. Constructors are highlighted later as a constant.
+        builtin: /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
+        // decimal integers and floating point numbers | hexadecimal integers
+        number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
+        // Most of this is needed because of the meaning of a single '.'.
+        // If it stands alone freely, it is the function composition.
+        // It may also be a separator between a module name and an identifier => no
+        // operator. If it comes together with other special characters it is an
+        // operator too.
+        // Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!
+        // Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ
+        operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
+        // In Elm, nearly everything is a variable, do not highlight these.
+        hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
+        constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
+        punctuation: /[{}[\]|(),.:]/
+      };
+    }
+  }
+});
+
+export {
+  require_elm
+};