@distri/react 0.2.5 → 0.2.8

package/dist/chunk-LP6PAX6W.js

@@ -0,0 +1,162 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/icu-message-format.js
+var require_icu_message_format = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/icu-message-format.js"(exports, module) {
+    module.exports = icuMessageFormat;
+    icuMessageFormat.displayName = "icuMessageFormat";
+    icuMessageFormat.aliases = [];
+    function icuMessageFormat(Prism) {
+      ;
+      (function(Prism2) {
+        function nested(source, level) {
+          if (level <= 0) {
+            return /[]/.source;
+          } else {
+            return source.replace(/<SELF>/g, function() {
+              return nested(source, level - 1);
+            });
+          }
+        }
+        var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/;
+        var escape = {
+          pattern: /''/,
+          greedy: true,
+          alias: "operator"
+        };
+        var string = {
+          pattern: stringPattern,
+          greedy: true,
+          inside: {
+            escape
+          }
+        };
+        var argumentSource = nested(
+          /\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source.replace(
+            /<STR>/g,
+            function() {
+              return stringPattern.source;
+            }
+          ),
+          8
+        );
+        var nestedMessage = {
+          pattern: RegExp(argumentSource),
+          inside: {
+            message: {
+              pattern: /^(\{)[\s\S]+(?=\}$)/,
+              lookbehind: true,
+              inside: null
+              // see below
+            },
+            "message-delimiter": {
+              pattern: /./,
+              alias: "punctuation"
+            }
+          }
+        };
+        Prism2.languages["icu-message-format"] = {
+          argument: {
+            pattern: RegExp(argumentSource),
+            greedy: true,
+            inside: {
+              content: {
+                pattern: /^(\{)[\s\S]+(?=\}$)/,
+                lookbehind: true,
+                inside: {
+                  "argument-name": {
+                    pattern: /^(\s*)[^{}:=,\s]+/,
+                    lookbehind: true
+                  },
+                  "choice-style": {
+                    // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details
+                    pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,
+                    lookbehind: true,
+                    inside: {
+                      punctuation: /\|/,
+                      range: {
+                        pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,
+                        lookbehind: true,
+                        inside: {
+                          operator: /[<#\u2264]/,
+                          number: /\S+/
+                        }
+                      },
+                      rest: null
+                      // see below
+                    }
+                  },
+                  "plural-style": {
+                    // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                    pattern: /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,
+                    lookbehind: true,
+                    inside: {
+                      offset: /^offset:\s*\d+/,
+                      "nested-message": nestedMessage,
+                      selector: {
+                        pattern: /=\d+|[^{}:=,\s]+/,
+                        inside: {
+                          keyword: /^(?:few|many|one|other|two|zero)$/
+                        }
+                      }
+                    }
+                  },
+                  "select-style": {
+                    // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                    pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,
+                    lookbehind: true,
+                    inside: {
+                      "nested-message": nestedMessage,
+                      selector: {
+                        pattern: /[^{}:=,\s]+/,
+                        inside: {
+                          keyword: /^other$/
+                        }
+                      }
+                    }
+                  },
+                  keyword: /\b(?:choice|plural|select|selectordinal)\b/,
+                  "arg-type": {
+                    pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/,
+                    alias: "keyword"
+                  },
+                  "arg-skeleton": {
+                    pattern: /(,\s*)::[^{}:=,\s]+/,
+                    lookbehind: true
+                  },
+                  "arg-style": {
+                    pattern: /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,
+                    lookbehind: true
+                  },
+                  "arg-style-text": {
+                    pattern: RegExp(
+                      /(^\s*,\s*(?=\S))/.source + nested(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source, 8) + "$"
+                    ),
+                    lookbehind: true,
+                    alias: "string"
+                  },
+                  punctuation: /,/
+                }
+              },
+              "argument-delimiter": {
+                pattern: /./,
+                alias: "operator"
+              }
+            }
+          },
+          escape,
+          string
+        };
+        nestedMessage.inside.message.inside = Prism2.languages["icu-message-format"];
+        Prism2.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest = Prism2.languages["icu-message-format"];
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_icu_message_format
+};

package/dist/chunk-LQIUIOZD.js

@@ -0,0 +1,312 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mongodb.js
+var require_mongodb = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mongodb.js"(exports, module) {
+    module.exports = mongodb;
+    mongodb.displayName = "mongodb";
+    mongodb.aliases = [];
+    function mongodb(Prism) {
+      ;
+      (function(Prism2) {
+        var operators = [
+          // query and projection
+          "$eq",
+          "$gt",
+          "$gte",
+          "$in",
+          "$lt",
+          "$lte",
+          "$ne",
+          "$nin",
+          "$and",
+          "$not",
+          "$nor",
+          "$or",
+          "$exists",
+          "$type",
+          "$expr",
+          "$jsonSchema",
+          "$mod",
+          "$regex",
+          "$text",
+          "$where",
+          "$geoIntersects",
+          "$geoWithin",
+          "$near",
+          "$nearSphere",
+          "$all",
+          "$elemMatch",
+          "$size",
+          "$bitsAllClear",
+          "$bitsAllSet",
+          "$bitsAnyClear",
+          "$bitsAnySet",
+          "$comment",
+          "$elemMatch",
+          "$meta",
+          "$slice",
+          // update
+          "$currentDate",
+          "$inc",
+          "$min",
+          "$max",
+          "$mul",
+          "$rename",
+          "$set",
+          "$setOnInsert",
+          "$unset",
+          "$addToSet",
+          "$pop",
+          "$pull",
+          "$push",
+          "$pullAll",
+          "$each",
+          "$position",
+          "$slice",
+          "$sort",
+          "$bit",
+          // aggregation pipeline stages
+          "$addFields",
+          "$bucket",
+          "$bucketAuto",
+          "$collStats",
+          "$count",
+          "$currentOp",
+          "$facet",
+          "$geoNear",
+          "$graphLookup",
+          "$group",
+          "$indexStats",
+          "$limit",
+          "$listLocalSessions",
+          "$listSessions",
+          "$lookup",
+          "$match",
+          "$merge",
+          "$out",
+          "$planCacheStats",
+          "$project",
+          "$redact",
+          "$replaceRoot",
+          "$replaceWith",
+          "$sample",
+          "$set",
+          "$skip",
+          "$sort",
+          "$sortByCount",
+          "$unionWith",
+          "$unset",
+          "$unwind",
+          "$setWindowFields",
+          // aggregation pipeline operators
+          "$abs",
+          "$accumulator",
+          "$acos",
+          "$acosh",
+          "$add",
+          "$addToSet",
+          "$allElementsTrue",
+          "$and",
+          "$anyElementTrue",
+          "$arrayElemAt",
+          "$arrayToObject",
+          "$asin",
+          "$asinh",
+          "$atan",
+          "$atan2",
+          "$atanh",
+          "$avg",
+          "$binarySize",
+          "$bsonSize",
+          "$ceil",
+          "$cmp",
+          "$concat",
+          "$concatArrays",
+          "$cond",
+          "$convert",
+          "$cos",
+          "$dateFromParts",
+          "$dateToParts",
+          "$dateFromString",
+          "$dateToString",
+          "$dayOfMonth",
+          "$dayOfWeek",
+          "$dayOfYear",
+          "$degreesToRadians",
+          "$divide",
+          "$eq",
+          "$exp",
+          "$filter",
+          "$first",
+          "$floor",
+          "$function",
+          "$gt",
+          "$gte",
+          "$hour",
+          "$ifNull",
+          "$in",
+          "$indexOfArray",
+          "$indexOfBytes",
+          "$indexOfCP",
+          "$isArray",
+          "$isNumber",
+          "$isoDayOfWeek",
+          "$isoWeek",
+          "$isoWeekYear",
+          "$last",
+          "$last",
+          "$let",
+          "$literal",
+          "$ln",
+          "$log",
+          "$log10",
+          "$lt",
+          "$lte",
+          "$ltrim",
+          "$map",
+          "$max",
+          "$mergeObjects",
+          "$meta",
+          "$min",
+          "$millisecond",
+          "$minute",
+          "$mod",
+          "$month",
+          "$multiply",
+          "$ne",
+          "$not",
+          "$objectToArray",
+          "$or",
+          "$pow",
+          "$push",
+          "$radiansToDegrees",
+          "$range",
+          "$reduce",
+          "$regexFind",
+          "$regexFindAll",
+          "$regexMatch",
+          "$replaceOne",
+          "$replaceAll",
+          "$reverseArray",
+          "$round",
+          "$rtrim",
+          "$second",
+          "$setDifference",
+          "$setEquals",
+          "$setIntersection",
+          "$setIsSubset",
+          "$setUnion",
+          "$size",
+          "$sin",
+          "$slice",
+          "$split",
+          "$sqrt",
+          "$stdDevPop",
+          "$stdDevSamp",
+          "$strcasecmp",
+          "$strLenBytes",
+          "$strLenCP",
+          "$substr",
+          "$substrBytes",
+          "$substrCP",
+          "$subtract",
+          "$sum",
+          "$switch",
+          "$tan",
+          "$toBool",
+          "$toDate",
+          "$toDecimal",
+          "$toDouble",
+          "$toInt",
+          "$toLong",
+          "$toObjectId",
+          "$toString",
+          "$toLower",
+          "$toUpper",
+          "$trim",
+          "$trunc",
+          "$type",
+          "$week",
+          "$year",
+          "$zip",
+          "$count",
+          "$dateAdd",
+          "$dateDiff",
+          "$dateSubtract",
+          "$dateTrunc",
+          "$getField",
+          "$rand",
+          "$sampleRate",
+          "$setField",
+          "$unsetField",
+          // aggregation pipeline query modifiers
+          "$comment",
+          "$explain",
+          "$hint",
+          "$max",
+          "$maxTimeMS",
+          "$min",
+          "$orderby",
+          "$query",
+          "$returnKey",
+          "$showDiskLoc",
+          "$natural"
+        ];
+        var builtinFunctions = [
+          "ObjectId",
+          "Code",
+          "BinData",
+          "DBRef",
+          "Timestamp",
+          "NumberLong",
+          "NumberDecimal",
+          "MaxKey",
+          "MinKey",
+          "RegExp",
+          "ISODate",
+          "UUID"
+        ];
+        operators = operators.map(function(operator) {
+          return operator.replace("$", "\\$");
+        });
+        var operatorsSource = "(?:" + operators.join("|") + ")\\b";
+        Prism2.languages.mongodb = Prism2.languages.extend("javascript", {});
+        Prism2.languages.insertBefore("mongodb", "string", {
+          property: {
+            pattern: /(?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)(?=\s*:)/,
+            greedy: true,
+            inside: {
+              keyword: RegExp(`^(['"])?` + operatorsSource + "(?:\\1)?$")
+            }
+          }
+        });
+        Prism2.languages.mongodb.string.inside = {
+          url: {
+            // url pattern
+            pattern: /https?:\/\/[-\w@:%.+~#=]{1,256}\.[a-z0-9()]{1,6}\b[-\w()@:%+.~#?&/=]*/i,
+            greedy: true
+          },
+          entity: {
+            // ipv4
+            pattern: /\b(?:(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d\d?|2[0-4]\d|25[0-5])\b/,
+            greedy: true
+          }
+        };
+        Prism2.languages.insertBefore("mongodb", "constant", {
+          builtin: {
+            pattern: RegExp("\\b(?:" + builtinFunctions.join("|") + ")\\b"),
+            alias: "keyword"
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_mongodb
+};

package/dist/chunk-LSJCH55S.js

@@ -0,0 +1,38 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/prolog.js
+var require_prolog = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/prolog.js"(exports, module) {
+    module.exports = prolog;
+    prolog.displayName = "prolog";
+    prolog.aliases = [];
+    function prolog(Prism) {
+      Prism.languages.prolog = {
+        // Syntax depends on the implementation
+        comment: {
+          pattern: /\/\*[\s\S]*?\*\/|%.*/,
+          greedy: true
+        },
+        // Depending on the implementation, strings may allow escaped newlines and quote-escape
+        string: {
+          pattern: /(["'])(?:\1\1|\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1(?!\1)/,
+          greedy: true
+        },
+        builtin: /\b(?:fx|fy|xf[xy]?|yfx?)\b/,
+        // FIXME: Should we list all null-ary predicates (not followed by a parenthesis) like halt, trace, etc.?
+        function: /\b[a-z]\w*(?:(?=\()|\/\d+)/,
+        number: /\b\d+(?:\.\d*)?/,
+        // Custom operators are allowed
+        operator: /[:\\=><\-?*@\/;+^|!$.]+|\b(?:is|mod|not|xor)\b/,
+        punctuation: /[(){}\[\],]/
+      };
+    }
+  }
+});
+
+export {
+  require_prolog
+};

package/dist/chunk-LSJTRURW.js

@@ -0,0 +1,153 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javastacktrace.js
+var require_javastacktrace = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javastacktrace.js"(exports, module) {
+    module.exports = javastacktrace;
+    javastacktrace.displayName = "javastacktrace";
+    javastacktrace.aliases = [];
+    function javastacktrace(Prism) {
+      Prism.languages.javastacktrace = {
+        // java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...]
+        // Caused by: java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...]
+        // Caused by: com.example.myproject.MyProjectServletException
+        // Caused by: MidLevelException: LowLevelException
+        // Suppressed: Resource$CloseFailException: Resource ID = 0
+        summary: {
+          pattern: /^([\t ]*)(?:(?:Caused by:|Suppressed:|Exception in thread "[^"]*")[\t ]+)?[\w$.]+(?::.*)?$/m,
+          lookbehind: true,
+          inside: {
+            keyword: {
+              pattern: /^([\t ]*)(?:(?:Caused by|Suppressed)(?=:)|Exception in thread)/m,
+              lookbehind: true
+            },
+            // the current thread if the summary starts with 'Exception in thread'
+            string: {
+              pattern: /^(\s*)"[^"]*"/,
+              lookbehind: true
+            },
+            exceptions: {
+              pattern: /^(:?\s*)[\w$.]+(?=:|$)/,
+              lookbehind: true,
+              inside: {
+                "class-name": /[\w$]+$/,
+                namespace: /\b[a-z]\w*\b/,
+                punctuation: /\./
+              }
+            },
+            message: {
+              pattern: /(:\s*)\S.*/,
+              lookbehind: true,
+              alias: "string"
+            },
+            punctuation: /:/
+          }
+        },
+        // at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1166)
+        // at org.hsqldb.jdbc.Util.throwError(Unknown Source) here could be some notes
+        // at java.base/java.lang.Class.forName0(Native Method)
+        // at Util.<init>(Unknown Source)
+        // at com.foo.loader/foo@9.0/com.foo.Main.run(Main.java:101)
+        // at com.foo.loader//com.foo.bar.App.run(App.java:12)
+        // at acme@2.1/org.acme.Lib.test(Lib.java:80)
+        // at MyClass.mash(MyClass.java:9)
+        //
+        // More information:
+        // https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/lang/StackTraceElement.html#toString()
+        //
+        // A valid Java module name is defined as:
+        //   "A module name consists of one or more Java identifiers (§3.8) separated by "." tokens."
+        // https://docs.oracle.com/javase/specs/jls/se9/html/jls-6.html#jls-ModuleName
+        //
+        // A Java module version is defined by this class:
+        // https://docs.oracle.com/javase/9/docs/api/java/lang/module/ModuleDescriptor.Version.html
+        // This is the implementation of the `parse` method in JDK13:
+        // https://github.com/matcdac/jdk/blob/2305df71d1b7710266ae0956d73927a225132c0f/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java#L1108
+        // However, to keep this simple, a version will be matched by the pattern /@[\w$.+-]*/.
+        "stack-frame": {
+          pattern: /^([\t ]*)at (?:[\w$./]|@[\w$.+-]*\/)+(?:<init>)?\([^()]*\)/m,
+          lookbehind: true,
+          inside: {
+            keyword: {
+              pattern: /^(\s*)at(?= )/,
+              lookbehind: true
+            },
+            source: [
+              // (Main.java:15)
+              // (Main.scala:15)
+              {
+                pattern: /(\()\w+\.\w+:\d+(?=\))/,
+                lookbehind: true,
+                inside: {
+                  file: /^\w+\.\w+/,
+                  punctuation: /:/,
+                  "line-number": {
+                    pattern: /\b\d+\b/,
+                    alias: "number"
+                  }
+                }
+              },
+              // (Unknown Source)
+              // (Native Method)
+              // (...something...)
+              {
+                pattern: /(\()[^()]*(?=\))/,
+                lookbehind: true,
+                inside: {
+                  keyword: /^(?:Native Method|Unknown Source)$/
+                }
+              }
+            ],
+            "class-name": /[\w$]+(?=\.(?:<init>|[\w$]+)\()/,
+            function: /(?:<init>|[\w$]+)(?=\()/,
+            "class-loader": {
+              pattern: /(\s)[a-z]\w*(?:\.[a-z]\w*)*(?=\/[\w@$.]*\/)/,
+              lookbehind: true,
+              alias: "namespace",
+              inside: {
+                punctuation: /\./
+              }
+            },
+            module: {
+              pattern: /([\s/])[a-z]\w*(?:\.[a-z]\w*)*(?:@[\w$.+-]*)?(?=\/)/,
+              lookbehind: true,
+              inside: {
+                version: {
+                  pattern: /(@)[\s\S]+/,
+                  lookbehind: true,
+                  alias: "number"
+                },
+                punctuation: /[@.]/
+              }
+            },
+            namespace: {
+              pattern: /(?:\b[a-z]\w*\.)+/,
+              inside: {
+                punctuation: /\./
+              }
+            },
+            punctuation: /[()/.]/
+          }
+        },
+        // ... 32 more
+        // ... 32 common frames omitted
+        more: {
+          pattern: /^([\t ]*)\.{3} \d+ [a-z]+(?: [a-z]+)*/m,
+          lookbehind: true,
+          inside: {
+            punctuation: /\.{3}/,
+            number: /\d+/,
+            keyword: /\b[a-z]+(?: [a-z]+)*\b/
+          }
+        }
+      };
+    }
+  }
+});
+
+export {
+  require_javastacktrace
+};