@distri/react 0.2.8 → 0.3.1

package/dist/chunk-UJBVRUTD.js

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

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

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

@@ -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
-};