@distri/react 0.2.7 → 0.3.0

package/dist/chunk-UJBVRUTD.js

@@ -0,0 +1,98 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/smali.js
+var require_smali = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/smali.js"(exports, module) {
+    module.exports = smali;
+    smali.displayName = "smali";
+    smali.aliases = [];
+    function smali(Prism) {
+      Prism.languages.smali = {
+        comment: /#.*/,
+        string: {
+          pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(^|[^L])L(?:(?:\w+|`[^`\r\n]*`)\/)*(?:[\w$]+|`[^`\r\n]*`)(?=\s*;)/,
+          lookbehind: true,
+          inside: {
+            "class-name": {
+              pattern: /(^L|\/)(?:[\w$]+|`[^`\r\n]*`)$/,
+              lookbehind: true
+            },
+            namespace: {
+              pattern: /^(L)(?:(?:\w+|`[^`\r\n]*`)\/)+/,
+              lookbehind: true,
+              inside: {
+                punctuation: /\//
+              }
+            },
+            builtin: /^L/
+          }
+        },
+        builtin: [
+          {
+            // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types
+            pattern: /([();\[])[BCDFIJSVZ]+/,
+            lookbehind: true
+          },
+          {
+            // e.g. .field mWifiOnUid:I
+            pattern: /([\w$>]:)[BCDFIJSVZ]/,
+            lookbehind: true
+          }
+        ],
+        keyword: [
+          {
+            pattern: /(\.end\s+)[\w-]+/,
+            lookbehind: true
+          },
+          {
+            pattern: /(^|[^\w.-])\.(?!\d)[\w-]+/,
+            lookbehind: true
+          },
+          {
+            pattern: /(^|[^\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\w.-])/,
+            lookbehind: true
+          }
+        ],
+        function: {
+          pattern: /(^|[^\w.-])(?:\w+|<[\w$-]+>)(?=\()/,
+          lookbehind: true
+        },
+        field: {
+          pattern: /[\w$]+(?=:)/,
+          alias: "variable"
+        },
+        register: {
+          pattern: /(^|[^\w.-])[vp]\d(?![\w.-])/,
+          lookbehind: true,
+          alias: "variable"
+        },
+        boolean: {
+          pattern: /(^|[^\w.-])(?:false|true)(?![\w.-])/,
+          lookbehind: true
+        },
+        number: {
+          pattern: /(^|[^/\w.-])-?(?:NAN|INFINITY|0x(?:[\dA-F]+(?:\.[\dA-F]*)?|\.[\dA-F]+)(?:p[+-]?[\dA-F]+)?|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)[dflst]?(?![\w.-])/i,
+          lookbehind: true
+        },
+        label: {
+          pattern: /(:)\w+/,
+          lookbehind: true,
+          alias: "property"
+        },
+        operator: /->|\.\.|[\[=]/,
+        punctuation: /[{}(),;:]/
+      };
+    }
+  }
+});
+
+export {
+  require_smali
+};

package/dist/chunk-UTCKMPAI.js

@@ -0,0 +1,289 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/textile.js
+var require_textile = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/textile.js"(exports, module) {
+    module.exports = textile;
+    textile.displayName = "textile";
+    textile.aliases = [];
+    function textile(Prism) {
+      ;
+      (function(Prism2) {
+        var modifierRegex = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source;
+        var parenthesesRegex = /\)|\((?![^|()\n]+\))/.source;
+        function withModifier(source, flags) {
+          return RegExp(
+            source.replace(/<MOD>/g, function() {
+              return "(?:" + modifierRegex + ")";
+            }).replace(/<PAR>/g, function() {
+              return "(?:" + parenthesesRegex + ")";
+            }),
+            flags || ""
+          );
+        }
+        var modifierTokens = {
+          css: {
+            pattern: /\{[^{}]+\}/,
+            inside: {
+              rest: Prism2.languages.css
+            }
+          },
+          "class-id": {
+            pattern: /(\()[^()]+(?=\))/,
+            lookbehind: true,
+            alias: "attr-value"
+          },
+          lang: {
+            pattern: /(\[)[^\[\]]+(?=\])/,
+            lookbehind: true,
+            alias: "attr-value"
+          },
+          // Anything else is punctuation (the first pattern is for row/col spans inside tables)
+          punctuation: /[\\\/]\d+|\S/
+        };
+        var textile2 = Prism2.languages.textile = Prism2.languages.extend("markup", {
+          phrase: {
+            pattern: /(^|\r|\n)\S[\s\S]*?(?=$|\r?\n\r?\n|\r\r)/,
+            lookbehind: true,
+            inside: {
+              // h1. Header 1
+              "block-tag": {
+                pattern: withModifier(/^[a-z]\w*(?:<MOD>|<PAR>|[<>=])*\./.source),
+                inside: {
+                  modifier: {
+                    pattern: withModifier(
+                      /(^[a-z]\w*)(?:<MOD>|<PAR>|[<>=])+(?=\.)/.source
+                    ),
+                    lookbehind: true,
+                    inside: modifierTokens
+                  },
+                  tag: /^[a-z]\w*/,
+                  punctuation: /\.$/
+                }
+              },
+              // # List item
+              // * List item
+              list: {
+                pattern: withModifier(/^[*#]+<MOD>*\s+\S.*/.source, "m"),
+                inside: {
+                  modifier: {
+                    pattern: withModifier(/(^[*#]+)<MOD>+/.source),
+                    lookbehind: true,
+                    inside: modifierTokens
+                  },
+                  punctuation: /^[*#]+/
+                }
+              },
+              // | cell | cell | cell |
+              table: {
+                // Modifiers can be applied to the row: {color:red}.|1|2|3|
+                // or the cell: |{color:red}.1|2|3|
+                pattern: withModifier(
+                  /^(?:(?:<MOD>|<PAR>|[<>=^~])+\.\s*)?(?:\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.))[^|]*)+\|/.source,
+                  "m"
+                ),
+                inside: {
+                  modifier: {
+                    // Modifiers for rows after the first one are
+                    // preceded by a pipe and a line feed
+                    pattern: withModifier(
+                      /(^|\|(?:\r?\n|\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+(?=\.)/.source
+                    ),
+                    lookbehind: true,
+                    inside: modifierTokens
+                  },
+                  punctuation: /\||^\./
+                }
+              },
+              inline: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(
+                  /(^|[^a-zA-Z\d])(\*\*|__|\?\?|[*_%@+\-^~])<MOD>*.+?\2(?![a-zA-Z\d])/.source
+                ),
+                lookbehind: true,
+                inside: {
+                  // Note: superscripts and subscripts are not handled specifically
+                  // *bold*, **bold**
+                  bold: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^(\*\*?)<MOD>*).+?(?=\2)/.source),
+                    lookbehind: true
+                  },
+                  // _italic_, __italic__
+                  italic: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^(__?)<MOD>*).+?(?=\2)/.source),
+                    lookbehind: true
+                  },
+                  // ??cite??
+                  cite: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^\?\?<MOD>*).+?(?=\?\?)/.source),
+                    lookbehind: true,
+                    alias: "string"
+                  },
+                  // @code@
+                  code: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^@<MOD>*).+?(?=@)/.source),
+                    lookbehind: true,
+                    alias: "keyword"
+                  },
+                  // +inserted+
+                  inserted: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^\+<MOD>*).+?(?=\+)/.source),
+                    lookbehind: true
+                  },
+                  // -deleted-
+                  deleted: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^-<MOD>*).+?(?=-)/.source),
+                    lookbehind: true
+                  },
+                  // %span%
+                  span: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^%<MOD>*).+?(?=%)/.source),
+                    lookbehind: true
+                  },
+                  modifier: {
+                    pattern: withModifier(
+                      /(^\*\*|__|\?\?|[*_%@+\-^~])<MOD>+/.source
+                    ),
+                    lookbehind: true,
+                    inside: modifierTokens
+                  },
+                  punctuation: /[*_%?@+\-^~]+/
+                }
+              },
+              // [alias]http://example.com
+              "link-ref": {
+                pattern: /^\[[^\]]+\]\S+$/m,
+                inside: {
+                  string: {
+                    pattern: /(^\[)[^\]]+(?=\])/,
+                    lookbehind: true
+                  },
+                  url: {
+                    pattern: /(^\])\S+$/,
+                    lookbehind: true
+                  },
+                  punctuation: /[\[\]]/
+                }
+              },
+              // "text":http://example.com
+              // "text":link-ref
+              link: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(
+                  /"<MOD>*[^"]+":.+?(?=[^\w/]?(?:\s|$))/.source
+                ),
+                inside: {
+                  text: {
+                    // eslint-disable-next-line regexp/no-super-linear-backtracking
+                    pattern: withModifier(/(^"<MOD>*)[^"]+(?=")/.source),
+                    lookbehind: true
+                  },
+                  modifier: {
+                    pattern: withModifier(/(^")<MOD>+/.source),
+                    lookbehind: true,
+                    inside: modifierTokens
+                  },
+                  url: {
+                    pattern: /(:).+/,
+                    lookbehind: true
+                  },
+                  punctuation: /[":]/
+                }
+              },
+              // !image.jpg!
+              // !image.jpg(Title)!:http://example.com
+              image: {
+                pattern: withModifier(
+                  /!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\s()]+(?:\([^)]+\))?!(?::.+?(?=[^\w/]?(?:\s|$)))?/.source
+                ),
+                inside: {
+                  source: {
+                    pattern: withModifier(
+                      /(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\s()]+(?:\([^)]+\))?(?=!)/.source
+                    ),
+                    lookbehind: true,
+                    alias: "url"
+                  },
+                  modifier: {
+                    pattern: withModifier(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),
+                    lookbehind: true,
+                    inside: modifierTokens
+                  },
+                  url: {
+                    pattern: /(:).+/,
+                    lookbehind: true
+                  },
+                  punctuation: /[!:]/
+                }
+              },
+              // Footnote[1]
+              footnote: {
+                pattern: /\b\[\d+\]/,
+                alias: "comment",
+                inside: {
+                  punctuation: /\[|\]/
+                }
+              },
+              // CSS(Cascading Style Sheet)
+              acronym: {
+                pattern: /\b[A-Z\d]+\([^)]+\)/,
+                inside: {
+                  comment: {
+                    pattern: /(\()[^()]+(?=\))/,
+                    lookbehind: true
+                  },
+                  punctuation: /[()]/
+                }
+              },
+              // Prism(C)
+              mark: {
+                pattern: /\b\((?:C|R|TM)\)/,
+                alias: "comment",
+                inside: {
+                  punctuation: /[()]/
+                }
+              }
+            }
+          }
+        });
+        var phraseInside = textile2["phrase"].inside;
+        var nestedPatterns = {
+          inline: phraseInside["inline"],
+          link: phraseInside["link"],
+          image: phraseInside["image"],
+          footnote: phraseInside["footnote"],
+          acronym: phraseInside["acronym"],
+          mark: phraseInside["mark"]
+        };
+        textile2.tag.pattern = /<\/?(?!\d)[a-z0-9]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i;
+        var phraseInlineInside = phraseInside["inline"].inside;
+        phraseInlineInside["bold"].inside = nestedPatterns;
+        phraseInlineInside["italic"].inside = nestedPatterns;
+        phraseInlineInside["inserted"].inside = nestedPatterns;
+        phraseInlineInside["deleted"].inside = nestedPatterns;
+        phraseInlineInside["span"].inside = nestedPatterns;
+        var phraseTableInside = phraseInside["table"].inside;
+        phraseTableInside["inline"] = nestedPatterns["inline"];
+        phraseTableInside["link"] = nestedPatterns["link"];
+        phraseTableInside["image"] = nestedPatterns["image"];
+        phraseTableInside["footnote"] = nestedPatterns["footnote"];
+        phraseTableInside["acronym"] = nestedPatterns["acronym"];
+        phraseTableInside["mark"] = nestedPatterns["mark"];
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_textile
+};

package/dist/chunk-UU73JDYM.js

@@ -0,0 +1,144 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nevod.js
+var require_nevod = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nevod.js"(exports, module) {
+    module.exports = nevod;
+    nevod.displayName = "nevod";
+    nevod.aliases = [];
+    function nevod(Prism) {
+      Prism.languages.nevod = {
+        comment: /\/\/.*|(?:\/\*[\s\S]*?(?:\*\/|$))/,
+        string: {
+          pattern: /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))!?\*?/,
+          greedy: true,
+          inside: {
+            "string-attrs": /!$|!\*$|\*$/
+          }
+        },
+        namespace: {
+          pattern: /(@namespace\s+)[a-zA-Z0-9\-.]+(?=\s*\{)/,
+          lookbehind: true
+        },
+        pattern: {
+          pattern: /(@pattern\s+)?#?[a-zA-Z0-9\-.]+(?:\s*\(\s*(?:~\s*)?[a-zA-Z0-9\-.]+\s*(?:,\s*(?:~\s*)?[a-zA-Z0-9\-.]*)*\))?(?=\s*=)/,
+          lookbehind: true,
+          inside: {
+            "pattern-name": {
+              pattern: /^#?[a-zA-Z0-9\-.]+/,
+              alias: "class-name"
+            },
+            fields: {
+              pattern: /\(.*\)/,
+              inside: {
+                "field-name": {
+                  pattern: /[a-zA-Z0-9\-.]+/,
+                  alias: "variable"
+                },
+                punctuation: /[,()]/,
+                operator: {
+                  pattern: /~/,
+                  alias: "field-hidden-mark"
+                }
+              }
+            }
+          }
+        },
+        search: {
+          pattern: /(@search\s+|#)[a-zA-Z0-9\-.]+(?:\.\*)?(?=\s*;)/,
+          alias: "function",
+          lookbehind: true
+        },
+        keyword: /@(?:having|inside|namespace|outside|pattern|require|search|where)\b/,
+        "standard-pattern": {
+          pattern: /\b(?:Alpha|AlphaNum|Any|Blank|End|LineBreak|Num|NumAlpha|Punct|Space|Start|Symbol|Word|WordBreak)\b(?:\([a-zA-Z0-9\-.,\s+]*\))?/,
+          inside: {
+            "standard-pattern-name": {
+              pattern: /^[a-zA-Z0-9\-.]+/,
+              alias: "builtin"
+            },
+            quantifier: {
+              pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+              alias: "number"
+            },
+            "standard-pattern-attr": {
+              pattern: /[a-zA-Z0-9\-.]+/,
+              alias: "builtin"
+            },
+            punctuation: /[,()]/
+          }
+        },
+        quantifier: {
+          pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+          alias: "number"
+        },
+        operator: [
+          {
+            pattern: /=/,
+            alias: "pattern-def"
+          },
+          {
+            pattern: /&/,
+            alias: "conjunction"
+          },
+          {
+            pattern: /~/,
+            alias: "exception"
+          },
+          {
+            pattern: /\?/,
+            alias: "optionality"
+          },
+          {
+            pattern: /[[\]]/,
+            alias: "repetition"
+          },
+          {
+            pattern: /[{}]/,
+            alias: "variation"
+          },
+          {
+            pattern: /[+_]/,
+            alias: "sequence"
+          },
+          {
+            pattern: /\.{2,3}/,
+            alias: "span"
+          }
+        ],
+        "field-capture": [
+          {
+            pattern: /([a-zA-Z0-9\-.]+\s*\()\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+(?:\s*,\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+)*(?=\s*\))/,
+            lookbehind: true,
+            inside: {
+              "field-name": {
+                pattern: /[a-zA-Z0-9\-.]+/,
+                alias: "variable"
+              },
+              colon: /:/
+            }
+          },
+          {
+            pattern: /[a-zA-Z0-9\-.]+\s*:/,
+            inside: {
+              "field-name": {
+                pattern: /[a-zA-Z0-9\-.]+/,
+                alias: "variable"
+              },
+              colon: /:/
+            }
+          }
+        ],
+        punctuation: /[:;,()]/,
+        name: /[a-zA-Z0-9\-.]+/
+      };
+    }
+  }
+});
+
+export {
+  require_nevod
+};

package/dist/chunk-UVOTXBDD.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
+};