@distri/react 0.3.1 → 0.3.2

package/dist/chunk-VIBEIY5K.js

@@ -0,0 +1,73 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/toml.js
+var require_toml = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/toml.js"(exports, module) {
+    module.exports = toml;
+    toml.displayName = "toml";
+    toml.aliases = [];
+    function toml(Prism) {
+      ;
+      (function(Prism2) {
+        var key = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
+        function insertKey(pattern) {
+          return pattern.replace(/__/g, function() {
+            return key;
+          });
+        }
+        Prism2.languages.toml = {
+          comment: {
+            pattern: /#.*/,
+            greedy: true
+          },
+          table: {
+            pattern: RegExp(
+              insertKey(
+                /(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source
+              ),
+              "m"
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "class-name"
+          },
+          key: {
+            pattern: RegExp(
+              insertKey(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source),
+              "m"
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "property"
+          },
+          string: {
+            pattern: /"""(?:\\[\s\S]|[^\\])*?"""|'''[\s\S]*?'''|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*"/,
+            greedy: true
+          },
+          date: [
+            {
+              // Offset Date-Time, Local Date-Time, Local Date
+              pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
+              alias: "number"
+            },
+            {
+              // Local Time
+              pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
+              alias: "number"
+            }
+          ],
+          number: /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
+          boolean: /\b(?:false|true)\b/,
+          punctuation: /[.,=[\]{}]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_toml
+};

package/dist/chunk-VJYOOKEI.js

@@ -0,0 +1,37 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/openqasm.js
+var require_openqasm = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/openqasm.js"(exports, module) {
+    module.exports = openqasm;
+    openqasm.displayName = "openqasm";
+    openqasm.aliases = ["qasm"];
+    function openqasm(Prism) {
+      Prism.languages.openqasm = {
+        comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
+        string: {
+          pattern: /"[^"\r\n\t]*"|'[^'\r\n\t]*'/,
+          greedy: true
+        },
+        keyword: /\b(?:CX|OPENQASM|U|barrier|boxas|boxto|break|const|continue|ctrl|def|defcal|defcalgrammar|delay|else|end|for|gate|gphase|if|in|include|inv|kernel|lengthof|let|measure|pow|reset|return|rotary|stretchinf|while)\b|#pragma\b/,
+        "class-name": /\b(?:angle|bit|bool|creg|fixed|float|int|length|qreg|qubit|stretch|uint)\b/,
+        function: /\b(?:cos|exp|ln|popcount|rotl|rotr|sin|sqrt|tan)\b(?=\s*\()/,
+        constant: /\b(?:euler|pi|tau)\b|π|𝜏|ℇ/,
+        number: {
+          pattern: /(^|[^.\w$])(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?(?:dt|ns|us|µs|ms|s)?/i,
+          lookbehind: true
+        },
+        operator: /->|>>=?|<<=?|&&|\|\||\+\+|--|[!=<>&|~^+\-*/%]=?|@/,
+        punctuation: /[(){}\[\];,:.]/
+      };
+      Prism.languages.qasm = Prism.languages.openqasm;
+    }
+  }
+});
+
+export {
+  require_openqasm
+};

package/dist/chunk-VRJ72GMO.js

@@ -0,0 +1,166 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/graphql.js
+var require_graphql = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/graphql.js"(exports, module) {
+    module.exports = graphql;
+    graphql.displayName = "graphql";
+    graphql.aliases = [];
+    function graphql(Prism) {
+      Prism.languages.graphql = {
+        comment: /#.*/,
+        description: {
+          pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
+          greedy: true,
+          alias: "string",
+          inside: {
+            "language-markdown": {
+              pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
+              lookbehind: true,
+              inside: Prism.languages.markdown
+            }
+          }
+        },
+        string: {
+          pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
+          greedy: true
+        },
+        number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        boolean: /\b(?:false|true)\b/,
+        variable: /\$[a-z_]\w*/i,
+        directive: {
+          pattern: /@[a-z_]\w*/i,
+          alias: "function"
+        },
+        "attr-name": {
+          pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
+          greedy: true
+        },
+        "atom-input": {
+          pattern: /\b[A-Z]\w*Input\b/,
+          alias: "class-name"
+        },
+        scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+        constant: /\b[A-Z][A-Z_\d]*\b/,
+        "class-name": {
+          pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+          lookbehind: true
+        },
+        fragment: {
+          pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
+          lookbehind: true,
+          alias: "function"
+        },
+        "definition-mutation": {
+          pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
+          lookbehind: true,
+          alias: "function"
+        },
+        "definition-query": {
+          pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
+          lookbehind: true,
+          alias: "function"
+        },
+        keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+        operator: /[!=|&]|\.{3}/,
+        "property-query": /\w+(?=\s*\()/,
+        object: /\w+(?=\s*\{)/,
+        punctuation: /[!(){}\[\]:=,]/,
+        property: /\w+/
+      };
+      Prism.hooks.add("after-tokenize", function afterTokenizeGraphql(env) {
+        if (env.language !== "graphql") {
+          return;
+        }
+        var validTokens = env.tokens.filter(function(token) {
+          return typeof token !== "string" && token.type !== "comment" && token.type !== "scalar";
+        });
+        var currentIndex = 0;
+        function getToken(offset) {
+          return validTokens[currentIndex + offset];
+        }
+        function isTokenType(types, offset) {
+          offset = offset || 0;
+          for (var i2 = 0; i2 < types.length; i2++) {
+            var token = getToken(i2 + offset);
+            if (!token || token.type !== types[i2]) {
+              return false;
+            }
+          }
+          return true;
+        }
+        function findClosingBracket(open, close) {
+          var stackHeight = 1;
+          for (var i2 = currentIndex; i2 < validTokens.length; i2++) {
+            var token = validTokens[i2];
+            var content = token.content;
+            if (token.type === "punctuation" && typeof content === "string") {
+              if (open.test(content)) {
+                stackHeight++;
+              } else if (close.test(content)) {
+                stackHeight--;
+                if (stackHeight === 0) {
+                  return i2;
+                }
+              }
+            }
+          }
+          return -1;
+        }
+        function addAlias(token, alias) {
+          var aliases = token.alias;
+          if (!aliases) {
+            token.alias = aliases = [];
+          } else if (!Array.isArray(aliases)) {
+            token.alias = aliases = [aliases];
+          }
+          aliases.push(alias);
+        }
+        for (; currentIndex < validTokens.length; ) {
+          var startToken = validTokens[currentIndex++];
+          if (startToken.type === "keyword" && startToken.content === "mutation") {
+            var inputVariables = [];
+            if (isTokenType(["definition-mutation", "punctuation"]) && getToken(1).content === "(") {
+              currentIndex += 2;
+              var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
+              if (definitionEnd === -1) {
+                continue;
+              }
+              for (; currentIndex < definitionEnd; currentIndex++) {
+                var t = getToken(0);
+                if (t.type === "variable") {
+                  addAlias(t, "variable-input");
+                  inputVariables.push(t.content);
+                }
+              }
+              currentIndex = definitionEnd + 1;
+            }
+            if (isTokenType(["punctuation", "property-query"]) && getToken(0).content === "{") {
+              currentIndex++;
+              addAlias(getToken(0), "property-mutation");
+              if (inputVariables.length > 0) {
+                var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
+                if (mutationEnd === -1) {
+                  continue;
+                }
+                for (var i = currentIndex; i < mutationEnd; i++) {
+                  var varToken = validTokens[i];
+                  if (varToken.type === "variable" && inputVariables.indexOf(varToken.content) >= 0) {
+                    addAlias(varToken, "variable-input");
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_graphql
+};

package/dist/chunk-VUCUUNVX.js

@@ -0,0 +1,30 @@
+"use client";
+import {
+  require_t4_templating
+} from "./chunk-F3IVXEVB.js";
+import {
+  require_csharp
+} from "./chunk-TR5CHC4X.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/t4-cs.js
+var require_t4_cs = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/t4-cs.js"(exports, module) {
+    var refractorT4Templating = require_t4_templating();
+    var refractorCsharp = require_csharp();
+    module.exports = t4Cs;
+    t4Cs.displayName = "t4Cs";
+    t4Cs.aliases = [];
+    function t4Cs(Prism) {
+      Prism.register(refractorT4Templating);
+      Prism.register(refractorCsharp);
+      Prism.languages.t4 = Prism.languages["t4-cs"] = Prism.languages["t4-templating"].createT4("csharp");
+    }
+  }
+});
+
+export {
+  require_t4_cs
+};

package/dist/chunk-W23BPRNS.js

@@ -0,0 +1,77 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/purebasic.js
+var require_purebasic = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/purebasic.js"(exports, module) {
+    module.exports = purebasic;
+    purebasic.displayName = "purebasic";
+    purebasic.aliases = [];
+    function purebasic(Prism) {
+      Prism.languages.purebasic = Prism.languages.extend("clike", {
+        comment: /;.*/,
+        keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
+        function: /\b\w+(?:\.\w+)?\s*(?=\()/,
+        number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
+        operator: /(?:@\*?|\?|\*)\w+|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
+      });
+      Prism.languages.insertBefore("purebasic", "keyword", {
+        tag: /#\w+\$?/,
+        asm: {
+          pattern: /(^[\t ]*)!.*/m,
+          lookbehind: true,
+          alias: "tag",
+          inside: {
+            comment: /;.*/,
+            string: {
+              pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+              greedy: true
+            },
+            // Anonymous label references, i.e.: jmp @b
+            "label-reference-anonymous": {
+              pattern: /(!\s*j[a-z]+\s+)@[fb]/i,
+              lookbehind: true,
+              alias: "fasm-label"
+            },
+            // Named label reference, i.e.: jne label1
+            "label-reference-addressed": {
+              pattern: /(!\s*j[a-z]+\s+)[A-Z._?$@][\w.?$@~#]*/i,
+              lookbehind: true,
+              alias: "fasm-label"
+            },
+            keyword: [
+              /\b(?:extern|global)\b[^;\r\n]*/i,
+              /\b(?:CPU|DEFAULT|FLOAT)\b.*/
+            ],
+            function: {
+              pattern: /^([\t ]*!\s*)[\da-z]+(?=\s|$)/im,
+              lookbehind: true
+            },
+            "function-inline": {
+              pattern: /(:\s*)[\da-z]+(?=\s)/i,
+              lookbehind: true,
+              alias: "function"
+            },
+            label: {
+              pattern: /^([\t ]*!\s*)[A-Za-z._?$@][\w.?$@~#]*(?=:)/m,
+              lookbehind: true,
+              alias: "fasm-label"
+            },
+            register: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\d+)\b/i,
+            number: /(?:\b|-|(?=\$))(?:0[hx](?:[\da-f]*\.)?[\da-f]+(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+            operator: /[\[\]*+\-/%<>=&|$!,.:]/
+          }
+        }
+      });
+      delete Prism.languages.purebasic["class-name"];
+      delete Prism.languages.purebasic["boolean"];
+      Prism.languages.pbfasm = Prism.languages["purebasic"];
+    }
+  }
+});
+
+export {
+  require_purebasic
+};

package/dist/chunk-W344P3PI.js

@@ -0,0 +1,65 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tcl.js
+var require_tcl = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tcl.js"(exports, module) {
+    module.exports = tcl;
+    tcl.displayName = "tcl";
+    tcl.aliases = [];
+    function tcl(Prism) {
+      Prism.languages.tcl = {
+        comment: {
+          pattern: /(^|[^\\])#.*/,
+          lookbehind: true
+        },
+        string: {
+          pattern: /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"/,
+          greedy: true
+        },
+        variable: [
+          {
+            pattern: /(\$)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/,
+            lookbehind: true
+          },
+          {
+            pattern: /(\$)\{[^}]+\}/,
+            lookbehind: true
+          },
+          {
+            pattern: /(^[\t ]*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
+            lookbehind: true
+          }
+        ],
+        function: {
+          pattern: /(^[\t ]*proc[ \t]+)\S+/m,
+          lookbehind: true
+        },
+        builtin: [
+          {
+            pattern: /(^[\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\b/m,
+            lookbehind: true
+          },
+          /\b(?:else|elseif)\b/
+        ],
+        scope: {
+          pattern: /(^[\t ]*)(?:global|upvar|variable)\b/m,
+          lookbehind: true,
+          alias: "constant"
+        },
+        keyword: {
+          pattern: /(^[\t ]*|\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
+          lookbehind: true
+        },
+        operator: /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|in|ne|ni)\b/,
+        punctuation: /[{}()\[\]]/
+      };
+    }
+  }
+});
+
+export {
+  require_tcl
+};

package/dist/chunk-W5UXHXCI.js

@@ -0,0 +1,71 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/coq.js
+var require_coq = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/coq.js"(exports, module) {
+    module.exports = coq;
+    coq.displayName = "coq";
+    coq.aliases = [];
+    function coq(Prism) {
+      ;
+      (function(Prism2) {
+        var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
+        for (var i = 0; i < 2; i++) {
+          commentSource = commentSource.replace(/<self>/g, function() {
+            return commentSource;
+          });
+        }
+        commentSource = commentSource.replace(/<self>/g, "[]");
+        Prism2.languages.coq = {
+          comment: RegExp(commentSource),
+          string: {
+            pattern: /"(?:[^"]|"")*"(?!")/,
+            greedy: true
+          },
+          attribute: [
+            {
+              pattern: RegExp(
+                /#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
+                  /<comment>/g,
+                  function() {
+                    return commentSource;
+                  }
+                )
+              ),
+              greedy: true,
+              alias: "attr-name",
+              inside: {
+                comment: RegExp(commentSource),
+                string: {
+                  pattern: /"(?:[^"]|"")*"(?!")/,
+                  greedy: true
+                },
+                operator: /=/,
+                punctuation: /^#\[|\]$|[,()]/
+              }
+            },
+            {
+              pattern: /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
+              alias: "attr-name"
+            }
+          ],
+          keyword: /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
+          number: /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
+          punct: {
+            pattern: /@\{|\{\||\[=|:>/,
+            alias: "punctuation"
+          },
+          operator: /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
+          punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_coq
+};

package/dist/chunk-WA6NBVF4.js

@@ -0,0 +1,39 @@
+"use client";
+import {
+  require_turtle
+} from "./chunk-5WQRG6G3.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sparql.js
+var require_sparql = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sparql.js"(exports, module) {
+    var refractorTurtle = require_turtle();
+    module.exports = sparql;
+    sparql.displayName = "sparql";
+    sparql.aliases = ["rq"];
+    function sparql(Prism) {
+      Prism.register(refractorTurtle);
+      Prism.languages.sparql = Prism.languages.extend("turtle", {
+        boolean: /\b(?:false|true)\b/i,
+        variable: {
+          pattern: /[?$]\w+/,
+          greedy: true
+        }
+      });
+      Prism.languages.insertBefore("sparql", "punctuation", {
+        keyword: [
+          /\b(?:A|ADD|ALL|AS|ASC|ASK|BNODE|BY|CLEAR|CONSTRUCT|COPY|CREATE|DATA|DEFAULT|DELETE|DESC|DESCRIBE|DISTINCT|DROP|EXISTS|FILTER|FROM|GROUP|HAVING|INSERT|INTO|LIMIT|LOAD|MINUS|MOVE|NAMED|NOT|NOW|OFFSET|OPTIONAL|ORDER|RAND|REDUCED|SELECT|SEPARATOR|SERVICE|SILENT|STRUUID|UNION|USING|UUID|VALUES|WHERE)\b/i,
+          /\b(?:ABS|AVG|BIND|BOUND|CEIL|COALESCE|CONCAT|CONTAINS|COUNT|DATATYPE|DAY|ENCODE_FOR_URI|FLOOR|GROUP_CONCAT|HOURS|IF|IRI|isBLANK|isIRI|isLITERAL|isNUMERIC|isURI|LANG|LANGMATCHES|LCASE|MAX|MD5|MIN|MINUTES|MONTH|REGEX|REPLACE|ROUND|sameTerm|SAMPLE|SECONDS|SHA1|SHA256|SHA384|SHA512|STR|STRAFTER|STRBEFORE|STRDT|STRENDS|STRLANG|STRLEN|STRSTARTS|SUBSTR|SUM|TIMEZONE|TZ|UCASE|URI|YEAR)\b(?=\s*\()/i,
+          /\b(?:BASE|GRAPH|PREFIX)\b/i
+        ]
+      });
+      Prism.languages.rq = Prism.languages.sparql;
+    }
+  }
+});
+
+export {
+  require_sparql
+};

package/dist/chunk-WC3TRKEX.js

@@ -0,0 +1,97 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wiki.js
+var require_wiki = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wiki.js"(exports, module) {
+    module.exports = wiki;
+    wiki.displayName = "wiki";
+    wiki.aliases = [];
+    function wiki(Prism) {
+      Prism.languages.wiki = Prism.languages.extend("markup", {
+        "block-comment": {
+          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+          lookbehind: true,
+          alias: "comment"
+        },
+        heading: {
+          pattern: /^(=+)[^=\r\n].*?\1/m,
+          inside: {
+            punctuation: /^=+|=+$/,
+            important: /.+/
+          }
+        },
+        emphasis: {
+          // TODO Multi-line
+          pattern: /('{2,5}).+?\1/,
+          inside: {
+            "bold-italic": {
+              pattern: /(''''').+?(?=\1)/,
+              lookbehind: true,
+              alias: ["bold", "italic"]
+            },
+            bold: {
+              pattern: /(''')[^'](?:.*?[^'])?(?=\1)/,
+              lookbehind: true
+            },
+            italic: {
+              pattern: /('')[^'](?:.*?[^'])?(?=\1)/,
+              lookbehind: true
+            },
+            punctuation: /^''+|''+$/
+          }
+        },
+        hr: {
+          pattern: /^-{4,}/m,
+          alias: "punctuation"
+        },
+        url: [
+          /ISBN +(?:97[89][ -]?)?(?:\d[ -]?){9}[\dx]\b|(?:PMID|RFC) +\d+/i,
+          /\[\[.+?\]\]|\[.+?\]/
+        ],
+        variable: [
+          /__[A-Z]+__/,
+          // FIXME Nested structures should be handled
+          // {{formatnum:{{#expr:{{{3}}}}}}}
+          /\{{3}.+?\}{3}/,
+          /\{\{.+?\}\}/
+        ],
+        symbol: [/^#redirect/im, /~{3,5}/],
+        // Handle table attrs:
+        // {|
+        // ! style="text-align:left;"| Item
+        // |}
+        "table-tag": {
+          pattern: /((?:^|[|!])[|!])[^|\r\n]+\|(?!\|)/m,
+          lookbehind: true,
+          inside: {
+            "table-bar": {
+              pattern: /\|$/,
+              alias: "punctuation"
+            },
+            rest: Prism.languages.markup["tag"].inside
+          }
+        },
+        punctuation: /^(?:\{\||\|\}|\|-|[*#:;!|])|\|\||!!/m
+      });
+      Prism.languages.insertBefore("wiki", "tag", {
+        // Prevent highlighting inside <nowiki>, <source> and <pre> tags
+        nowiki: {
+          pattern: /<(nowiki|pre|source)\b[^>]*>[\s\S]*?<\/\1>/i,
+          inside: {
+            tag: {
+              pattern: /<(?:nowiki|pre|source)\b[^>]*>|<\/(?:nowiki|pre|source)>/i,
+              inside: Prism.languages.markup["tag"].inside
+            }
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_wiki
+};