@distri/react 0.2.5 → 0.2.8

package/dist/chunk-BYU5NTFP.js

@@ -0,0 +1,77 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/csp.js
+var require_csp = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/csp.js"(exports, module) {
+    module.exports = csp;
+    csp.displayName = "csp";
+    csp.aliases = [];
+    function csp(Prism) {
+      ;
+      (function(Prism2) {
+        function value(source) {
+          return RegExp(
+            /([ \t])/.source + "(?:" + source + ")" + /(?=[\s;]|$)/.source,
+            "i"
+          );
+        }
+        Prism2.languages.csp = {
+          directive: {
+            pattern: /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
+            lookbehind: true,
+            alias: "property"
+          },
+          scheme: {
+            pattern: value(/[a-z][a-z0-9.+-]*:/.source),
+            lookbehind: true
+          },
+          none: {
+            pattern: value(/'none'/.source),
+            lookbehind: true,
+            alias: "keyword"
+          },
+          nonce: {
+            pattern: value(/'nonce-[-+/\w=]+'/.source),
+            lookbehind: true,
+            alias: "number"
+          },
+          hash: {
+            pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
+            lookbehind: true,
+            alias: "number"
+          },
+          host: {
+            pattern: value(
+              /[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source + "|" + /\*[^\s;,']*/.source + "|" + /[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source
+            ),
+            lookbehind: true,
+            alias: "url",
+            inside: {
+              important: /\*/
+            }
+          },
+          keyword: [
+            {
+              pattern: value(/'unsafe-[a-z-]+'/.source),
+              lookbehind: true,
+              alias: "unsafe"
+            },
+            {
+              pattern: value(/'[a-z-]+'/.source),
+              lookbehind: true,
+              alias: "safe"
+            }
+          ],
+          punctuation: /;/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_csp
+};

package/dist/chunk-C475R4FS.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-C4VUAB44.js

@@ -0,0 +1,52 @@
+"use client";
+import {
+  require_lua
+} from "./chunk-DWJTQN4Q.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/etlua.js
+var require_etlua = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/etlua.js"(exports, module) {
+    var refractorLua = require_lua();
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = etlua;
+    etlua.displayName = "etlua";
+    etlua.aliases = [];
+    function etlua(Prism) {
+      Prism.register(refractorLua);
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        Prism2.languages.etlua = {
+          delimiter: {
+            pattern: /^<%[-=]?|-?%>$/,
+            alias: "punctuation"
+          },
+          "language-lua": {
+            pattern: /[\s\S]+/,
+            inside: Prism2.languages.lua
+          }
+        };
+        Prism2.hooks.add("before-tokenize", function(env) {
+          var pattern = /<%[\s\S]+?%>/g;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "etlua",
+            pattern
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "etlua");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_etlua
+};

package/dist/chunk-C7D4KPR4.js

@@ -0,0 +1,79 @@
+"use client";
+import {
+  require_cpp
+} from "./chunk-N4CDNUSI.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/chaiscript.js
+var require_chaiscript = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/chaiscript.js"(exports, module) {
+    var refractorCpp = require_cpp();
+    module.exports = chaiscript;
+    chaiscript.displayName = "chaiscript";
+    chaiscript.aliases = [];
+    function chaiscript(Prism) {
+      Prism.register(refractorCpp);
+      Prism.languages.chaiscript = Prism.languages.extend("clike", {
+        string: {
+          pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'/,
+          lookbehind: true,
+          greedy: true
+        },
+        "class-name": [
+          {
+            // e.g. class Rectangle { ... }
+            pattern: /(\bclass\s+)\w+/,
+            lookbehind: true
+          },
+          {
+            // e.g. attr Rectangle::height, def Rectangle::area() { ... }
+            pattern: /(\b(?:attr|def)\s+)\w+(?=\s*::)/,
+            lookbehind: true
+          }
+        ],
+        keyword: /\b(?:attr|auto|break|case|catch|class|continue|def|default|else|finally|for|fun|global|if|return|switch|this|try|var|while)\b/,
+        number: [Prism.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
+        operator: />>=?|<<=?|\|\||&&|:[:=]?|--|\+\+|[=!<>+\-*/%|&^]=?|[?~]|`[^`\r\n]{1,4}`/
+      });
+      Prism.languages.insertBefore("chaiscript", "operator", {
+        "parameter-type": {
+          // e.g. def foo(int x, Vector y) {...}
+          pattern: /([,(]\s*)\w+(?=\s+\w)/,
+          lookbehind: true,
+          alias: "class-name"
+        }
+      });
+      Prism.languages.insertBefore("chaiscript", "string", {
+        "string-interpolation": {
+          pattern: /(^|[^\\])"(?:[^"$\\]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*"/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/,
+              lookbehind: true,
+              inside: {
+                "interpolation-expression": {
+                  pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                  lookbehind: true,
+                  inside: Prism.languages.chaiscript
+                },
+                "interpolation-punctuation": {
+                  pattern: /^\$\{|\}$/,
+                  alias: "punctuation"
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_chaiscript
+};

package/dist/chunk-C7DN7SOA.js

@@ -0,0 +1,88 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/velocity.js
+var require_velocity = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/velocity.js"(exports, module) {
+    module.exports = velocity;
+    velocity.displayName = "velocity";
+    velocity.aliases = [];
+    function velocity(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.velocity = Prism2.languages.extend("markup", {});
+        var velocity2 = {
+          variable: {
+            pattern: /(^|[^\\](?:\\\\)*)\$!?(?:[a-z][\w-]*(?:\([^)]*\))?(?:\.[a-z][\w-]*(?:\([^)]*\))?|\[[^\]]+\])*|\{[^}]+\})/i,
+            lookbehind: true,
+            inside: {}
+            // See below
+          },
+          string: {
+            pattern: /"[^"]*"|'[^']*'/,
+            greedy: true
+          },
+          number: /\b\d+\b/,
+          boolean: /\b(?:false|true)\b/,
+          operator: /[=!<>]=?|[+*/%-]|&&|\|\||\.\.|\b(?:eq|g[et]|l[et]|n(?:e|ot))\b/,
+          punctuation: /[(){}[\]:,.]/
+        };
+        velocity2.variable.inside = {
+          string: velocity2["string"],
+          function: {
+            pattern: /([^\w-])[a-z][\w-]*(?=\()/,
+            lookbehind: true
+          },
+          number: velocity2["number"],
+          boolean: velocity2["boolean"],
+          punctuation: velocity2["punctuation"]
+        };
+        Prism2.languages.insertBefore("velocity", "comment", {
+          unparsed: {
+            pattern: /(^|[^\\])#\[\[[\s\S]*?\]\]#/,
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              punctuation: /^#\[\[|\]\]#$/
+            }
+          },
+          "velocity-comment": [
+            {
+              pattern: /(^|[^\\])#\*[\s\S]*?\*#/,
+              lookbehind: true,
+              greedy: true,
+              alias: "comment"
+            },
+            {
+              pattern: /(^|[^\\])##.*/,
+              lookbehind: true,
+              greedy: true,
+              alias: "comment"
+            }
+          ],
+          directive: {
+            pattern: /(^|[^\\](?:\\\\)*)#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})(?:\s*\((?:[^()]|\([^()]*\))*\))?/i,
+            lookbehind: true,
+            inside: {
+              keyword: {
+                pattern: /^#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})|\bin\b/,
+                inside: {
+                  punctuation: /[{}]/
+                }
+              },
+              rest: velocity2
+            }
+          },
+          variable: velocity2["variable"]
+        });
+        Prism2.languages.velocity["tag"].inside["attr-value"].inside.rest = Prism2.languages.velocity;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_velocity
+};

package/dist/chunk-CGQKUOBK.js

@@ -0,0 +1,166 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/graphql.js
+var require_graphql = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/graphql.js"(exports, module) {
+    module.exports = graphql;
+    graphql.displayName = "graphql";
+    graphql.aliases = [];
+    function graphql(Prism) {
+      Prism.languages.graphql = {
+        comment: /#.*/,
+        description: {
+          pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
+          greedy: true,
+          alias: "string",
+          inside: {
+            "language-markdown": {
+              pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
+              lookbehind: true,
+              inside: Prism.languages.markdown
+            }
+          }
+        },
+        string: {
+          pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
+          greedy: true
+        },
+        number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        boolean: /\b(?:false|true)\b/,
+        variable: /\$[a-z_]\w*/i,
+        directive: {
+          pattern: /@[a-z_]\w*/i,
+          alias: "function"
+        },
+        "attr-name": {
+          pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
+          greedy: true
+        },
+        "atom-input": {
+          pattern: /\b[A-Z]\w*Input\b/,
+          alias: "class-name"
+        },
+        scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+        constant: /\b[A-Z][A-Z_\d]*\b/,
+        "class-name": {
+          pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+          lookbehind: true
+        },
+        fragment: {
+          pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
+          lookbehind: true,
+          alias: "function"
+        },
+        "definition-mutation": {
+          pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
+          lookbehind: true,
+          alias: "function"
+        },
+        "definition-query": {
+          pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
+          lookbehind: true,
+          alias: "function"
+        },
+        keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+        operator: /[!=|&]|\.{3}/,
+        "property-query": /\w+(?=\s*\()/,
+        object: /\w+(?=\s*\{)/,
+        punctuation: /[!(){}\[\]:=,]/,
+        property: /\w+/
+      };
+      Prism.hooks.add("after-tokenize", function afterTokenizeGraphql(env) {
+        if (env.language !== "graphql") {
+          return;
+        }
+        var validTokens = env.tokens.filter(function(token) {
+          return typeof token !== "string" && token.type !== "comment" && token.type !== "scalar";
+        });
+        var currentIndex = 0;
+        function getToken(offset) {
+          return validTokens[currentIndex + offset];
+        }
+        function isTokenType(types, offset) {
+          offset = offset || 0;
+          for (var i2 = 0; i2 < types.length; i2++) {
+            var token = getToken(i2 + offset);
+            if (!token || token.type !== types[i2]) {
+              return false;
+            }
+          }
+          return true;
+        }
+        function findClosingBracket(open, close) {
+          var stackHeight = 1;
+          for (var i2 = currentIndex; i2 < validTokens.length; i2++) {
+            var token = validTokens[i2];
+            var content = token.content;
+            if (token.type === "punctuation" && typeof content === "string") {
+              if (open.test(content)) {
+                stackHeight++;
+              } else if (close.test(content)) {
+                stackHeight--;
+                if (stackHeight === 0) {
+                  return i2;
+                }
+              }
+            }
+          }
+          return -1;
+        }
+        function addAlias(token, alias) {
+          var aliases = token.alias;
+          if (!aliases) {
+            token.alias = aliases = [];
+          } else if (!Array.isArray(aliases)) {
+            token.alias = aliases = [aliases];
+          }
+          aliases.push(alias);
+        }
+        for (; currentIndex < validTokens.length; ) {
+          var startToken = validTokens[currentIndex++];
+          if (startToken.type === "keyword" && startToken.content === "mutation") {
+            var inputVariables = [];
+            if (isTokenType(["definition-mutation", "punctuation"]) && getToken(1).content === "(") {
+              currentIndex += 2;
+              var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
+              if (definitionEnd === -1) {
+                continue;
+              }
+              for (; currentIndex < definitionEnd; currentIndex++) {
+                var t = getToken(0);
+                if (t.type === "variable") {
+                  addAlias(t, "variable-input");
+                  inputVariables.push(t.content);
+                }
+              }
+              currentIndex = definitionEnd + 1;
+            }
+            if (isTokenType(["punctuation", "property-query"]) && getToken(0).content === "{") {
+              currentIndex++;
+              addAlias(getToken(0), "property-mutation");
+              if (inputVariables.length > 0) {
+                var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
+                if (mutationEnd === -1) {
+                  continue;
+                }
+                for (var i = currentIndex; i < mutationEnd; i++) {
+                  var varToken = validTokens[i];
+                  if (varToken.type === "variable" && inputVariables.indexOf(varToken.content) >= 0) {
+                    addAlias(varToken, "variable-input");
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_graphql
+};

package/dist/chunk-CNXZNSZ6.js

@@ -0,0 +1,73 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/toml.js
+var require_toml = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/toml.js"(exports, module) {
+    module.exports = toml;
+    toml.displayName = "toml";
+    toml.aliases = [];
+    function toml(Prism) {
+      ;
+      (function(Prism2) {
+        var key = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
+        function insertKey(pattern) {
+          return pattern.replace(/__/g, function() {
+            return key;
+          });
+        }
+        Prism2.languages.toml = {
+          comment: {
+            pattern: /#.*/,
+            greedy: true
+          },
+          table: {
+            pattern: RegExp(
+              insertKey(
+                /(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source
+              ),
+              "m"
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "class-name"
+          },
+          key: {
+            pattern: RegExp(
+              insertKey(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source),
+              "m"
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "property"
+          },
+          string: {
+            pattern: /"""(?:\\[\s\S]|[^\\])*?"""|'''[\s\S]*?'''|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*"/,
+            greedy: true
+          },
+          date: [
+            {
+              // Offset Date-Time, Local Date-Time, Local Date
+              pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
+              alias: "number"
+            },
+            {
+              // Local Time
+              pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
+              alias: "number"
+            }
+          ],
+          number: /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
+          boolean: /\b(?:false|true)\b/,
+          punctuation: /[.,=[\]{}]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_toml
+};

package/dist/chunk-CPE7WTCO.js

@@ -0,0 +1,87 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javadoclike.js
+var require_javadoclike = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javadoclike.js"(exports, module) {
+    module.exports = javadoclike;
+    javadoclike.displayName = "javadoclike";
+    javadoclike.aliases = [];
+    function javadoclike(Prism) {
+      ;
+      (function(Prism2) {
+        var javaDocLike = Prism2.languages.javadoclike = {
+          parameter: {
+            pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
+            lookbehind: true
+          },
+          keyword: {
+            // keywords are the first word in a line preceded be an `@` or surrounded by curly braces.
+            // @word, {@word}
+            pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
+            lookbehind: true
+          },
+          punctuation: /[{}]/
+        };
+        function docCommentSupport(lang, callback) {
+          var tokenName = "doc-comment";
+          var grammar = Prism2.languages[lang];
+          if (!grammar) {
+            return;
+          }
+          var token = grammar[tokenName];
+          if (!token) {
+            var definition = {};
+            definition[tokenName] = {
+              pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
+              lookbehind: true,
+              alias: "comment"
+            };
+            grammar = Prism2.languages.insertBefore(lang, "comment", definition);
+            token = grammar[tokenName];
+          }
+          if (token instanceof RegExp) {
+            token = grammar[tokenName] = {
+              pattern: token
+            };
+          }
+          if (Array.isArray(token)) {
+            for (var i = 0, l = token.length; i < l; i++) {
+              if (token[i] instanceof RegExp) {
+                token[i] = {
+                  pattern: token[i]
+                };
+              }
+              callback(token[i]);
+            }
+          } else {
+            callback(token);
+          }
+        }
+        function addSupport(languages, docLanguage) {
+          if (typeof languages === "string") {
+            languages = [languages];
+          }
+          languages.forEach(function(lang) {
+            docCommentSupport(lang, function(pattern) {
+              if (!pattern.inside) {
+                pattern.inside = {};
+              }
+              pattern.inside.rest = docLanguage;
+            });
+          });
+        }
+        Object.defineProperty(javaDocLike, "addSupport", {
+          value: addSupport
+        });
+        javaDocLike.addSupport(["java", "javascript", "php"], javaDocLike);
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_javadoclike
+};