@distri/react 0.2.8 → 0.3.1

package/dist/chunk-TYBQXIHB.js

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

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

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

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

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

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

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

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