@distri/react 0.3.1 → 0.3.3

package/dist/chunk-NF3NJF7X.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-NH3HO3D4.js

@@ -0,0 +1,101 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vala.js
+var require_vala = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vala.js"(exports, module) {
+    module.exports = vala;
+    vala.displayName = "vala";
+    vala.aliases = [];
+    function vala(Prism) {
+      Prism.languages.vala = Prism.languages.extend("clike", {
+        // Classes copied from prism-csharp
+        "class-name": [
+          {
+            // (Foo bar, Bar baz)
+            pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=(?:\?\s+|\*?\s+\*?)\w)/,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          {
+            // [Foo]
+            pattern: /(\[)[A-Z]\w*(?:\.\w+)*\b/,
+            lookbehind: true,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          {
+            // class Foo : Bar
+            pattern: /(\b(?:class|interface)\s+[A-Z]\w*(?:\.\w+)*\s*:\s*)[A-Z]\w*(?:\.\w+)*\b/,
+            lookbehind: true,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          {
+            // class Foo
+            pattern: /((?:\b(?:class|enum|interface|new|struct)\s+)|(?:catch\s+\())[A-Z]\w*(?:\.\w+)*\b/,
+            lookbehind: true,
+            inside: {
+              punctuation: /\./
+            }
+          }
+        ],
+        keyword: /\b(?:abstract|as|assert|async|base|bool|break|case|catch|char|class|const|construct|continue|default|delegate|delete|do|double|dynamic|else|ensures|enum|errordomain|extern|finally|float|for|foreach|get|if|in|inline|int|int16|int32|int64|int8|interface|internal|is|lock|long|namespace|new|null|out|override|owned|params|private|protected|public|ref|requires|return|set|short|signal|sizeof|size_t|ssize_t|static|string|struct|switch|this|throw|throws|try|typeof|uchar|uint|uint16|uint32|uint64|uint8|ulong|unichar|unowned|ushort|using|value|var|virtual|void|volatile|weak|while|yield)\b/i,
+        function: /\b\w+(?=\s*\()/,
+        number: /(?:\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?:f|u?l?)?/i,
+        operator: /\+\+|--|&&|\|\||<<=?|>>=?|=>|->|~|[+\-*\/%&^|=!<>]=?|\?\??|\.\.\./,
+        punctuation: /[{}[\];(),.:]/,
+        constant: /\b[A-Z0-9_]+\b/
+      });
+      Prism.languages.insertBefore("vala", "string", {
+        "raw-string": {
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true,
+          alias: "string"
+        },
+        "template-string": {
+          pattern: /@"[\s\S]*?"/,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /\$(?:\([^)]*\)|[a-zA-Z]\w*)/,
+              inside: {
+                delimiter: {
+                  pattern: /^\$\(?|\)$/,
+                  alias: "punctuation"
+                },
+                rest: Prism.languages.vala
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      });
+      Prism.languages.insertBefore("vala", "keyword", {
+        regex: {
+          pattern: /\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[imsx]{0,4}(?=\s*(?:$|[\r\n,.;})\]]))/,
+          greedy: true,
+          inside: {
+            "regex-source": {
+              pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+              lookbehind: true,
+              alias: "language-regex",
+              inside: Prism.languages.regex
+            },
+            "regex-delimiter": /^\//,
+            "regex-flags": /^[a-z]+$/
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_vala
+};

package/dist/chunk-NMF5JCGX.js

@@ -0,0 +1,49 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/magma.js
+var require_magma = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/magma.js"(exports, module) {
+    module.exports = magma;
+    magma.displayName = "magma";
+    magma.aliases = [];
+    function magma(Prism) {
+      Prism.languages.magma = {
+        output: {
+          pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+          lookbehind: true,
+          greedy: true
+        },
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: true
+        },
+        string: {
+          pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+          lookbehind: true,
+          greedy: true
+        },
+        // http://magma.maths.usyd.edu.au/magma/handbook/text/82
+        keyword: /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/,
+        boolean: /\b(?:false|true)\b/,
+        generator: {
+          pattern: /\b[a-z_]\w*(?=\s*<)/i,
+          alias: "class-name"
+        },
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: {
+          pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+          lookbehind: true
+        },
+        operator: /->|[-+*/^~!|#=]|:=|\.\./,
+        punctuation: /[()[\]{}<>,;.:]/
+      };
+    }
+  }
+});
+
+export {
+  require_magma
+};

package/dist/chunk-NMYFSUVO.js

@@ -0,0 +1,106 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pascaligo.js
+var require_pascaligo = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pascaligo.js"(exports, module) {
+    module.exports = pascaligo;
+    pascaligo.displayName = "pascaligo";
+    pascaligo.aliases = [];
+    function pascaligo(Prism) {
+      ;
+      (function(Prism2) {
+        var braces = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source;
+        var type = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(
+          /<braces>/g,
+          function() {
+            return braces;
+          }
+        );
+        var pascaligo2 = Prism2.languages.pascaligo = {
+          comment: /\(\*[\s\S]+?\*\)|\/\/.*/,
+          string: {
+            pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,
+            greedy: true
+          },
+          "class-name": [
+            {
+              pattern: RegExp(
+                /(\btype\s+\w+\s+is\s+)<type>/.source.replace(
+                  /<type>/g,
+                  function() {
+                    return type;
+                  }
+                ),
+                "i"
+              ),
+              lookbehind: true,
+              inside: null
+              // see below
+            },
+            {
+              pattern: RegExp(
+                /<type>(?=\s+is\b)/.source.replace(/<type>/g, function() {
+                  return type;
+                }),
+                "i"
+              ),
+              inside: null
+              // see below
+            },
+            {
+              pattern: RegExp(
+                /(:\s*)<type>/.source.replace(/<type>/g, function() {
+                  return type;
+                })
+              ),
+              lookbehind: true,
+              inside: null
+              // see below
+            }
+          ],
+          keyword: {
+            pattern: /(^|[^&])\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\b/i,
+            lookbehind: true
+          },
+          boolean: {
+            pattern: /(^|[^&])\b(?:False|True)\b/i,
+            lookbehind: true
+          },
+          builtin: {
+            pattern: /(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,
+            lookbehind: true
+          },
+          function: /\b\w+(?=\s*\()/,
+          number: [
+            // Hexadecimal, octal and binary
+            /%[01]+|&[0-7]+|\$[a-f\d]+/i,
+            // Decimal
+            /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?(?:mtz|n)?/i
+          ],
+          operator: /->|=\/=|\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=|]|\b(?:and|mod|or)\b/,
+          punctuation: /\(\.|\.\)|[()\[\]:;,.{}]/
+        };
+        var classNameInside = [
+          "comment",
+          "keyword",
+          "builtin",
+          "operator",
+          "punctuation"
+        ].reduce(function(accum, key) {
+          accum[key] = pascaligo2[key];
+          return accum;
+        }, {});
+        pascaligo2["class-name"].forEach(function(p) {
+          p.inside = classNameInside;
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_pascaligo
+};

package/dist/chunk-NOBI3JZF.js

@@ -0,0 +1,49 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/clojure.js
+var require_clojure = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/clojure.js"(exports, module) {
+    module.exports = clojure;
+    clojure.displayName = "clojure";
+    clojure.aliases = [];
+    function clojure(Prism) {
+      Prism.languages.clojure = {
+        comment: {
+          pattern: /;.*/,
+          greedy: true
+        },
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: true
+        },
+        char: /\\\w+/,
+        symbol: {
+          pattern: /(^|[\s()\[\]{},])::?[\w*+!?'<>=/.-]+/,
+          lookbehind: true
+        },
+        keyword: {
+          pattern: /(\()(?:-|->|->>|\.|\.\.|\*|\/|\+|<|<=|=|==|>|>=|accessor|agent|agent-errors|aget|alength|all-ns|alter|and|append-child|apply|array-map|aset|aset-boolean|aset-byte|aset-char|aset-double|aset-float|aset-int|aset-long|aset-short|assert|assoc|await|await-for|bean|binding|bit-and|bit-not|bit-or|bit-shift-left|bit-shift-right|bit-xor|boolean|branch\?|butlast|byte|cast|char|children|class|clear-agent-errors|comment|commute|comp|comparator|complement|concat|cond|conj|cons|constantly|construct-proxy|contains\?|count|create-ns|create-struct|cycle|dec|declare|def|def-|definline|definterface|defmacro|defmethod|defmulti|defn|defn-|defonce|defproject|defprotocol|defrecord|defstruct|deftype|deref|difference|disj|dissoc|distinct|do|doall|doc|dorun|doseq|dosync|dotimes|doto|double|down|drop|drop-while|edit|end\?|ensure|eval|every\?|false\?|ffirst|file-seq|filter|find|find-doc|find-ns|find-var|first|float|flush|fn|fnseq|for|frest|gensym|get|get-proxy-class|hash-map|hash-set|identical\?|identity|if|if-let|if-not|import|in-ns|inc|index|insert-child|insert-left|insert-right|inspect-table|inspect-tree|instance\?|int|interleave|intersection|into|into-array|iterate|join|key|keys|keyword|keyword\?|last|lazy-cat|lazy-cons|left|lefts|let|line-seq|list|list\*|load|load-file|locking|long|loop|macroexpand|macroexpand-1|make-array|make-node|map|map-invert|map\?|mapcat|max|max-key|memfn|merge|merge-with|meta|min|min-key|monitor-enter|name|namespace|neg\?|new|newline|next|nil\?|node|not|not-any\?|not-every\?|not=|ns|ns-imports|ns-interns|ns-map|ns-name|ns-publics|ns-refers|ns-resolve|ns-unmap|nth|nthrest|or|parse|partial|path|peek|pop|pos\?|pr|pr-str|print|print-str|println|println-str|prn|prn-str|project|proxy|proxy-mappings|quot|quote|rand|rand-int|range|re-find|re-groups|re-matcher|re-matches|re-pattern|re-seq|read|read-line|recur|reduce|ref|ref-set|refer|rem|remove|remove-method|remove-ns|rename|rename-keys|repeat|replace|replicate|resolve|rest|resultset-seq|reverse|rfirst|right|rights|root|rrest|rseq|second|select|select-keys|send|send-off|seq|seq-zip|seq\?|set|set!|short|slurp|some|sort|sort-by|sorted-map|sorted-map-by|sorted-set|special-symbol\?|split-at|split-with|str|string\?|struct|struct-map|subs|subvec|symbol|symbol\?|sync|take|take-nth|take-while|test|throw|time|to-array|to-array-2d|tree-seq|true\?|try|union|up|update-proxy|val|vals|var|var-get|var-set|var\?|vector|vector-zip|vector\?|when|when-first|when-let|when-not|with-local-vars|with-meta|with-open|with-out-str|xml-seq|xml-zip|zero\?|zipmap|zipper)(?=[\s)]|$)/,
+          lookbehind: true
+        },
+        boolean: /\b(?:false|nil|true)\b/,
+        number: {
+          pattern: /(^|[^\w$@])(?:\d+(?:[/.]\d+)?(?:e[+-]?\d+)?|0x[a-f0-9]+|[1-9]\d?r[a-z0-9]+)[lmn]?(?![\w$@])/i,
+          lookbehind: true
+        },
+        function: {
+          pattern: /((?:^|[^'])\()[\w*+!?'<>=/.-]+(?=[\s)]|$)/,
+          lookbehind: true
+        },
+        operator: /[#@^`~]/,
+        punctuation: /[{}\[\](),]/
+      };
+    }
+  }
+});
+
+export {
+  require_clojure
+};

package/dist/chunk-NQS5H6QB.js

@@ -0,0 +1,31 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mizar.js
+var require_mizar = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/mizar.js"(exports, module) {
+    module.exports = mizar;
+    mizar.displayName = "mizar";
+    mizar.aliases = [];
+    function mizar(Prism) {
+      Prism.languages.mizar = {
+        comment: /::.+/,
+        keyword: /@proof\b|\b(?:according|aggregate|all|and|antonym|are|as|associativity|assume|asymmetry|attr|be|begin|being|by|canceled|case|cases|clusters?|coherence|commutativity|compatibility|connectedness|consider|consistency|constructors|contradiction|correctness|def|deffunc|define|definitions?|defpred|do|does|end|environ|equals|ex|exactly|existence|for|from|func|given|hence|hereby|holds|idempotence|identity|iff?|implies|involutiveness|irreflexivity|is|it|let|means|mode|non|not|notations?|now|of|or|otherwise|over|per|pred|prefix|projectivity|proof|provided|qua|reconsider|redefine|reduce|reducibility|reflexivity|registrations?|requirements|reserve|sch|schemes?|section|selector|set|sethood|st|struct|such|suppose|symmetry|synonym|take|that|the|then|theorems?|thesis|thus|to|transitivity|uniqueness|vocabular(?:ies|y)|when|where|with|wrt)\b/,
+        parameter: {
+          pattern: /\$(?:10|\d)/,
+          alias: "variable"
+        },
+        variable: /\b\w+(?=:)/,
+        number: /(?:\b|-)\d+\b/,
+        operator: /\.\.\.|->|&|\.?=/,
+        punctuation: /\(#|#\)|[,:;\[\](){}]/
+      };
+    }
+  }
+});
+
+export {
+  require_mizar
+};

package/dist/chunk-O7AAH5I3.js

@@ -0,0 +1,45 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/go.js
+var require_go = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/go.js"(exports, module) {
+    module.exports = go;
+    go.displayName = "go";
+    go.aliases = [];
+    function go(Prism) {
+      Prism.languages.go = Prism.languages.extend("clike", {
+        string: {
+          pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
+          lookbehind: true,
+          greedy: true
+        },
+        keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
+        boolean: /\b(?:_|false|iota|nil|true)\b/,
+        number: [
+          // binary and octal integers
+          /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
+          // hexadecimal integers and floats
+          /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+          // decimal integers and floats
+          /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
+        ],
+        operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
+        builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
+      });
+      Prism.languages.insertBefore("go", "string", {
+        char: {
+          pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
+          greedy: true
+        }
+      });
+      delete Prism.languages.go["class-name"];
+    }
+  }
+});
+
+export {
+  require_go
+};

package/dist/chunk-OI7FVI7R.js

@@ -0,0 +1,42 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vhdl.js
+var require_vhdl = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vhdl.js"(exports, module) {
+    module.exports = vhdl;
+    vhdl.displayName = "vhdl";
+    vhdl.aliases = [];
+    function vhdl(Prism) {
+      Prism.languages.vhdl = {
+        comment: /--.+/,
+        // support for all logic vectors
+        "vhdl-vectors": {
+          pattern: /\b[oxb]"[\da-f_]+"|"[01uxzwlh-]+"/i,
+          alias: "number"
+        },
+        // support for operator overloading included
+        "quoted-function": {
+          pattern: /"\S+?"(?=\()/,
+          alias: "function"
+        },
+        string: /"(?:[^\\"\r\n]|\\(?:\r\n|[\s\S]))*"/,
+        constant: /\b(?:library|use)\b/i,
+        // support for predefined attributes included
+        keyword: /\b(?:'active|'ascending|'base|'delayed|'driving|'driving_value|'event|'high|'image|'instance_name|'last_active|'last_event|'last_value|'left|'leftof|'length|'low|'path_name|'pos|'pred|'quiet|'range|'reverse_range|'right|'rightof|'simple_name|'stable|'succ|'transaction|'val|'value|access|after|alias|all|architecture|array|assert|attribute|begin|block|body|buffer|bus|case|component|configuration|constant|disconnect|downto|else|elsif|end|entity|exit|file|for|function|generate|generic|group|guarded|if|impure|in|inertial|inout|is|label|library|linkage|literal|loop|map|new|next|null|of|on|open|others|out|package|port|postponed|procedure|process|pure|range|record|register|reject|report|return|select|severity|shared|signal|subtype|then|to|transport|type|unaffected|units|until|use|variable|wait|when|while|with)\b/i,
+        boolean: /\b(?:false|true)\b/i,
+        function: /\w+(?=\()/,
+        // decimal, based, physical, and exponential numbers supported
+        number: /'[01uxzwlh-]'|\b(?:\d+#[\da-f_.]+#|\d[\d_.]*)(?:e[-+]?\d+)?/i,
+        operator: /[<>]=?|:=|[-+*/&=]|\b(?:abs|and|mod|nand|nor|not|or|rem|rol|ror|sla|sll|sra|srl|xnor|xor)\b/i,
+        punctuation: /[{}[\];(),.:]/
+      };
+    }
+  }
+});
+
+export {
+  require_vhdl
+};

package/dist/chunk-OIU6EBEL.js

@@ -0,0 +1,59 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/fortran.js
+var require_fortran = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/fortran.js"(exports, module) {
+    module.exports = fortran;
+    fortran.displayName = "fortran";
+    fortran.aliases = [];
+    function fortran(Prism) {
+      Prism.languages.fortran = {
+        "quoted-number": {
+          pattern: /[BOZ](['"])[A-F0-9]+\1/i,
+          alias: "number"
+        },
+        string: {
+          pattern: /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
+          inside: {
+            comment: {
+              pattern: /(&(?:\r\n?|\n)\s*)!.*/,
+              lookbehind: true
+            }
+          }
+        },
+        comment: {
+          pattern: /!.*/,
+          greedy: true
+        },
+        boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
+        number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
+        keyword: [
+          // Types
+          /\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i,
+          // END statements
+          /\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i,
+          // Statements
+          /\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i,
+          // Others
+          /\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
+        ],
+        operator: [
+          /\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
+          {
+            // Use lookbehind to prevent confusion with (/ /)
+            pattern: /(^|(?!\().)\/(?!\))/,
+            lookbehind: true
+          }
+        ],
+        punctuation: /\(\/|\/\)|[(),;:&]/
+      };
+    }
+  }
+});
+
+export {
+  require_fortran
+};