@distri/react 0.2.7 → 0.2.8

package/dist/chunk-TYBQXIHB.js

@@ -0,0 +1,132 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scheme.js
+var require_scheme = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scheme.js"(exports, module) {
+    module.exports = scheme;
+    scheme.displayName = "scheme";
+    scheme.aliases = [];
+    function scheme(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.scheme = {
+          // this supports "normal" single-line comments:
+          //   ; comment
+          // and (potentially nested) multiline comments:
+          //   #| comment #| nested |# still comment |#
+          // (only 1 level of nesting is supported)
+          comment: /;.*|#;\s*(?:\((?:[^()]|\([^()]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\])|#\|(?:[^#|]|#(?!\|)|\|(?!#)|#\|(?:[^#|]|#(?!\|)|\|(?!#))*\|#)*\|#/,
+          string: {
+            pattern: /"(?:[^"\\]|\\.)*"/,
+            greedy: true
+          },
+          symbol: {
+            pattern: /'[^()\[\]#'\s]+/,
+            greedy: true
+          },
+          char: {
+            pattern: /#\\(?:[ux][a-fA-F\d]+\b|[-a-zA-Z]+\b|[\uD800-\uDBFF][\uDC00-\uDFFF]|\S)/,
+            greedy: true
+          },
+          "lambda-parameter": [
+            // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30
+            {
+              pattern: /((?:^|[^'`#])[(\[]lambda\s+)(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)/,
+              lookbehind: true
+            },
+            {
+              pattern: /((?:^|[^'`#])[(\[]lambda\s+[(\[])[^()\[\]']+/,
+              lookbehind: true
+            }
+          ],
+          keyword: {
+            pattern: /((?:^|[^'`#])[(\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\*)?|let\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\[\]\s]|$)/,
+            lookbehind: true
+          },
+          builtin: {
+            // all functions of the base library of R7RS plus some of built-ins of R5Rs
+            pattern: /((?:^|[^'`#])[(\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\?|boolean=?\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\?|\?|<\?|<=\?|=\?|>\?|>=\?)|close-(?:input-port|output-port|port)|complex\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\??|eq\?|equal\?|eqv\?|error|error-object(?:-irritants|-message|\?)|eval|even\?|exact(?:-integer-sqrt|-integer\?|\?)?|expt|features|file-error\?|floor(?:-quotient|-remainder|\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\??|input-port(?:-open\?|\?)|integer(?:->char|\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\?|newline|not|null\?|number(?:->string|\?)|numerator|odd\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\?|\?)|pair\?|peek-char|peek-u8|port\?|positive\?|procedure\?|quotient|raise|raise-continuable|rational\?|rationalize|read-(?:bytevector|bytevector!|char|error\?|line|string|u8)|real\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?|<\?|<=\?|=\?|>\?|>=\?)?|substring|symbol(?:->string|\?|=\?)|syntax-error|textual-port\?|truncate(?:-quotient|-remainder|\/)?|u8-ready\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\?)(?=[()\[\]\s]|$)/,
+            lookbehind: true
+          },
+          operator: {
+            pattern: /((?:^|[^'`#])[(\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\[\]\s]|$)/,
+            lookbehind: true
+          },
+          number: {
+            // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).
+            //
+            // <number>      := <num 2>|<num 8>|<num 10>|<num 16>
+            // <num R>       := <prefix R><complex R>
+            // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>
+            // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\.0)?i
+            // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\.0
+            // <ureal R>     := <uint R>(?:\/<uint R>)?
+            //                | <decimal R>
+            //
+            // <decimal 10>  := (?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?
+            // <uint R>      := <digit R>+
+            // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>
+            // <radix 2>     := #b
+            // <radix 8>     := #o
+            // <radix 10>    := (?:#d)?
+            // <radix 16>    := #x
+            // <digit 2>     := [01]
+            // <digit 8>     := [0-7]
+            // <digit 10>    := \d
+            // <digit 16>    := [0-9a-f]
+            //
+            // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all
+            // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)
+            // pattern:
+            pattern: RegExp(
+              SortedBNF({
+                "<ureal dec>": /\d+(?:\/\d+)|(?:\d+(?:\.\d*)?|\.\d+)(?:[esfdl][+-]?\d+)?/.source,
+                "<real dec>": /[+-]?<ureal dec>|[+-](?:inf|nan)\.0/.source,
+                "<imaginary dec>": /[+-](?:<ureal dec>|(?:inf|nan)\.0)?i/.source,
+                "<complex dec>": /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/.source,
+                "<num dec>": /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,
+                "<ureal box>": /[0-9a-f]+(?:\/[0-9a-f]+)?/.source,
+                "<real box>": /[+-]?<ureal box>|[+-](?:inf|nan)\.0/.source,
+                "<imaginary box>": /[+-](?:<ureal box>|(?:inf|nan)\.0)?i/.source,
+                "<complex box>": /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/.source,
+                "<num box>": /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/.source,
+                "<number>": /(^|[()\[\]\s])(?:<num dec>|<num box>)(?=[()\[\]\s]|$)/.source
+              }),
+              "i"
+            ),
+            lookbehind: true
+          },
+          boolean: {
+            pattern: /(^|[()\[\]\s])#(?:[ft]|false|true)(?=[()\[\]\s]|$)/,
+            lookbehind: true
+          },
+          function: {
+            pattern: /((?:^|[^'`#])[(\[])(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)(?=[()\[\]\s]|$)/,
+            lookbehind: true
+          },
+          identifier: {
+            pattern: /(^|[()\[\]\s])\|(?:[^\\|]|\\.)*\|(?=[()\[\]\s]|$)/,
+            lookbehind: true,
+            greedy: true
+          },
+          punctuation: /[()\[\]']/
+        };
+        function SortedBNF(grammar) {
+          for (var key in grammar) {
+            grammar[key] = grammar[key].replace(/<[\w\s]+>/g, function(key2) {
+              return "(?:" + grammar[key2].trim() + ")";
+            });
+          }
+          return grammar[key];
+        }
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_scheme
+};

package/dist/chunk-U6KZOUWP.js

@@ -0,0 +1,97 @@
+"use client";
+import {
+  require_php
+} from "./chunk-VXO6WZ3Z.js";
+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/latte.js
+var require_latte = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/latte.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    var refractorPhp = require_php();
+    module.exports = latte;
+    latte.displayName = "latte";
+    latte.aliases = [];
+    function latte(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      Prism.register(refractorPhp);
+      (function(Prism2) {
+        Prism2.languages.latte = {
+          comment: /^\{\*[\s\S]*/,
+          "latte-tag": {
+            // https://latte.nette.org/en/tags
+            pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i,
+            lookbehind: true,
+            alias: "important"
+          },
+          delimiter: {
+            pattern: /^\{\/?|\}$/,
+            alias: "punctuation"
+          },
+          php: {
+            pattern: /\S(?:[\s\S]*\S)?/,
+            alias: "language-php",
+            inside: Prism2.languages.php
+          }
+        };
+        var markupLatte = Prism2.languages.extend("markup", {});
+        Prism2.languages.insertBefore(
+          "inside",
+          "attr-value",
+          {
+            "n-attr": {
+              pattern: /n:[\w-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+))?/,
+              inside: {
+                "attr-name": {
+                  pattern: /^[^\s=]+/,
+                  alias: "important"
+                },
+                "attr-value": {
+                  pattern: /=[\s\S]+/,
+                  inside: {
+                    punctuation: [
+                      /^=/,
+                      {
+                        pattern: /^(\s*)["']|["']$/,
+                        lookbehind: true
+                      }
+                    ],
+                    php: {
+                      pattern: /\S(?:[\s\S]*\S)?/,
+                      inside: Prism2.languages.php
+                    }
+                  }
+                }
+              }
+            }
+          },
+          markupLatte.tag
+        );
+        Prism2.hooks.add("before-tokenize", function(env) {
+          if (env.language !== "latte") {
+            return;
+          }
+          var lattePattern = /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "latte",
+            lattePattern
+          );
+          env.grammar = markupLatte;
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "latte");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_latte
+};

package/dist/chunk-UAYBD6YK.js

@@ -0,0 +1,53 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/autoit.js
+var require_autoit = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/autoit.js"(exports, module) {
+    module.exports = autoit;
+    autoit.displayName = "autoit";
+    autoit.aliases = [];
+    function autoit(Prism) {
+      Prism.languages.autoit = {
+        comment: [
+          /;.*/,
+          {
+            // The multi-line comments delimiters can actually be commented out with ";"
+            pattern: /(^[\t ]*)#(?:comments-start|cs)[\s\S]*?^[ \t]*#(?:ce|comments-end)/m,
+            lookbehind: true
+          }
+        ],
+        url: {
+          pattern: /(^[\t ]*#include\s+)(?:<[^\r\n>]+>|"[^\r\n"]+")/m,
+          lookbehind: true
+        },
+        string: {
+          pattern: /(["'])(?:\1\1|(?!\1)[^\r\n])*\1/,
+          greedy: true,
+          inside: {
+            variable: /([%$@])\w+\1/
+          }
+        },
+        directive: {
+          pattern: /(^[\t ]*)#[\w-]+/m,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        function: /\b\w+(?=\()/,
+        // Variables and macros
+        variable: /[$@]\w+/,
+        keyword: /\b(?:Case|Const|Continue(?:Case|Loop)|Default|Dim|Do|Else(?:If)?|End(?:Func|If|Select|Switch|With)|Enum|Exit(?:Loop)?|For|Func|Global|If|In|Local|Next|Null|ReDim|Select|Static|Step|Switch|Then|To|Until|Volatile|WEnd|While|With)\b/i,
+        number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+        boolean: /\b(?:False|True)\b/i,
+        operator: /<[=>]?|[-+*\/=&>]=?|[?^]|\b(?:And|Not|Or)\b/i,
+        punctuation: /[\[\]().,:]/
+      };
+    }
+  }
+});
+
+export {
+  require_autoit
+};

package/dist/chunk-UBBKEK2F.js

@@ -0,0 +1,43 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/splunk-spl.js
+var require_splunk_spl = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/splunk-spl.js"(exports, module) {
+    module.exports = splunkSpl;
+    splunkSpl.displayName = "splunkSpl";
+    splunkSpl.aliases = [];
+    function splunkSpl(Prism) {
+      Prism.languages["splunk-spl"] = {
+        comment: /`comment\("(?:\\.|[^\\"])*"\)`/,
+        string: {
+          pattern: /"(?:\\.|[^\\"])*"/,
+          greedy: true
+        },
+        // https://docs.splunk.com/Documentation/Splunk/7.3.0/SearchReference/ListOfSearchCommands
+        keyword: /\b(?:abstract|accum|addcoltotals|addinfo|addtotals|analyzefields|anomalies|anomalousvalue|anomalydetection|append|appendcols|appendcsv|appendlookup|appendpipe|arules|associate|audit|autoregress|bin|bucket|bucketdir|chart|cluster|cofilter|collect|concurrency|contingency|convert|correlate|datamodel|dbinspect|dedup|delete|delta|diff|erex|eval|eventcount|eventstats|extract|fieldformat|fields|fieldsummary|filldown|fillnull|findtypes|folderize|foreach|format|from|gauge|gentimes|geom|geomfilter|geostats|head|highlight|history|iconify|input|inputcsv|inputlookup|iplocation|join|kmeans|kv|kvform|loadjob|localize|localop|lookup|makecontinuous|makemv|makeresults|map|mcollect|metadata|metasearch|meventcollect|mstats|multikv|multisearch|mvcombine|mvexpand|nomv|outlier|outputcsv|outputlookup|outputtext|overlap|pivot|predict|rangemap|rare|regex|relevancy|reltime|rename|replace|rest|return|reverse|rex|rtorder|run|savedsearch|script|scrub|search|searchtxn|selfjoin|sendemail|set|setfields|sichart|sirare|sistats|sitimechart|sitop|sort|spath|stats|strcat|streamstats|table|tags|tail|timechart|timewrap|top|transaction|transpose|trendline|tscollect|tstats|typeahead|typelearner|typer|union|uniq|untable|where|x11|xmlkv|xmlunescape|xpath|xyseries)\b/i,
+        "operator-word": {
+          pattern: /\b(?:and|as|by|not|or|xor)\b/i,
+          alias: "operator"
+        },
+        function: /\b\w+(?=\s*\()/,
+        property: /\b\w+(?=\s*=(?!=))/,
+        date: {
+          // MM/DD/YYYY(:HH:MM:SS)?
+          pattern: /\b\d{1,2}\/\d{1,2}\/\d{1,4}(?:(?::\d{1,2}){3})?\b/,
+          alias: "number"
+        },
+        number: /\b\d+(?:\.\d+)?\b/,
+        boolean: /\b(?:f|false|t|true)\b/i,
+        operator: /[<>=]=?|[-+*/%|]/,
+        punctuation: /[()[\],]/
+      };
+    }
+  }
+});
+
+export {
+  require_splunk_spl
+};

package/dist/chunk-UBOVR4MJ.js

@@ -0,0 +1,55 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/firestore-security-rules.js
+var require_firestore_security_rules = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/firestore-security-rules.js"(exports, module) {
+    module.exports = firestoreSecurityRules;
+    firestoreSecurityRules.displayName = "firestoreSecurityRules";
+    firestoreSecurityRules.aliases = [];
+    function firestoreSecurityRules(Prism) {
+      Prism.languages["firestore-security-rules"] = Prism.languages.extend(
+        "clike",
+        {
+          comment: /\/\/.*/,
+          keyword: /\b(?:allow|function|if|match|null|return|rules_version|service)\b/,
+          operator: /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/
+        }
+      );
+      delete Prism.languages["firestore-security-rules"]["class-name"];
+      Prism.languages.insertBefore("firestore-security-rules", "keyword", {
+        path: {
+          pattern: /(^|[\s(),])(?:\/(?:[\w\xA0-\uFFFF]+|\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)))+/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            variable: {
+              pattern: /\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)/,
+              inside: {
+                operator: /=/,
+                keyword: /\*\*/,
+                punctuation: /[.$(){}]/
+              }
+            },
+            punctuation: /\//
+          }
+        },
+        method: {
+          // to make the pattern shorter, the actual method names are omitted
+          pattern: /(\ballow\s+)[a-z]+(?:\s*,\s*[a-z]+)*(?=\s*[:;])/,
+          lookbehind: true,
+          alias: "builtin",
+          inside: {
+            punctuation: /,/
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_firestore_security_rules
+};

package/dist/chunk-UCYAOIJX.js

@@ -0,0 +1,106 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/yaml.js
+var require_yaml = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/yaml.js"(exports, module) {
+    module.exports = yaml;
+    yaml.displayName = "yaml";
+    yaml.aliases = ["yml"];
+    function yaml(Prism) {
+      ;
+      (function(Prism2) {
+        var anchorOrAlias = /[*&][^\s[\]{},]+/;
+        var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
+        var properties = "(?:" + tag.source + "(?:[ 	]+" + anchorOrAlias.source + ")?|" + anchorOrAlias.source + "(?:[ 	]+" + tag.source + ")?)";
+        var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+          /<PLAIN>/g,
+          function() {
+            return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+          }
+        );
+        var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+        function createValuePattern(value, flags) {
+          flags = (flags || "").replace(/m/g, "") + "m";
+          var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+            return properties;
+          }).replace(/<<value>>/g, function() {
+            return value;
+          });
+          return RegExp(pattern, flags);
+        }
+        Prism2.languages.yaml = {
+          scalar: {
+            pattern: RegExp(
+              /([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(
+                /<<prop>>/g,
+                function() {
+                  return properties;
+                }
+              )
+            ),
+            lookbehind: true,
+            alias: "string"
+          },
+          comment: /#.*/,
+          key: {
+            pattern: RegExp(
+              /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+                return properties;
+              }).replace(/<<key>>/g, function() {
+                return "(?:" + plainKey + "|" + string + ")";
+              })
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "atrule"
+          },
+          directive: {
+            pattern: /(^[ \t]*)%.+/m,
+            lookbehind: true,
+            alias: "important"
+          },
+          datetime: {
+            pattern: createValuePattern(
+              /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source
+            ),
+            lookbehind: true,
+            alias: "number"
+          },
+          boolean: {
+            pattern: createValuePattern(/false|true/.source, "i"),
+            lookbehind: true,
+            alias: "important"
+          },
+          null: {
+            pattern: createValuePattern(/null|~/.source, "i"),
+            lookbehind: true,
+            alias: "important"
+          },
+          string: {
+            pattern: createValuePattern(string),
+            lookbehind: true,
+            greedy: true
+          },
+          number: {
+            pattern: createValuePattern(
+              /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source,
+              "i"
+            ),
+            lookbehind: true
+          },
+          tag,
+          important: anchorOrAlias,
+          punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+        };
+        Prism2.languages.yml = Prism2.languages.yaml;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_yaml
+};

package/dist/chunk-UDSEA732.js

@@ -0,0 +1,89 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bicep.js
+var require_bicep = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bicep.js"(exports, module) {
+    module.exports = bicep;
+    bicep.displayName = "bicep";
+    bicep.aliases = [];
+    function bicep(Prism) {
+      Prism.languages.bicep = {
+        comment: [
+          {
+            // multiline comments eg /* ASDF */
+            pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            // singleline comments eg // ASDF
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        property: [
+          {
+            pattern: /([\r\n][ \t]*)[a-z_]\w*(?=[ \t]*:)/i,
+            lookbehind: true
+          },
+          {
+            pattern: /([\r\n][ \t]*)'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'(?=[ \t]*:)/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        string: [
+          {
+            pattern: /'''[^'][\s\S]*?'''/,
+            greedy: true
+          },
+          {
+            pattern: /(^|[^\\'])'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        "interpolated-string": {
+          pattern: /(^|[^\\'])'(?:\\.|\$(?:(?!\{)|\{[^{}\r\n]*\})|[^'\\\r\n$])*'/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /\$\{[^{}\r\n]*\}/,
+              inside: {
+                expression: {
+                  pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                  lookbehind: true
+                },
+                punctuation: /^\$\{|\}$/
+              }
+            },
+            string: /[\s\S]+/
+          }
+        },
+        datatype: {
+          pattern: /(\b(?:output|param)\b[ \t]+\w+[ \t]+)\w+\b/,
+          lookbehind: true,
+          alias: "class-name"
+        },
+        boolean: /\b(?:false|true)\b/,
+        // https://github.com/Azure/bicep/blob/114a3251b4e6e30082a58729f19a8cc4e374ffa6/src/textmate/bicep.tmlanguage#L184
+        keyword: /\b(?:existing|for|if|in|module|null|output|param|resource|targetScope|var)\b/,
+        decorator: /@\w+\b/,
+        function: /\b[a-z_]\w*(?=[ \t]*\()/i,
+        number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+        operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
+        punctuation: /[{}[\];(),.:]/
+      };
+      Prism.languages.bicep["interpolated-string"].inside["interpolation"].inside["expression"].inside = Prism.languages.bicep;
+    }
+  }
+});
+
+export {
+  require_bicep
+};

package/dist/chunk-UICM7ISL.js

@@ -0,0 +1,97 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/v.js
+var require_v = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/v.js"(exports, module) {
+    module.exports = v;
+    v.displayName = "v";
+    v.aliases = [];
+    function v(Prism) {
+      ;
+      (function(Prism2) {
+        var interpolationExpr = {
+          pattern: /[\s\S]+/,
+          inside: null
+        };
+        Prism2.languages.v = Prism2.languages.extend("clike", {
+          string: {
+            pattern: /r?(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+            alias: "quoted-string",
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[^{}]*\}|\w+(?:\.\w+(?:\([^\(\)]*\))?|\[[^\[\]]+\])*)/,
+                lookbehind: true,
+                inside: {
+                  "interpolation-variable": {
+                    pattern: /^\$\w[\s\S]*$/,
+                    alias: "variable"
+                  },
+                  "interpolation-punctuation": {
+                    pattern: /^\$\{|\}$/,
+                    alias: "punctuation"
+                  },
+                  "interpolation-expression": interpolationExpr
+                }
+              }
+            }
+          },
+          "class-name": {
+            pattern: /(\b(?:enum|interface|struct|type)\s+)(?:C\.)?\w+/,
+            lookbehind: true
+          },
+          keyword: /(?:\b(?:__global|as|asm|assert|atomic|break|chan|const|continue|defer|else|embed|enum|fn|for|go(?:to)?|if|import|in|interface|is|lock|match|module|mut|none|or|pub|return|rlock|select|shared|sizeof|static|struct|type(?:of)?|union|unsafe)|\$(?:else|for|if)|#(?:flag|include))\b/,
+          number: /\b(?:0x[a-f\d]+(?:_[a-f\d]+)*|0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?)\b/i,
+          operator: /~|\?|[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\.?/,
+          builtin: /\b(?:any(?:_float|_int)?|bool|byte(?:ptr)?|charptr|f(?:32|64)|i(?:8|16|64|128|nt)|rune|size_t|string|u(?:16|32|64|128)|voidptr)\b/
+        });
+        interpolationExpr.inside = Prism2.languages.v;
+        Prism2.languages.insertBefore("v", "string", {
+          char: {
+            pattern: /`(?:\\`|\\?[^`]{1,2})`/,
+            // using {1,2} instead of `u` flag for compatibility
+            alias: "rune"
+          }
+        });
+        Prism2.languages.insertBefore("v", "operator", {
+          attribute: {
+            pattern: /(^[\t ]*)\[(?:deprecated|direct_array_access|flag|inline|live|ref_only|typedef|unsafe_fn|windows_stdcall)\]/m,
+            lookbehind: true,
+            alias: "annotation",
+            inside: {
+              punctuation: /[\[\]]/,
+              keyword: /\w+/
+            }
+          },
+          generic: {
+            pattern: /<\w+>(?=\s*[\)\{])/,
+            inside: {
+              punctuation: /[<>]/,
+              "class-name": /\w+/
+            }
+          }
+        });
+        Prism2.languages.insertBefore("v", "function", {
+          "generic-function": {
+            // e.g. foo<T>( ...
+            pattern: /\b\w+\s*<\w+>(?=\()/,
+            inside: {
+              function: /^\w+/,
+              generic: {
+                pattern: /<\w+>/,
+                inside: Prism2.languages.v.generic.inside
+              }
+            }
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_v
+};