@distri/react 0.3.1 → 0.3.3

package/dist/chunk-MI6VDBLM.js

@@ -0,0 +1,93 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dart.js
+var require_dart = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dart.js"(exports, module) {
+    module.exports = dart;
+    dart.displayName = "dart";
+    dart.aliases = [];
+    function dart(Prism) {
+      ;
+      (function(Prism2) {
+        var keywords = [
+          /\b(?:async|sync|yield)\*/,
+          /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
+        ];
+        var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
+        var className = {
+          pattern: RegExp(packagePrefix + /[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: /\./
+              }
+            }
+          }
+        };
+        Prism2.languages.dart = Prism2.languages.extend("clike", {
+          "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(
+                packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+              ),
+              lookbehind: true,
+              inside: className.inside
+            }
+          ],
+          keyword: keywords,
+          operator: /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+        });
+        Prism2.languages.insertBefore("dart", "string", {
+          "string-literal": {
+            pattern: /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+                lookbehind: true,
+                inside: {
+                  punctuation: /^\$\{?|\}$/,
+                  expression: {
+                    pattern: /[\s\S]+/,
+                    inside: Prism2.languages.dart
+                  }
+                }
+              },
+              string: /[\s\S]+/
+            }
+          },
+          string: void 0
+        });
+        Prism2.languages.insertBefore("dart", "class-name", {
+          metadata: {
+            pattern: /@\w+/,
+            alias: "function"
+          }
+        });
+        Prism2.languages.insertBefore("dart", "class-name", {
+          generics: {
+            pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+            inside: {
+              "class-name": className,
+              keyword: keywords,
+              punctuation: /[<>(),.:]/,
+              operator: /[?&|]/
+            }
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_dart
+};

package/dist/chunk-MRLBYC4E.js

@@ -0,0 +1,47 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/monkey.js
+var require_monkey = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/monkey.js"(exports, module) {
+    module.exports = monkey;
+    monkey.displayName = "monkey";
+    monkey.aliases = [];
+    function monkey(Prism) {
+      Prism.languages.monkey = {
+        comment: {
+          pattern: /^#Rem\s[\s\S]*?^#End|'.+/im,
+          greedy: true
+        },
+        string: {
+          pattern: /"[^"\r\n]*"/,
+          greedy: true
+        },
+        preprocessor: {
+          pattern: /(^[ \t]*)#.+/m,
+          lookbehind: true,
+          greedy: true,
+          alias: "property"
+        },
+        function: /\b\w+(?=\()/,
+        "type-char": {
+          pattern: /\b[?%#$]/,
+          alias: "class-name"
+        },
+        number: {
+          pattern: /((?:\.\.)?)(?:(?:\b|\B-\.?|\B\.)\d+(?:(?!\.\.)\.\d*)?|\$[\da-f]+)/i,
+          lookbehind: true
+        },
+        keyword: /\b(?:Abstract|Array|Bool|Case|Catch|Class|Const|Continue|Default|Eachin|Else|ElseIf|End|EndIf|Exit|Extends|Extern|False|Field|Final|Float|For|Forever|Function|Global|If|Implements|Import|Inline|Int|Interface|Local|Method|Module|New|Next|Null|Object|Private|Property|Public|Repeat|Return|Select|Self|Step|Strict|String|Super|Then|Throw|To|True|Try|Until|Void|Wend|While)\b/i,
+        operator: /\.\.|<[=>]?|>=?|:?=|(?:[+\-*\/&~|]|\b(?:Mod|Shl|Shr)\b)=?|\b(?:And|Not|Or)\b/i,
+        punctuation: /[.,:;()\[\]]/
+      };
+    }
+  }
+});
+
+export {
+  require_monkey
+};

package/dist/chunk-MU3ZP5L5.js

@@ -0,0 +1,91 @@
+"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/liquid.js
+var require_liquid = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/liquid.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = liquid;
+    liquid.displayName = "liquid";
+    liquid.aliases = [];
+    function liquid(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      Prism.languages.liquid = {
+        comment: {
+          pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
+          lookbehind: true
+        },
+        delimiter: {
+          pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/,
+          alias: "punctuation"
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: true
+        },
+        keyword: /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/,
+        object: /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/,
+        function: [
+          {
+            pattern: /(\|\s*)\w+/,
+            lookbehind: true,
+            alias: "filter"
+          },
+          {
+            // array functions
+            pattern: /(\.\s*)(?:first|last|size)/,
+            lookbehind: true
+          }
+        ],
+        boolean: /\b(?:false|nil|true)\b/,
+        range: {
+          pattern: /\.\./,
+          alias: "operator"
+        },
+        // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21
+        number: /\b\d+(?:\.\d+)?\b/,
+        operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/,
+        punctuation: /[.,\[\]()]/,
+        empty: {
+          pattern: /\bempty\b/,
+          alias: "keyword"
+        }
+      };
+      Prism.hooks.add("before-tokenize", function(env) {
+        var liquidPattern = /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g;
+        var insideRaw = false;
+        Prism.languages["markup-templating"].buildPlaceholders(
+          env,
+          "liquid",
+          liquidPattern,
+          function(match) {
+            var tagMatch = /^\{%-?\s*(\w+)/.exec(match);
+            if (tagMatch) {
+              var tag = tagMatch[1];
+              if (tag === "raw" && !insideRaw) {
+                insideRaw = true;
+                return true;
+              } else if (tag === "endraw") {
+                insideRaw = false;
+                return true;
+              }
+            }
+            return !insideRaw;
+          }
+        );
+      });
+      Prism.hooks.add("after-tokenize", function(env) {
+        Prism.languages["markup-templating"].tokenizePlaceholders(env, "liquid");
+      });
+    }
+  }
+});
+
+export {
+  require_liquid
+};

package/dist/chunk-MUOOCQ2U.js

@@ -0,0 +1,56 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nix.js
+var require_nix = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nix.js"(exports, module) {
+    module.exports = nix;
+    nix.displayName = "nix";
+    nix.aliases = [];
+    function nix(Prism) {
+      Prism.languages.nix = {
+        comment: {
+          pattern: /\/\*[\s\S]*?\*\/|#.*/,
+          greedy: true
+        },
+        string: {
+          pattern: /"(?:[^"\\]|\\[\s\S])*"|''(?:(?!'')[\s\S]|''(?:'|\\|\$\{))*''/,
+          greedy: true,
+          inside: {
+            interpolation: {
+              // The lookbehind ensures the ${} is not preceded by \ or ''
+              pattern: /(^|(?:^|(?!'').)[^\\])\$\{(?:[^{}]|\{[^}]*\})*\}/,
+              lookbehind: true,
+              inside: null
+              // see below
+            }
+          }
+        },
+        url: [
+          /\b(?:[a-z]{3,7}:\/\/)[\w\-+%~\/.:#=?&]+/,
+          {
+            pattern: /([^\/])(?:[\w\-+%~.:#=?&]*(?!\/\/)[\w\-+%~\/.:#=?&])?(?!\/\/)\/[\w\-+%~\/.:#=?&]*/,
+            lookbehind: true
+          }
+        ],
+        antiquotation: {
+          pattern: /\$(?=\{)/,
+          alias: "important"
+        },
+        number: /\b\d+\b/,
+        keyword: /\b(?:assert|builtins|else|if|in|inherit|let|null|or|then|with)\b/,
+        function: /\b(?:abort|add|all|any|attrNames|attrValues|baseNameOf|compareVersions|concatLists|currentSystem|deepSeq|derivation|dirOf|div|elem(?:At)?|fetch(?:Tarball|url)|filter(?:Source)?|fromJSON|genList|getAttr|getEnv|hasAttr|hashString|head|import|intersectAttrs|is(?:Attrs|Bool|Function|Int|List|Null|String)|length|lessThan|listToAttrs|map|mul|parseDrvName|pathExists|read(?:Dir|File)|removeAttrs|replaceStrings|seq|sort|stringLength|sub(?:string)?|tail|throw|to(?:File|JSON|Path|String|XML)|trace|typeOf)\b|\bfoldl'\B/,
+        boolean: /\b(?:false|true)\b/,
+        operator: /[=!<>]=?|\+\+?|\|\||&&|\/\/|->?|[?@]/,
+        punctuation: /[{}()[\].,:;]/
+      };
+      Prism.languages.nix.string.inside.interpolation.inside = Prism.languages.nix;
+    }
+  }
+});
+
+export {
+  require_nix
+};

package/dist/chunk-MVYKGSQQ.js

@@ -0,0 +1,65 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gap.js
+var require_gap = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gap.js"(exports, module) {
+    module.exports = gap;
+    gap.displayName = "gap";
+    gap.aliases = [];
+    function gap(Prism) {
+      Prism.languages.gap = {
+        shell: {
+          pattern: /^gap>[\s\S]*?(?=^gap>|$(?![\s\S]))/m,
+          greedy: true,
+          inside: {
+            gap: {
+              pattern: /^(gap>).+(?:(?:\r(?:\n|(?!\n))|\n)>.*)*/,
+              lookbehind: true,
+              inside: null
+              // see below
+            },
+            punctuation: /^gap>/
+          }
+        },
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        string: {
+          pattern: /(^|[^\\'"])(?:'(?:[^\r\n\\']|\\.){1,10}'|"(?:[^\r\n\\"]|\\.)*"(?!")|"""[\s\S]*?""")/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            continuation: {
+              pattern: /([\r\n])>/,
+              lookbehind: true,
+              alias: "punctuation"
+            }
+          }
+        },
+        keyword: /\b(?:Assert|Info|IsBound|QUIT|TryNextMethod|Unbind|and|atomic|break|continue|do|elif|else|end|fi|for|function|if|in|local|mod|not|od|or|quit|readonly|readwrite|rec|repeat|return|then|until|while)\b/,
+        boolean: /\b(?:false|true)\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: {
+          pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+          lookbehind: true
+        },
+        continuation: {
+          pattern: /([\r\n])>/,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        operator: /->|[-+*/^~=!]|<>|[<>]=?|:=|\.\./,
+        punctuation: /[()[\]{},;.:]/
+      };
+      Prism.languages.gap.shell.inside.gap.inside = Prism.languages.gap;
+    }
+  }
+});
+
+export {
+  require_gap
+};

package/dist/chunk-NC6NC3VB.js

@@ -0,0 +1,94 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/haxe.js
+var require_haxe = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/haxe.js"(exports, module) {
+    module.exports = haxe;
+    haxe.displayName = "haxe";
+    haxe.aliases = [];
+    function haxe(Prism) {
+      Prism.languages.haxe = Prism.languages.extend("clike", {
+        string: {
+          // Strings can be multi-line
+          pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+          greedy: true
+        },
+        "class-name": [
+          {
+            pattern: /(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
+            lookbehind: true
+          },
+          // based on naming convention
+          /\b[A-Z]\w*/
+        ],
+        // The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
+        keyword: /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
+        function: {
+          pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
+          greedy: true
+        },
+        operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
+      });
+      Prism.languages.insertBefore("haxe", "string", {
+        "string-interpolation": {
+          pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
+              lookbehind: true,
+              inside: {
+                "interpolation-punctuation": {
+                  pattern: /^\$\{?|\}$/,
+                  alias: "punctuation"
+                },
+                expression: {
+                  pattern: /[\s\S]+/,
+                  inside: Prism.languages.haxe
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      });
+      Prism.languages.insertBefore("haxe", "class-name", {
+        regex: {
+          pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
+          greedy: true,
+          inside: {
+            "regex-flags": /\b[a-z]+$/,
+            "regex-source": {
+              pattern: /^(~\/)[\s\S]+(?=\/$)/,
+              lookbehind: true,
+              alias: "language-regex",
+              inside: Prism.languages.regex
+            },
+            "regex-delimiter": /^~\/|\/$/
+          }
+        }
+      });
+      Prism.languages.insertBefore("haxe", "keyword", {
+        preprocessor: {
+          pattern: /#(?:else|elseif|end|if)\b.*/,
+          alias: "property"
+        },
+        metadata: {
+          pattern: /@:?[\w.]+/,
+          alias: "symbol"
+        },
+        reification: {
+          pattern: /\$(?:\w+|(?=\{))/,
+          alias: "important"
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_haxe
+};

package/dist/chunk-NCAE746Z.js

@@ -0,0 +1,115 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/batch.js
+var require_batch = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/batch.js"(exports, module) {
+    module.exports = batch;
+    batch.displayName = "batch";
+    batch.aliases = [];
+    function batch(Prism) {
+      ;
+      (function(Prism2) {
+        var variable = /%%?[~:\w]+%?|!\S+!/;
+        var parameter = {
+          pattern: /\/[a-z?]+(?=[ :]|$):?|-[a-z]\b|--[a-z-]+\b/im,
+          alias: "attr-name",
+          inside: {
+            punctuation: /:/
+          }
+        };
+        var string = /"(?:[\\"]"|[^"])*"(?!")/;
+        var number = /(?:\b|-)\d+\b/;
+        Prism2.languages.batch = {
+          comment: [
+            /^::.*/m,
+            {
+              pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+              lookbehind: true
+            }
+          ],
+          label: {
+            pattern: /^:.*/m,
+            alias: "property"
+          },
+          command: [
+            {
+              // FOR command
+              pattern: /((?:^|[&(])[ \t]*)for(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* \S+ in \([^)]+\) do/im,
+              lookbehind: true,
+              inside: {
+                keyword: /\b(?:do|in)\b|^for\b/i,
+                string,
+                parameter,
+                variable,
+                number,
+                punctuation: /[()',]/
+              }
+            },
+            {
+              // IF command
+              pattern: /((?:^|[&(])[ \t]*)if(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:not )?(?:cmdextversion \d+|defined \w+|errorlevel \d+|exist \S+|(?:"[^"]*"|(?!")(?:(?!==)\S)+)?(?:==| (?:equ|geq|gtr|leq|lss|neq) )(?:"[^"]*"|[^\s"]\S*))/im,
+              lookbehind: true,
+              inside: {
+                keyword: /\b(?:cmdextversion|defined|errorlevel|exist|not)\b|^if\b/i,
+                string,
+                parameter,
+                variable,
+                number,
+                operator: /\^|==|\b(?:equ|geq|gtr|leq|lss|neq)\b/i
+              }
+            },
+            {
+              // ELSE command
+              pattern: /((?:^|[&()])[ \t]*)else\b/im,
+              lookbehind: true,
+              inside: {
+                keyword: /^else\b/i
+              }
+            },
+            {
+              // SET command
+              pattern: /((?:^|[&(])[ \t]*)set(?: \/[a-z](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+              lookbehind: true,
+              inside: {
+                keyword: /^set\b/i,
+                string,
+                parameter,
+                variable: [variable, /\w+(?=(?:[*\/%+\-&^|]|<<|>>)?=)/],
+                number,
+                operator: /[*\/%+\-&^|]=?|<<=?|>>=?|[!~_=]/,
+                punctuation: /[()',]/
+              }
+            },
+            {
+              // Other commands
+              pattern: /((?:^|[&(])[ \t]*@?)\w+\b(?:"(?:[\\"]"|[^"])*"(?!")|[^"^&)\r\n]|\^(?:\r\n|[\s\S]))*/m,
+              lookbehind: true,
+              inside: {
+                keyword: /^\w+\b/,
+                string,
+                parameter,
+                label: {
+                  pattern: /(^\s*):\S+/m,
+                  lookbehind: true,
+                  alias: "property"
+                },
+                variable,
+                number,
+                operator: /\^/
+              }
+            }
+          ],
+          operator: /[&@]/,
+          punctuation: /[()']/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_batch
+};