@distri/react 0.3.1 → 0.3.2

package/dist/chunk-PSILHWIJ.js

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

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

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

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

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

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