@distri/react 0.3.1 → 0.3.3

package/dist/chunk-DYKZ7WAD.js

@@ -0,0 +1,122 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/qsharp.js
+var require_qsharp = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/qsharp.js"(exports, module) {
+    module.exports = qsharp;
+    qsharp.displayName = "qsharp";
+    qsharp.aliases = ["qs"];
+    function qsharp(Prism) {
+      ;
+      (function(Prism2) {
+        function replace(pattern, replacements) {
+          return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+            return "(?:" + replacements[+index] + ")";
+          });
+        }
+        function re(pattern, replacements, flags) {
+          return RegExp(replace(pattern, replacements), flags || "");
+        }
+        function nested(pattern, depthLog2) {
+          for (var i = 0; i < depthLog2; i++) {
+            pattern = pattern.replace(/<<self>>/g, function() {
+              return "(?:" + pattern + ")";
+            });
+          }
+          return pattern.replace(/<<self>>/g, "[^\\s\\S]");
+        }
+        var keywordKinds = {
+          // keywords which represent a return or variable type
+          type: "Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero",
+          // all other keywords
+          other: "Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within"
+        };
+        function keywordsToPattern(words) {
+          return "\\b(?:" + words.trim().replace(/ /g, "|") + ")\\b";
+        }
+        var keywords = RegExp(
+          keywordsToPattern(keywordKinds.type + " " + keywordKinds.other)
+        );
+        var identifier = /\b[A-Za-z_]\w*\b/.source;
+        var qualifiedName = replace(/<<0>>(?:\s*\.\s*<<0>>)*/.source, [identifier]);
+        var typeInside = {
+          keyword: keywords,
+          punctuation: /[<>()?,.:[\]]/
+        };
+        var regularString = /"(?:\\.|[^\\"])*"/.source;
+        Prism2.languages.qsharp = Prism2.languages.extend("clike", {
+          comment: /\/\/.*/,
+          string: [
+            {
+              pattern: re(/(^|[^$\\])<<0>>/.source, [regularString]),
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          "class-name": [
+            {
+              // open Microsoft.Quantum.Canon;
+              // open Microsoft.Quantum.Canon as CN;
+              pattern: re(/(\b(?:as|open)\s+)<<0>>(?=\s*(?:;|as\b))/.source, [
+                qualifiedName
+              ]),
+              lookbehind: true,
+              inside: typeInside
+            },
+            {
+              // namespace Quantum.App1;
+              pattern: re(/(\bnamespace\s+)<<0>>(?=\s*\{)/.source, [qualifiedName]),
+              lookbehind: true,
+              inside: typeInside
+            }
+          ],
+          keyword: keywords,
+          number: /(?:\b0(?:x[\da-f]+|b[01]+|o[0-7]+)|(?:\B\.\d+|\b\d+(?:\.\d*)?)(?:e[-+]?\d+)?)l?\b/i,
+          operator: /\band=|\bor=|\band\b|\bnot\b|\bor\b|<[-=]|[-=]>|>>>=?|<<<=?|\^\^\^=?|\|\|\|=?|&&&=?|w\/=?|~~~|[*\/+\-^=!%]=?/,
+          punctuation: /::|[{}[\];(),.:]/
+        });
+        Prism2.languages.insertBefore("qsharp", "number", {
+          range: {
+            pattern: /\.\./,
+            alias: "operator"
+          }
+        });
+        var interpolationExpr = nested(
+          replace(/\{(?:[^"{}]|<<0>>|<<self>>)*\}/.source, [regularString]),
+          2
+        );
+        Prism2.languages.insertBefore("qsharp", "string", {
+          "interpolation-string": {
+            pattern: re(/\$"(?:\\.|<<0>>|[^\\"{])*"/.source, [interpolationExpr]),
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: re(/((?:^|[^\\])(?:\\\\)*)<<0>>/.source, [
+                  interpolationExpr
+                ]),
+                lookbehind: true,
+                inside: {
+                  punctuation: /^\{|\}$/,
+                  expression: {
+                    pattern: /[\s\S]+/,
+                    alias: "language-qsharp",
+                    inside: Prism2.languages.qsharp
+                  }
+                }
+              },
+              string: /[\s\S]+/
+            }
+          }
+        });
+      })(Prism);
+      Prism.languages.qs = Prism.languages.qsharp;
+    }
+  }
+});
+
+export {
+  require_qsharp
+};

package/dist/chunk-E3MMTLT7.js

@@ -0,0 +1,93 @@
+"use client";
+import {
+  require_sql
+} from "./chunk-DIPKDKOW.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apex.js
+var require_apex = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apex.js"(exports, module) {
+    var refractorSql = require_sql();
+    module.exports = apex;
+    apex.displayName = "apex";
+    apex.aliases = [];
+    function apex(Prism) {
+      Prism.register(refractorSql);
+      (function(Prism2) {
+        var keywords = /\b(?:(?:after|before)(?=\s+[a-z])|abstract|activate|and|any|array|as|asc|autonomous|begin|bigdecimal|blob|boolean|break|bulk|by|byte|case|cast|catch|char|class|collect|commit|const|continue|currency|date|datetime|decimal|default|delete|desc|do|double|else|end|enum|exception|exit|export|extends|final|finally|float|for|from|get(?=\s*[{};])|global|goto|group|having|hint|if|implements|import|in|inner|insert|instanceof|int|integer|interface|into|join|like|limit|list|long|loop|map|merge|new|not|null|nulls|number|object|of|on|or|outer|override|package|parallel|pragma|private|protected|public|retrieve|return|rollback|select|set|short|sObject|sort|static|string|super|switch|synchronized|system|testmethod|then|this|throw|time|transaction|transient|trigger|try|undelete|update|upsert|using|virtual|void|webservice|when|where|while|(?:inherited|with|without)\s+sharing)\b/i;
+        var className = /\b(?:(?=[a-z_]\w*\s*[<\[])|(?!<keyword>))[A-Z_]\w*(?:\s*\.\s*[A-Z_]\w*)*\b(?:\s*(?:\[\s*\]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>))*/.source.replace(
+          /<keyword>/g,
+          function() {
+            return keywords.source;
+          }
+        );
+        function insertClassName(pattern) {
+          return RegExp(
+            pattern.replace(/<CLASS-NAME>/g, function() {
+              return className;
+            }),
+            "i"
+          );
+        }
+        var classNameInside = {
+          keyword: keywords,
+          punctuation: /[()\[\]{};,:.<>]/
+        };
+        Prism2.languages.apex = {
+          comment: Prism2.languages.clike.comment,
+          string: Prism2.languages.clike.string,
+          sql: {
+            pattern: /((?:[=,({:]|\breturn)\s*)\[[^\[\]]*\]/i,
+            lookbehind: true,
+            greedy: true,
+            alias: "language-sql",
+            inside: Prism2.languages.sql
+          },
+          annotation: {
+            pattern: /@\w+\b/,
+            alias: "punctuation"
+          },
+          "class-name": [
+            {
+              pattern: insertClassName(
+                /(\b(?:class|enum|extends|implements|instanceof|interface|new|trigger\s+\w+\s+on)\s+)<CLASS-NAME>/.source
+              ),
+              lookbehind: true,
+              inside: classNameInside
+            },
+            {
+              // cast
+              pattern: insertClassName(
+                /(\(\s*)<CLASS-NAME>(?=\s*\)\s*[\w(])/.source
+              ),
+              lookbehind: true,
+              inside: classNameInside
+            },
+            {
+              // variable/parameter declaration and return types
+              pattern: insertClassName(/<CLASS-NAME>(?=\s*\w+\s*[;=,(){:])/.source),
+              inside: classNameInside
+            }
+          ],
+          trigger: {
+            pattern: /(\btrigger\s+)\w+\b/i,
+            lookbehind: true,
+            alias: "class-name"
+          },
+          keyword: keywords,
+          function: /\b[a-z_]\w*(?=\s*\()/i,
+          boolean: /\b(?:false|true)\b/i,
+          number: /(?:\B\.\d+|\b\d+(?:\.\d+|L)?)\b/i,
+          operator: /[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
+          punctuation: /[()\[\]{};,.]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_apex
+};

package/dist/chunk-E4OGXPQD.js

@@ -0,0 +1,41 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/go-module.js
+var require_go_module = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/go-module.js"(exports, module) {
+    module.exports = goModule;
+    goModule.displayName = "goModule";
+    goModule.aliases = [];
+    function goModule(Prism) {
+      Prism.languages["go-mod"] = Prism.languages["go-module"] = {
+        comment: {
+          pattern: /\/\/.*/,
+          greedy: true
+        },
+        version: {
+          pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,
+          lookbehind: true,
+          alias: "number"
+        },
+        "go-version": {
+          pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,
+          lookbehind: true,
+          alias: "number"
+        },
+        keyword: {
+          pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,
+          lookbehind: true
+        },
+        operator: /=>/,
+        punctuation: /[()[\],]/
+      };
+    }
+  }
+});
+
+export {
+  require_go_module
+};

package/dist/chunk-E4WYTZCV.js

@@ -0,0 +1,27 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/hsts.js
+var require_hsts = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/hsts.js"(exports, module) {
+    module.exports = hsts;
+    hsts.displayName = "hsts";
+    hsts.aliases = [];
+    function hsts(Prism) {
+      Prism.languages.hsts = {
+        directive: {
+          pattern: /\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i,
+          alias: "property"
+        },
+        operator: /=/,
+        punctuation: /;/
+      };
+    }
+  }
+});
+
+export {
+  require_hsts
+};

package/dist/chunk-E5VEHLSN.js

@@ -0,0 +1,117 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/regex.js
+var require_regex = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/regex.js"(exports, module) {
+    module.exports = regex;
+    regex.displayName = "regex";
+    regex.aliases = [];
+    function regex(Prism) {
+      ;
+      (function(Prism2) {
+        var specialEscape = {
+          pattern: /\\[\\(){}[\]^$+*?|.]/,
+          alias: "escape"
+        };
+        var escape = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/;
+        var charSet = {
+          pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+          alias: "class-name"
+        };
+        var charSetWithoutDot = {
+          pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+          alias: "class-name"
+        };
+        var rangeChar = "(?:[^\\\\-]|" + escape.source + ")";
+        var range = RegExp(rangeChar + "-" + rangeChar);
+        var groupName = {
+          pattern: /(<|')[^<>']+(?=[>']$)/,
+          lookbehind: true,
+          alias: "variable"
+        };
+        Prism2.languages.regex = {
+          "char-class": {
+            pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+            lookbehind: true,
+            inside: {
+              "char-class-negation": {
+                pattern: /(^\[)\^/,
+                lookbehind: true,
+                alias: "operator"
+              },
+              "char-class-punctuation": {
+                pattern: /^\[|\]$/,
+                alias: "punctuation"
+              },
+              range: {
+                pattern: range,
+                inside: {
+                  escape,
+                  "range-punctuation": {
+                    pattern: /-/,
+                    alias: "operator"
+                  }
+                }
+              },
+              "special-escape": specialEscape,
+              "char-set": charSetWithoutDot,
+              escape
+            }
+          },
+          "special-escape": specialEscape,
+          "char-set": charSet,
+          backreference: [
+            {
+              // a backreference which is not an octal escape
+              pattern: /\\(?![123][0-7]{2})[1-9]/,
+              alias: "keyword"
+            },
+            {
+              pattern: /\\k<[^<>']+>/,
+              alias: "keyword",
+              inside: {
+                "group-name": groupName
+              }
+            }
+          ],
+          anchor: {
+            pattern: /[$^]|\\[ABbGZz]/,
+            alias: "function"
+          },
+          escape,
+          group: [
+            {
+              // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+              // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+              // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+              pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+              alias: "punctuation",
+              inside: {
+                "group-name": groupName
+              }
+            },
+            {
+              pattern: /\)/,
+              alias: "punctuation"
+            }
+          ],
+          quantifier: {
+            pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+            alias: "number"
+          },
+          alternation: {
+            pattern: /\|/,
+            alias: "keyword"
+          }
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_regex
+};

package/dist/chunk-ECQZQ46F.js

@@ -0,0 +1,196 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lisp.js
+var require_lisp = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lisp.js"(exports, module) {
+    module.exports = lisp;
+    lisp.displayName = "lisp";
+    lisp.aliases = [];
+    function lisp(Prism) {
+      ;
+      (function(Prism2) {
+        function simple_form(name) {
+          return RegExp(/(\()/.source + "(?:" + name + ")" + /(?=[\s\)])/.source);
+        }
+        function primitive(pattern) {
+          return RegExp(
+            /([\s([])/.source + "(?:" + pattern + ")" + /(?=[\s)])/.source
+          );
+        }
+        var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source;
+        var marker = "&" + symbol;
+        var par = "(\\()";
+        var endpar = "(?=\\))";
+        var space = "(?=\\s)";
+        var nestedPar = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source;
+        var language = {
+          // Three or four semicolons are considered a heading.
+          // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
+          heading: {
+            pattern: /;;;.*/,
+            alias: ["comment", "title"]
+          },
+          comment: /;.*/,
+          string: {
+            pattern: /"(?:[^"\\]|\\.)*"/,
+            greedy: true,
+            inside: {
+              argument: /[-A-Z]+(?=[.,\s])/,
+              symbol: RegExp("`" + symbol + "'")
+            }
+          },
+          "quoted-symbol": {
+            pattern: RegExp("#?'" + symbol),
+            alias: ["variable", "symbol"]
+          },
+          "lisp-property": {
+            pattern: RegExp(":" + symbol),
+            alias: "property"
+          },
+          splice: {
+            pattern: RegExp(",@?" + symbol),
+            alias: ["symbol", "variable"]
+          },
+          keyword: [
+            {
+              pattern: RegExp(
+                par + "(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)" + space
+              ),
+              lookbehind: true
+            },
+            {
+              pattern: RegExp(
+                par + "(?:append|by|collect|concat|do|finally|for|in|return)" + space
+              ),
+              lookbehind: true
+            }
+          ],
+          declare: {
+            pattern: simple_form(/declare/.source),
+            lookbehind: true,
+            alias: "keyword"
+          },
+          interactive: {
+            pattern: simple_form(/interactive/.source),
+            lookbehind: true,
+            alias: "keyword"
+          },
+          boolean: {
+            pattern: primitive(/nil|t/.source),
+            lookbehind: true
+          },
+          number: {
+            pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source),
+            lookbehind: true
+          },
+          defvar: {
+            pattern: RegExp(par + "def(?:const|custom|group|var)\\s+" + symbol),
+            lookbehind: true,
+            inside: {
+              keyword: /^def[a-z]+/,
+              variable: RegExp(symbol)
+            }
+          },
+          defun: {
+            pattern: RegExp(
+              par + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + symbol + /\s+\(/.source + nestedPar + /\)/.source
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              keyword: /^(?:cl-)?def\S+/,
+              // See below, this property needs to be defined later so that it can
+              // reference the language object.
+              arguments: null,
+              function: {
+                pattern: RegExp("(^\\s)" + symbol),
+                lookbehind: true
+              },
+              punctuation: /[()]/
+            }
+          },
+          lambda: {
+            pattern: RegExp(
+              par + "lambda\\s+\\(\\s*(?:&?" + symbol + "(?:\\s+&?" + symbol + ")*\\s*)?\\)"
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              keyword: /^lambda/,
+              // See below, this property needs to be defined later so that it can
+              // reference the language object.
+              arguments: null,
+              punctuation: /[()]/
+            }
+          },
+          car: {
+            pattern: RegExp(par + symbol),
+            lookbehind: true
+          },
+          punctuation: [
+            // open paren, brackets, and close paren
+            /(?:['`,]?\(|[)\[\]])/,
+            // cons
+            {
+              pattern: /(\s)\.(?=\s)/,
+              lookbehind: true
+            }
+          ]
+        };
+        var arg = {
+          "lisp-marker": RegExp(marker),
+          varform: {
+            pattern: RegExp(
+              /\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source
+            ),
+            inside: language
+          },
+          argument: {
+            pattern: RegExp(/(^|[\s(])/.source + symbol),
+            lookbehind: true,
+            alias: "variable"
+          },
+          rest: language
+        };
+        var forms = "\\S+(?:\\s+\\S+)*";
+        var arglist = {
+          pattern: RegExp(par + nestedPar + endpar),
+          lookbehind: true,
+          inside: {
+            "rest-vars": {
+              pattern: RegExp("&(?:body|rest)\\s+" + forms),
+              inside: arg
+            },
+            "other-marker-vars": {
+              pattern: RegExp("&(?:aux|optional)\\s+" + forms),
+              inside: arg
+            },
+            keys: {
+              pattern: RegExp("&key\\s+" + forms + "(?:\\s+&allow-other-keys)?"),
+              inside: arg
+            },
+            argument: {
+              pattern: RegExp(symbol),
+              alias: "variable"
+            },
+            punctuation: /[()]/
+          }
+        };
+        language["lambda"].inside.arguments = arglist;
+        language["defun"].inside.arguments = Prism2.util.clone(arglist);
+        language["defun"].inside.arguments.inside.sublist = arglist;
+        Prism2.languages.lisp = language;
+        Prism2.languages.elisp = language;
+        Prism2.languages.emacs = language;
+        Prism2.languages["emacs-lisp"] = language;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_lisp
+};

package/dist/chunk-EJSYBCND.js

@@ -0,0 +1,60 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dataweave.js
+var require_dataweave = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dataweave.js"(exports, module) {
+    module.exports = dataweave;
+    dataweave.displayName = "dataweave";
+    dataweave.aliases = [];
+    function dataweave(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.dataweave = {
+          url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
+          property: {
+            pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
+            greedy: true
+          },
+          string: {
+            pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+            greedy: true
+          },
+          "mime-type": /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
+          date: {
+            pattern: /\|[\w:+-]+\|/,
+            greedy: true
+          },
+          comment: [
+            {
+              pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              pattern: /(^|[^\\:])\/\/.*/,
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          regex: {
+            pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
+            greedy: true
+          },
+          keyword: /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
+          function: /\b[A-Z_]\w*(?=\s*\()/i,
+          number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+          punctuation: /[{}[\];(),.:@]/,
+          operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
+          boolean: /\b(?:false|true)\b/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_dataweave
+};