@distri/react 0.2.5 → 0.2.8

package/dist/chunk-5ME2UIV2.js

@@ -0,0 +1,61 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nim.js
+var require_nim = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nim.js"(exports, module) {
+    module.exports = nim;
+    nim.displayName = "nim";
+    nim.aliases = [];
+    function nim(Prism) {
+      Prism.languages.nim = {
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        string: {
+          // Double-quoted strings can be prefixed by an identifier (Generalized raw string literals)
+          pattern: /(?:\b(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+)?(?:"""[\s\S]*?"""(?!")|"(?:\\[\s\S]|""|[^"\\])*")/,
+          greedy: true
+        },
+        char: {
+          // Character literals are handled specifically to prevent issues with numeric type suffixes
+          pattern: /'(?:\\(?:\d+|x[\da-fA-F]{0,2}|.)|[^'])'/,
+          greedy: true
+        },
+        function: {
+          pattern: /(?:(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+|`[^`\r\n]+`)\*?(?:\[[^\]]+\])?(?=\s*\()/,
+          greedy: true,
+          inside: {
+            operator: /\*$/
+          }
+        },
+        // We don't want to highlight operators (and anything really) inside backticks
+        identifier: {
+          pattern: /`[^`\r\n]+`/,
+          greedy: true,
+          inside: {
+            punctuation: /`/
+          }
+        },
+        // The negative look ahead prevents wrong highlighting of the .. operator
+        number: /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)(?:'?[iuf]\d*)?/,
+        keyword: /\b(?:addr|as|asm|atomic|bind|block|break|case|cast|concept|const|continue|converter|defer|discard|distinct|do|elif|else|end|enum|except|export|finally|for|from|func|generic|if|import|include|interface|iterator|let|macro|method|mixin|nil|object|out|proc|ptr|raise|ref|return|static|template|try|tuple|type|using|var|when|while|with|without|yield)\b/,
+        operator: {
+          // Look behind and look ahead prevent wrong highlighting of punctuations [. .] {. .} (. .)
+          // but allow the slice operator .. to take precedence over them
+          // One can define his own operators in Nim so all combination of operators might be an operator.
+          pattern: /(^|[({\[](?=\.\.)|(?![({\[]\.).)(?:(?:[=+\-*\/<>@$~&%|!?^:\\]|\.\.|\.(?![)}\]]))+|\b(?:and|div|in|is|isnot|mod|not|notin|of|or|shl|shr|xor)\b)/m,
+          lookbehind: true
+        },
+        punctuation: /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/
+      };
+    }
+  }
+});
+
+export {
+  require_nim
+};

package/dist/chunk-5NFJPAWG.js

@@ -0,0 +1,65 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gap.js
+var require_gap = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gap.js"(exports, module) {
+    module.exports = gap;
+    gap.displayName = "gap";
+    gap.aliases = [];
+    function gap(Prism) {
+      Prism.languages.gap = {
+        shell: {
+          pattern: /^gap>[\s\S]*?(?=^gap>|$(?![\s\S]))/m,
+          greedy: true,
+          inside: {
+            gap: {
+              pattern: /^(gap>).+(?:(?:\r(?:\n|(?!\n))|\n)>.*)*/,
+              lookbehind: true,
+              inside: null
+              // see below
+            },
+            punctuation: /^gap>/
+          }
+        },
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        string: {
+          pattern: /(^|[^\\'"])(?:'(?:[^\r\n\\']|\\.){1,10}'|"(?:[^\r\n\\"]|\\.)*"(?!")|"""[\s\S]*?""")/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            continuation: {
+              pattern: /([\r\n])>/,
+              lookbehind: true,
+              alias: "punctuation"
+            }
+          }
+        },
+        keyword: /\b(?:Assert|Info|IsBound|QUIT|TryNextMethod|Unbind|and|atomic|break|continue|do|elif|else|end|fi|for|function|if|in|local|mod|not|od|or|quit|readonly|readwrite|rec|repeat|return|then|until|while)\b/,
+        boolean: /\b(?:false|true)\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: {
+          pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+          lookbehind: true
+        },
+        continuation: {
+          pattern: /([\r\n])>/,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        operator: /->|[-+*/^~=!]|<>|[<>]=?|:=|\.\./,
+        punctuation: /[()[\]{},;.:]/
+      };
+      Prism.languages.gap.shell.inside.gap.inside = Prism.languages.gap;
+    }
+  }
+});
+
+export {
+  require_gap
+};

package/dist/chunk-5OHRFMBB.js

@@ -0,0 +1,67 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/uorazor.js
+var require_uorazor = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/uorazor.js"(exports, module) {
+    module.exports = uorazor;
+    uorazor.displayName = "uorazor";
+    uorazor.aliases = [];
+    function uorazor(Prism) {
+      Prism.languages.uorazor = {
+        "comment-hash": {
+          pattern: /#.*/,
+          alias: "comment",
+          greedy: true
+        },
+        "comment-slash": {
+          pattern: /\/\/.*/,
+          alias: "comment",
+          greedy: true
+        },
+        string: {
+          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          inside: {
+            punctuation: /^['"]|['"]$/
+          },
+          greedy: true
+        },
+        "source-layers": {
+          pattern: /\b(?:arms|backpack|blue|bracelet|cancel|clear|cloak|criminal|earrings|enemy|facialhair|friend|friendly|gloves|gray|grey|ground|hair|head|innerlegs|innertorso|innocent|lefthand|middletorso|murderer|neck|nonfriendly|onehandedsecondary|outerlegs|outertorso|pants|red|righthand|ring|self|shirt|shoes|talisman|waist)\b/i,
+          alias: "function"
+        },
+        "source-commands": {
+          pattern: /\b(?:alliance|attack|cast|clearall|clearignore|clearjournal|clearlist|clearsysmsg|createlist|createtimer|dclick|dclicktype|dclickvar|dress|dressconfig|drop|droprelloc|emote|getlabel|guild|gumpclose|gumpresponse|hotkey|ignore|lasttarget|lift|lifttype|menu|menuresponse|msg|org|organize|organizer|overhead|pause|poplist|potion|promptresponse|pushlist|removelist|removetimer|rename|restock|say|scav|scavenger|script|setability|setlasttarget|setskill|settimer|setvar|sysmsg|target|targetloc|targetrelloc|targettype|undress|unignore|unsetvar|useobject|useonce|useskill|usetype|virtue|wait|waitforgump|waitformenu|waitforprompt|waitforstat|waitforsysmsg|waitfortarget|walk|wfsysmsg|wft|whisper|yell)\b/,
+          alias: "function"
+        },
+        "tag-name": {
+          pattern: /(^\{%-?\s*)\w+/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        delimiter: {
+          pattern: /^\{[{%]-?|-?[%}]\}$/,
+          alias: "punctuation"
+        },
+        function: /\b(?:atlist|close|closest|count|counter|counttype|dead|dex|diffhits|diffmana|diffstam|diffweight|find|findbuff|finddebuff|findlayer|findtype|findtypelist|followers|gumpexists|hidden|hits|hp|hue|human|humanoid|ingump|inlist|insysmessage|insysmsg|int|invul|lhandempty|list|listexists|mana|maxhits|maxhp|maxmana|maxstam|maxweight|monster|mounted|name|next|noto|paralyzed|poisoned|position|prev|previous|queued|rand|random|rhandempty|skill|stam|str|targetexists|timer|timerexists|varexist|warmode|weight)\b/,
+        keyword: /\b(?:and|as|break|continue|else|elseif|endfor|endif|endwhile|for|if|loop|not|or|replay|stop|while)\b/,
+        boolean: /\b(?:false|null|true)\b/,
+        number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+        operator: [
+          {
+            pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
+            lookbehind: true
+          },
+          /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/
+        ],
+        punctuation: /[()\[\]{}:.,]/
+      };
+    }
+  }
+});
+
+export {
+  require_uorazor
+};

package/dist/chunk-5ONN2BWW.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-DYCT6UGG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/django.js
+var require_django = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/django.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = django;
+    django.displayName = "django";
+    django.aliases = ["jinja2"];
+    function django(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        Prism2.languages.django = {
+          comment: /^\{#[\s\S]*?#\}$/,
+          tag: {
+            pattern: /(^\{%[+-]?\s*)\w+/,
+            lookbehind: true,
+            alias: "keyword"
+          },
+          delimiter: {
+            pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
+            alias: "punctuation"
+          },
+          string: {
+            pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+            greedy: true
+          },
+          filter: {
+            pattern: /(\|)\w+/,
+            lookbehind: true,
+            alias: "function"
+          },
+          test: {
+            pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+            lookbehind: true,
+            alias: "function"
+          },
+          function: /\b[a-z_]\w+(?=\s*\()/i,
+          keyword: /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+          operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+          number: /\b\d+(?:\.\d+)?\b/,
+          boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
+          variable: /\b\w+\b/,
+          punctuation: /[{}[\](),.:;]/
+        };
+        var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g;
+        var markupTemplating = Prism2.languages["markup-templating"];
+        Prism2.hooks.add("before-tokenize", function(env) {
+          markupTemplating.buildPlaceholders(env, "django", pattern);
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          markupTemplating.tokenizePlaceholders(env, "django");
+        });
+        Prism2.languages.jinja2 = Prism2.languages.django;
+        Prism2.hooks.add("before-tokenize", function(env) {
+          markupTemplating.buildPlaceholders(env, "jinja2", pattern);
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          markupTemplating.tokenizePlaceholders(env, "jinja2");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_django
+};

package/dist/chunk-5SUD76JK.js

@@ -0,0 +1,67 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/keepalived.js
+var require_keepalived = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/keepalived.js"(exports, module) {
+    module.exports = keepalived;
+    keepalived.displayName = "keepalived";
+    keepalived.aliases = [];
+    function keepalived(Prism) {
+      Prism.languages.keepalived = {
+        comment: {
+          pattern: /[#!].*/,
+          greedy: true
+        },
+        string: {
+          pattern: /(^|[^\\])(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/,
+          lookbehind: true,
+          greedy: true
+        },
+        // support IPv4, IPv6, subnet mask
+        ip: {
+          pattern: RegExp(
+            /\b(?:(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){5}:(?:[\da-f]{1,4}:)?[\da-f]{1,4}|(?:[\da-f]{1,4}:){4}:(?:[\da-f]{1,4}:){0,2}[\da-f]{1,4}|(?:[\da-f]{1,4}:){3}:(?:[\da-f]{1,4}:){0,3}[\da-f]{1,4}|(?:[\da-f]{1,4}:){2}:(?:[\da-f]{1,4}:){0,4}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}<ipv4>|(?:[\da-f]{1,4}:){0,5}:<ipv4>|::(?:[\da-f]{1,4}:){0,5}<ipv4>|[\da-f]{1,4}::(?:[\da-f]{1,4}:){0,5}[\da-f]{1,4}|::(?:[\da-f]{1,4}:){0,6}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:)(?:\/\d{1,3})?|<ipv4>(?:\/\d{1,2})?)\b/.source.replace(
+              /<ipv4>/g,
+              function() {
+                return /(?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d))/.source;
+              }
+            ),
+            "i"
+          ),
+          alias: "number"
+        },
+        // support *nix / Windows, directory / file
+        path: {
+          pattern: /(\s)\/(?:[^\/\s]+\/)*[^\/\s]*|\b[a-zA-Z]:\\(?:[^\\\s]+\\)*[^\\\s]*/,
+          lookbehind: true,
+          alias: "string"
+        },
+        variable: /\$\{?\w+\}?/,
+        email: {
+          pattern: /[\w-]+@[\w-]+(?:\.[\w-]{2,3}){1,2}/,
+          alias: "string"
+        },
+        "conditional-configuration": {
+          pattern: /@\^?[\w-]+/,
+          alias: "variable"
+        },
+        operator: /=/,
+        property: /\b(?:BFD_CHECK|DNS_CHECK|FILE_CHECK|HTTP_GET|MISC_CHECK|NAME|PING_CHECK|SCRIPTS|SMTP_CHECK|SSL|SSL_GET|TCP_CHECK|UDP_CHECK|accept|advert_int|alpha|auth_pass|auth_type|authentication|bfd_cpu_affinity|bfd_instance|bfd_no_swap|bfd_priority|bfd_process_name|bfd_rlimit_rttime|bfd_rt_priority|bind_if|bind_port|bindto|ca|certificate|check_unicast_src|checker|checker_cpu_affinity|checker_log_all_failures|checker_no_swap|checker_priority|checker_rlimit_rttime|checker_rt_priority|child_wait_time|connect_ip|connect_port|connect_timeout|dbus_service_name|debug|default_interface|delay|delay_before_retry|delay_loop|digest|dont_track_primary|dynamic|dynamic_interfaces|enable_(?:dbus|script_security|sni|snmp_checker|snmp_rfc|snmp_rfcv2|snmp_rfcv3|snmp_vrrp|traps)|end|fall|fast_recovery|file|flag-[123]|fork_delay|full_command|fwmark|garp_group|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|global_defs|global_tracking|gna_interval|group|ha_suspend|hashed|helo_name|higher_prio_send_advert|hoplimit|http_protocol|hysteresis|idle_tx|include|inhibit_on_failure|init_fail|init_file|instance|interface|interfaces|interval|ip_family|ipvs_process_name|keepalived.conf|kernel_rx_buf_size|key|linkbeat_interfaces|linkbeat_use_polling|log_all_failures|log_unknown_vrids|lower_prio_no_advert|lthreshold|lvs_flush|lvs_flush_onstop|lvs_method|lvs_netlink_cmd_rcv_bufs|lvs_netlink_cmd_rcv_bufs_force|lvs_netlink_monitor_rcv_bufs|lvs_netlink_monitor_rcv_bufs_force|lvs_notify_fifo|lvs_notify_fifo_script|lvs_sched|lvs_sync_daemon|max_auto_priority|max_hops|mcast_src_ip|mh-fallback|mh-port|min_auto_priority_delay|min_rx|min_tx|misc_dynamic|misc_path|misc_timeout|multiplier|name|namespace_with_ipsets|native_ipv6|neighbor_ip|net_namespace|net_namespace_ipvs|nftables|nftables_counters|nftables_ifindex|nftables_priority|no_accept|no_checker_emails|no_email_faults|nopreempt|notification_email|notification_email_from|notify|notify_backup|notify_deleted|notify_down|notify_fault|notify_fifo|notify_fifo_script|notify_master|notify_master_rx_lower_pri|notify_priority_changes|notify_stop|notify_up|old_unicast_checksum|omega|ops|param_match|passive|password|path|persistence_engine|persistence_granularity|persistence_timeout|preempt|preempt_delay|priority|process|process_monitor_rcv_bufs|process_monitor_rcv_bufs_force|process_name|process_names|promote_secondaries|protocol|proxy_arp|proxy_arp_pvlan|quorum|quorum_down|quorum_max|quorum_up|random_seed|real_server|regex|regex_max_offset|regex_min_offset|regex_no_match|regex_options|regex_stack|reload_repeat|reload_time_file|require_reply|retry|rise|router_id|rs_init_notifies|script|script_user|sh-fallback|sh-port|shutdown_script|shutdown_script_timeout|skip_check_adv_addr|smtp_alert|smtp_alert_checker|smtp_alert_vrrp|smtp_connect_timeout|smtp_helo_name|smtp_server|snmp_socket|sorry_server|sorry_server_inhibit|sorry_server_lvs_method|source_ip|start|startup_script|startup_script_timeout|state|static_ipaddress|static_routes|static_rules|status_code|step|strict_mode|sync_group_tracking_weight|terminate_delay|timeout|track_bfd|track_file|track_group|track_interface|track_process|track_script|track_src_ip|ttl|type|umask|unicast_peer|unicast_src_ip|unicast_ttl|url|use_ipvlan|use_pid_dir|use_vmac|user|uthreshold|val[123]|version|virtual_ipaddress|virtual_ipaddress_excluded|virtual_router_id|virtual_routes|virtual_rules|virtual_server|virtual_server_group|virtualhost|vmac_xmit_base|vrrp|vrrp_(?:check_unicast_src|cpu_affinity|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|gna_interval|higher_prio_send_advert|instance|ipsets|iptables|lower_prio_no_advert|mcast_group4|mcast_group6|min_garp|netlink_cmd_rcv_bufs|netlink_cmd_rcv_bufs_force|netlink_monitor_rcv_bufs|netlink_monitor_rcv_bufs_force|no_swap|notify_fifo|notify_fifo_script|notify_priority_changes|priority|process_name|rlimit_rttime|rt_priority|rx_bufs_multiplier|rx_bufs_policy|script|skip_check_adv_addr|startup_delay|strict|sync_group|track_process|version)|warmup|weight)\b/,
+        constant: /\b(?:A|AAAA|AH|BACKUP|CNAME|DR|MASTER|MX|NAT|NS|PASS|SCTP|SOA|TCP|TUN|TXT|UDP|dh|fo|lblc|lblcr|lc|mh|nq|ovf|rr|sed|sh|wlc|wrr)\b/,
+        number: {
+          pattern: /(^|[^\w.-])-?\d+(?:\.\d+)?/,
+          lookbehind: true
+        },
+        boolean: /\b(?:false|no|off|on|true|yes)\b/,
+        punctuation: /[\{\}]/
+      };
+    }
+  }
+});
+
+export {
+  require_keepalived
+};

package/dist/chunk-5U3JUGOR.js

@@ -0,0 +1,55 @@
+"use client";
+import {
+  require_php
+} from "./chunk-VXO6WZ3Z.js";
+import {
+  require_javadoclike
+} from "./chunk-CPE7WTCO.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/phpdoc.js
+var require_phpdoc = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/phpdoc.js"(exports, module) {
+    var refractorPhp = require_php();
+    var refractorJavadoclike = require_javadoclike();
+    module.exports = phpdoc;
+    phpdoc.displayName = "phpdoc";
+    phpdoc.aliases = [];
+    function phpdoc(Prism) {
+      Prism.register(refractorPhp);
+      Prism.register(refractorJavadoclike);
+      (function(Prism2) {
+        var typeExpression = /(?:\b[a-zA-Z]\w*|[|\\[\]])+/.source;
+        Prism2.languages.phpdoc = Prism2.languages.extend("javadoclike", {
+          parameter: {
+            pattern: RegExp(
+              "(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" + typeExpression + "\\s+)?)\\$\\w+"
+            ),
+            lookbehind: true
+          }
+        });
+        Prism2.languages.insertBefore("phpdoc", "keyword", {
+          "class-name": [
+            {
+              pattern: RegExp(
+                "(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\s+)" + typeExpression
+              ),
+              lookbehind: true,
+              inside: {
+                keyword: /\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\b/,
+                punctuation: /[|\\[\]()]/
+              }
+            }
+          ]
+        });
+        Prism2.languages.javadoclike.addSupport("php", Prism2.languages.phpdoc);
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_phpdoc
+};

package/dist/chunk-5WGGQBDN.js

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

package/dist/chunk-65KJS5T6.js

@@ -0,0 +1,112 @@
+"use client";
+import {
+  require_typescript
+} from "./chunk-P4DAHZUQ.js";
+import {
+  require_javadoclike
+} from "./chunk-CPE7WTCO.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsdoc.js
+var require_jsdoc = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsdoc.js"(exports, module) {
+    var refractorJavadoclike = require_javadoclike();
+    var refractorTypescript = require_typescript();
+    module.exports = jsdoc;
+    jsdoc.displayName = "jsdoc";
+    jsdoc.aliases = [];
+    function jsdoc(Prism) {
+      Prism.register(refractorJavadoclike);
+      Prism.register(refractorTypescript);
+      (function(Prism2) {
+        var javascript = Prism2.languages.javascript;
+        var type = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source;
+        var parameterPrefix = "(@(?:arg|argument|param|property)\\s+(?:" + type + "\\s+)?)";
+        Prism2.languages.jsdoc = Prism2.languages.extend("javadoclike", {
+          parameter: {
+            // @param {string} foo - foo bar
+            pattern: RegExp(
+              parameterPrefix + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source
+            ),
+            lookbehind: true,
+            inside: {
+              punctuation: /\./
+            }
+          }
+        });
+        Prism2.languages.insertBefore("jsdoc", "keyword", {
+          "optional-parameter": {
+            // @param {string} [baz.foo="bar"] foo bar
+            pattern: RegExp(
+              parameterPrefix + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source
+            ),
+            lookbehind: true,
+            inside: {
+              parameter: {
+                pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/,
+                lookbehind: true,
+                inside: {
+                  punctuation: /\./
+                }
+              },
+              code: {
+                pattern: /(=)[\s\S]*(?=\]$)/,
+                lookbehind: true,
+                inside: javascript,
+                alias: "language-javascript"
+              },
+              punctuation: /[=[\]]/
+            }
+          },
+          "class-name": [
+            {
+              pattern: RegExp(
+                /(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(
+                  /<TYPE>/g,
+                  function() {
+                    return type;
+                  }
+                )
+              ),
+              lookbehind: true,
+              inside: {
+                punctuation: /\./
+              }
+            },
+            {
+              pattern: RegExp("(@[a-z]+\\s+)" + type),
+              lookbehind: true,
+              inside: {
+                string: javascript.string,
+                number: javascript.number,
+                boolean: javascript.boolean,
+                keyword: Prism2.languages.typescript.keyword,
+                operator: /=>|\.\.\.|[&|?:*]/,
+                punctuation: /[.,;=<>{}()[\]]/
+              }
+            }
+          ],
+          example: {
+            pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/,
+            lookbehind: true,
+            inside: {
+              code: {
+                pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m,
+                lookbehind: true,
+                inside: javascript,
+                alias: "language-javascript"
+              }
+            }
+          }
+        });
+        Prism2.languages.javadoclike.addSupport("javascript", Prism2.languages.jsdoc);
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_jsdoc
+};

package/dist/chunk-6ADGDPPW.js

@@ -0,0 +1,79 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tremor.js
+var require_tremor = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tremor.js"(exports, module) {
+    module.exports = tremor;
+    tremor.displayName = "tremor";
+    tremor.aliases = [];
+    function tremor(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.tremor = {
+          comment: {
+            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+            lookbehind: true
+          },
+          "interpolated-string": null,
+          // see below
+          extractor: {
+            pattern: /\b[a-z_]\w*\|(?:[^\r\n\\|]|\\(?:\r\n|[\s\S]))*\|/i,
+            greedy: true,
+            inside: {
+              regex: {
+                pattern: /(^re)\|[\s\S]+/,
+                lookbehind: true
+              },
+              function: /^\w+/,
+              value: /\|[\s\S]+/
+            }
+          },
+          identifier: {
+            pattern: /`[^`]*`/,
+            greedy: true
+          },
+          function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())\b/,
+          keyword: /\b(?:args|as|by|case|config|connect|connector|const|copy|create|default|define|deploy|drop|each|emit|end|erase|event|flow|fn|for|from|group|having|insert|into|intrinsic|let|links|match|merge|mod|move|of|operator|patch|pipeline|recur|script|select|set|sliding|state|stream|to|tumbling|update|use|when|where|window|with)\b/,
+          boolean: /\b(?:false|null|true)\b/i,
+          number: /\b(?:0b[01_]*|0x[0-9a-fA-F_]*|\d[\d_]*(?:\.\d[\d_]*)?(?:[Ee][+-]?[\d_]+)?)\b/,
+          "pattern-punctuation": {
+            pattern: /%(?=[({[])/,
+            alias: "punctuation"
+          },
+          operator: /[-+*\/%~!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?>?=?|(?:absent|and|not|or|present|xor)\b/,
+          punctuation: /::|[;\[\]()\{\},.:]/
+        };
+        var interpolationPattern = /#\{(?:[^"{}]|\{[^{}]*\}|"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*")*\}/.source;
+        Prism2.languages.tremor["interpolated-string"] = {
+          pattern: RegExp(
+            /(^|[^\\])/.source + '(?:"""(?:' + /[^"\\#]|\\[\s\S]|"(?!"")|#(?!\{)/.source + "|" + interpolationPattern + ')*"""|"(?:' + /[^"\\\r\n#]|\\(?:\r\n|[\s\S])|#(?!\{)/.source + "|" + interpolationPattern + ')*")'
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: RegExp(interpolationPattern),
+              inside: {
+                punctuation: /^#\{|\}$/,
+                expression: {
+                  pattern: /[\s\S]+/,
+                  inside: Prism2.languages.tremor
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        };
+        Prism2.languages.troy = Prism2.languages["tremor"];
+        Prism2.languages.trickle = Prism2.languages["tremor"];
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_tremor
+};