@distri/react 0.3.2 → 0.3.4

package/dist/chunk-PSILHWIJ.js

@@ -1,84 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/css.js
-var require_css = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/css.js"(exports, module) {
-    module.exports = css;
-    css.displayName = "css";
-    css.aliases = [];
-    function css(Prism) {
-      ;
-      (function(Prism2) {
-        var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
-        Prism2.languages.css = {
-          comment: /\/\*[\s\S]*?\*\//,
-          atrule: {
-            pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
-            inside: {
-              rule: /^@[\w-]+/,
-              "selector-function-argument": {
-                pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
-                lookbehind: true,
-                alias: "selector"
-              },
-              keyword: {
-                pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
-                lookbehind: true
-              }
-              // See rest below
-            }
-          },
-          url: {
-            // https://drafts.csswg.org/css-values-3/#urls
-            pattern: RegExp(
-              "\\burl\\((?:" + string.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)",
-              "i"
-            ),
-            greedy: true,
-            inside: {
-              function: /^url/i,
-              punctuation: /^\(|\)$/,
-              string: {
-                pattern: RegExp("^" + string.source + "$"),
-                alias: "url"
-              }
-            }
-          },
-          selector: {
-            pattern: RegExp(
-              `(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + string.source + ")*(?=\\s*\\{)"
-            ),
-            lookbehind: true
-          },
-          string: {
-            pattern: string,
-            greedy: true
-          },
-          property: {
-            pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
-            lookbehind: true
-          },
-          important: /!important\b/i,
-          function: {
-            pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
-            lookbehind: true
-          },
-          punctuation: /[(){};:,]/
-        };
-        Prism2.languages.css["atrule"].inside.rest = Prism2.languages.css;
-        var markup = Prism2.languages.markup;
-        if (markup) {
-          markup.tag.addInlined("style", "css");
-          markup.tag.addAttribute("style", "css");
-        }
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_css
-};

package/dist/chunk-PSSNU4KS.js

@@ -1,121 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/docker.js
-var require_docker = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/docker.js"(exports, module) {
-    module.exports = docker;
-    docker.displayName = "docker";
-    docker.aliases = ["dockerfile"];
-    function docker(Prism) {
-      ;
-      (function(Prism2) {
-        var spaceAfterBackSlash = /\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source;
-        var space = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(
-          /<SP_BS>/g,
-          function() {
-            return spaceAfterBackSlash;
-          }
-        );
-        var string = /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/.source;
-        var option = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(
-          /<STR>/g,
-          function() {
-            return string;
-          }
-        );
-        var stringRule = {
-          pattern: RegExp(string),
-          greedy: true
-        };
-        var commentRule = {
-          pattern: /(^[ \t]*)#.*/m,
-          lookbehind: true,
-          greedy: true
-        };
-        function re(source, flags) {
-          source = source.replace(/<OPT>/g, function() {
-            return option;
-          }).replace(/<SP>/g, function() {
-            return space;
-          });
-          return RegExp(source, flags);
-        }
-        Prism2.languages.docker = {
-          instruction: {
-            pattern: /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              options: {
-                pattern: re(
-                  /(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,
-                  "i"
-                ),
-                lookbehind: true,
-                greedy: true,
-                inside: {
-                  property: {
-                    pattern: /(^|\s)--[\w-]+/,
-                    lookbehind: true
-                  },
-                  string: [
-                    stringRule,
-                    {
-                      pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
-                      lookbehind: true
-                    }
-                  ],
-                  operator: /\\$/m,
-                  punctuation: /=/
-                }
-              },
-              keyword: [
-                {
-                  // https://docs.docker.com/engine/reference/builder/#healthcheck
-                  pattern: re(
-                    /(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/.source,
-                    "i"
-                  ),
-                  lookbehind: true,
-                  greedy: true
-                },
-                {
-                  // https://docs.docker.com/engine/reference/builder/#from
-                  pattern: re(
-                    /(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/.source,
-                    "i"
-                  ),
-                  lookbehind: true,
-                  greedy: true
-                },
-                {
-                  // https://docs.docker.com/engine/reference/builder/#onbuild
-                  pattern: re(/(^ONBUILD<SP>)\w+/.source, "i"),
-                  lookbehind: true,
-                  greedy: true
-                },
-                {
-                  pattern: /^\w+/,
-                  greedy: true
-                }
-              ],
-              comment: commentRule,
-              string: stringRule,
-              variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
-              operator: /\\$/m
-            }
-          },
-          comment: commentRule
-        };
-        Prism2.languages.dockerfile = Prism2.languages.docker;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_docker
-};

package/dist/chunk-PU3XOBI7.js

@@ -1,111 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/java.js
-var require_java = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/java.js"(exports, module) {
-    module.exports = java;
-    java.displayName = "java";
-    java.aliases = [];
-    function java(Prism) {
-      ;
-      (function(Prism2) {
-        var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
-        var classNamePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
-        var className = {
-          pattern: RegExp(classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
-          lookbehind: true,
-          inside: {
-            namespace: {
-              pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-              inside: {
-                punctuation: /\./
-              }
-            },
-            punctuation: /\./
-          }
-        };
-        Prism2.languages.java = Prism2.languages.extend("clike", {
-          string: {
-            pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
-            lookbehind: true,
-            greedy: true
-          },
-          "class-name": [
-            className,
-            {
-              // variables and parameters
-              // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-              pattern: RegExp(
-                classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
-              ),
-              lookbehind: true,
-              inside: className.inside
-            }
-          ],
-          keyword: keywords,
-          function: [
-            Prism2.languages.clike.function,
-            {
-              pattern: /(::\s*)[a-z_]\w*/,
-              lookbehind: true
-            }
-          ],
-          number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
-          operator: {
-            pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
-            lookbehind: true
-          }
-        });
-        Prism2.languages.insertBefore("java", "string", {
-          "triple-quoted-string": {
-            // http://openjdk.java.net/jeps/355#Description
-            pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
-            greedy: true,
-            alias: "string"
-          },
-          char: {
-            pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
-            greedy: true
-          }
-        });
-        Prism2.languages.insertBefore("java", "class-name", {
-          annotation: {
-            pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
-            lookbehind: true,
-            alias: "punctuation"
-          },
-          generics: {
-            pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
-            inside: {
-              "class-name": className,
-              keyword: keywords,
-              punctuation: /[<>(),.:]/,
-              operator: /[?&|]/
-            }
-          },
-          namespace: {
-            pattern: RegExp(
-              /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(
-                /<keyword>/g,
-                function() {
-                  return keywords.source;
-                }
-              )
-            ),
-            lookbehind: true,
-            inside: {
-              punctuation: /\./
-            }
-          }
-        });
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_java
-};

package/dist/chunk-PVUHXI4V.js

@@ -1,123 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mermaid.js
-var require_mermaid = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mermaid.js"(exports, module) {
-    module.exports = mermaid;
-    mermaid.displayName = "mermaid";
-    mermaid.aliases = [];
-    function mermaid(Prism) {
-      Prism.languages.mermaid = {
-        comment: {
-          pattern: /%%.*/,
-          greedy: true
-        },
-        style: {
-          pattern: /^([ \t]*(?:classDef|linkStyle|style)[ \t]+[\w$-]+[ \t]+)\w.*[^\s;]/m,
-          lookbehind: true,
-          inside: {
-            property: /\b\w[\w-]*(?=[ \t]*:)/,
-            operator: /:/,
-            punctuation: /,/
-          }
-        },
-        "inter-arrow-label": {
-          pattern: /([^<>ox.=-])(?:-[-.]|==)(?![<>ox.=-])[ \t]*(?:"[^"\r\n]*"|[^\s".=-](?:[^\r\n.=-]*[^\s.=-])?)[ \t]*(?:\.+->?|--+[->]|==+[=>])(?![<>ox.=-])/,
-          lookbehind: true,
-          greedy: true,
-          inside: {
-            arrow: {
-              pattern: /(?:\.+->?|--+[->]|==+[=>])$/,
-              alias: "operator"
-            },
-            label: {
-              pattern: /^([\s\S]{2}[ \t]*)\S(?:[\s\S]*\S)?/,
-              lookbehind: true,
-              alias: "property"
-            },
-            "arrow-head": {
-              pattern: /^\S+/,
-              alias: ["arrow", "operator"]
-            }
-          }
-        },
-        arrow: [
-          // This might look complex but it really isn't.
-          // There are many possible arrows (see tests) and it's impossible to fit all of them into one pattern. The
-          // problem is that we only have one lookbehind per pattern. However, we cannot disallow too many arrow
-          // characters in the one lookbehind because that would create too many false negatives. So we have to split the
-          // arrows into different patterns.
-          {
-            // ER diagram
-            pattern: /(^|[^{}|o.-])[|}][|o](?:--|\.\.)[|o][|{](?![{}|o.-])/,
-            lookbehind: true,
-            alias: "operator"
-          },
-          {
-            // flow chart
-            // (?:==+|--+|-\.*-)
-            pattern: /(^|[^<>ox.=-])(?:[<ox](?:==+|--+|-\.*-)[>ox]?|(?:==+|--+|-\.*-)[>ox]|===+|---+|-\.+-)(?![<>ox.=-])/,
-            lookbehind: true,
-            alias: "operator"
-          },
-          {
-            // sequence diagram
-            pattern: /(^|[^<>()x-])(?:--?(?:>>|[x>)])(?![<>()x])|(?:<<|[x<(])--?(?!-))/,
-            lookbehind: true,
-            alias: "operator"
-          },
-          {
-            // class diagram
-            pattern: /(^|[^<>|*o.-])(?:[*o]--|--[*o]|<\|?(?:--|\.\.)|(?:--|\.\.)\|?>|--|\.\.)(?![<>|*o.-])/,
-            lookbehind: true,
-            alias: "operator"
-          }
-        ],
-        label: {
-          pattern: /(^|[^|<])\|(?:[^\r\n"|]|"[^"\r\n]*")+\|/,
-          lookbehind: true,
-          greedy: true,
-          alias: "property"
-        },
-        text: {
-          pattern: /(?:[(\[{]+|\b>)(?:[^\r\n"()\[\]{}]|"[^"\r\n]*")+(?:[)\]}]+|>)/,
-          alias: "string"
-        },
-        string: {
-          pattern: /"[^"\r\n]*"/,
-          greedy: true
-        },
-        annotation: {
-          pattern: /<<(?:abstract|choice|enumeration|fork|interface|join|service)>>|\[\[(?:choice|fork|join)\]\]/i,
-          alias: "important"
-        },
-        keyword: [
-          // This language has both case-sensitive and case-insensitive keywords
-          {
-            pattern: /(^[ \t]*)(?:action|callback|class|classDef|classDiagram|click|direction|erDiagram|flowchart|gantt|gitGraph|graph|journey|link|linkStyle|pie|requirementDiagram|sequenceDiagram|stateDiagram|stateDiagram-v2|style|subgraph)(?![\w$-])/m,
-            lookbehind: true,
-            greedy: true
-          },
-          {
-            pattern: /(^[ \t]*)(?:activate|alt|and|as|autonumber|deactivate|else|end(?:[ \t]+note)?|loop|opt|par|participant|rect|state|note[ \t]+(?:over|(?:left|right)[ \t]+of))(?![\w$-])/im,
-            lookbehind: true,
-            greedy: true
-          }
-        ],
-        entity: /#[a-z0-9]+;/,
-        operator: {
-          pattern: /(\w[ \t]*)&(?=[ \t]*\w)|:::|:/,
-          lookbehind: true
-        },
-        punctuation: /[(){};]/
-      };
-    }
-  }
-});
-
-export {
-  require_mermaid
-};

package/dist/chunk-Q2EUB6IK.js

@@ -1,41 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ignore.js
-var require_ignore = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ignore.js"(exports, module) {
-    module.exports = ignore;
-    ignore.displayName = "ignore";
-    ignore.aliases = ["gitignore", "hgignore", "npmignore"];
-    function ignore(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.ignore = {
-          // https://git-scm.com/docs/gitignore
-          comment: /^#.*/m,
-          entry: {
-            pattern: /\S(?:.*(?:(?:\\ )|\S))?/,
-            alias: "string",
-            inside: {
-              operator: /^!|\*\*?|\?/,
-              regex: {
-                pattern: /(^|[^\\])\[[^\[\]]*\]/,
-                lookbehind: true
-              },
-              punctuation: /\//
-            }
-          }
-        };
-        Prism2.languages.gitignore = Prism2.languages.ignore;
-        Prism2.languages.hgignore = Prism2.languages.ignore;
-        Prism2.languages.npmignore = Prism2.languages.ignore;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_ignore
-};

package/dist/chunk-Q6JXYTWV.js

@@ -1,115 +0,0 @@
-"use client";
-import {
-  require_markup_templating
-} from "./chunk-XUQ4ZZPG.js";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/soy.js
-var require_soy = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/soy.js"(exports, module) {
-    var refractorMarkupTemplating = require_markup_templating();
-    module.exports = soy;
-    soy.displayName = "soy";
-    soy.aliases = [];
-    function soy(Prism) {
-      Prism.register(refractorMarkupTemplating);
-      (function(Prism2) {
-        var stringPattern = /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
-        var numberPattern = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-F]+\b/;
-        Prism2.languages.soy = {
-          comment: [
-            /\/\*[\s\S]*?\*\//,
-            {
-              pattern: /(\s)\/\/.*/,
-              lookbehind: true,
-              greedy: true
-            }
-          ],
-          "command-arg": {
-            pattern: /(\{+\/?\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\s+)\.?[\w.]+/,
-            lookbehind: true,
-            alias: "string",
-            inside: {
-              punctuation: /\./
-            }
-          },
-          parameter: {
-            pattern: /(\{+\/?\s*@?param\??\s+)\.?[\w.]+/,
-            lookbehind: true,
-            alias: "variable"
-          },
-          keyword: [
-            {
-              pattern: /(\{+\/?[^\S\r\n]*)(?:\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\??|rb|sp|switch|template|xid)/,
-              lookbehind: true
-            },
-            /\b(?:any|as|attributes|bool|css|float|html|in|int|js|list|map|null|number|string|uri)\b/
-          ],
-          delimiter: {
-            pattern: /^\{+\/?|\/?\}+$/,
-            alias: "punctuation"
-          },
-          property: /\w+(?==)/,
-          variable: {
-            pattern: /\$[^\W\d]\w*(?:\??(?:\.\w+|\[[^\]]+\]))*/,
-            inside: {
-              string: {
-                pattern: stringPattern,
-                greedy: true
-              },
-              number: numberPattern,
-              punctuation: /[\[\].?]/
-            }
-          },
-          string: {
-            pattern: stringPattern,
-            greedy: true
-          },
-          function: [
-            /\w+(?=\()/,
-            {
-              pattern: /(\|[^\S\r\n]*)\w+/,
-              lookbehind: true
-            }
-          ],
-          boolean: /\b(?:false|true)\b/,
-          number: numberPattern,
-          operator: /\?:?|<=?|>=?|==?|!=|[+*/%-]|\b(?:and|not|or)\b/,
-          punctuation: /[{}()\[\]|.,:]/
-        };
-        Prism2.hooks.add("before-tokenize", function(env) {
-          var soyPattern = /\{\{.+?\}\}|\{.+?\}|\s\/\/.*|\/\*[\s\S]*?\*\//g;
-          var soyLitteralStart = "{literal}";
-          var soyLitteralEnd = "{/literal}";
-          var soyLitteralMode = false;
-          Prism2.languages["markup-templating"].buildPlaceholders(
-            env,
-            "soy",
-            soyPattern,
-            function(match) {
-              if (match === soyLitteralEnd) {
-                soyLitteralMode = false;
-              }
-              if (!soyLitteralMode) {
-                if (match === soyLitteralStart) {
-                  soyLitteralMode = true;
-                }
-                return true;
-              }
-              return false;
-            }
-          );
-        });
-        Prism2.hooks.add("after-tokenize", function(env) {
-          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "soy");
-        });
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_soy
-};