@distri/react 0.2.5 → 0.2.8

package/dist/chunk-QQOZXGR3.js

@@ -0,0 +1,47 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/visual-basic.js
+var require_visual_basic = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/visual-basic.js"(exports, module) {
+    module.exports = visualBasic;
+    visualBasic.displayName = "visualBasic";
+    visualBasic.aliases = [];
+    function visualBasic(Prism) {
+      Prism.languages["visual-basic"] = {
+        comment: {
+          pattern: /(?:['‘’]|REM\b)(?:[^\r\n_]|_(?:\r\n?|\n)?)*/i,
+          inside: {
+            keyword: /^REM/i
+          }
+        },
+        directive: {
+          pattern: /#(?:Const|Else|ElseIf|End|ExternalChecksum|ExternalSource|If|Region)(?:\b_[ \t]*(?:\r\n?|\n)|.)+/i,
+          alias: "property",
+          greedy: true
+        },
+        string: {
+          pattern: /\$?["“”](?:["“”]{2}|[^"“”])*["“”]C?/i,
+          greedy: true
+        },
+        date: {
+          pattern: /#[ \t]*(?:\d+([/-])\d+\1\d+(?:[ \t]+(?:\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?))?|\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?)[ \t]*#/i,
+          alias: "number"
+        },
+        number: /(?:(?:\b\d+(?:\.\d+)?|\.\d+)(?:E[+-]?\d+)?|&[HO][\dA-F]+)(?:[FRD]|U?[ILS])?/i,
+        boolean: /\b(?:False|Nothing|True)\b/i,
+        keyword: /\b(?:AddHandler|AddressOf|Alias|And(?:Also)?|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|C(?:Bool|Byte|Char|Date|Dbl|Dec|Int|Lng|Obj|SByte|Short|Sng|Str|Type|UInt|ULng|UShort)|Char|Class|Const|Continue|Currency|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else(?:If)?|End(?:If)?|Enum|Erase|Error|Event|Exit|Finally|For|Friend|Function|Get(?:Type|XMLNamespace)?|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|Must(?:Inherit|Override)|My(?:Base|Class)|Namespace|Narrowing|New|Next|Not(?:Inheritable|Overridable)?|Object|Of|On|Operator|Option(?:al)?|Or(?:Else)?|Out|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|Try|TryCast|Type|TypeOf|U(?:Integer|Long|Short)|Until|Using|Variant|Wend|When|While|Widening|With(?:Events)?|WriteOnly|Xor)\b/i,
+        operator: /[+\-*/\\^<=>&#@$%!]|\b_(?=[ \t]*[\r\n])/,
+        punctuation: /[{}().,:?]/
+      };
+      Prism.languages.vb = Prism.languages["visual-basic"];
+      Prism.languages.vba = Prism.languages["visual-basic"];
+    }
+  }
+});
+
+export {
+  require_visual_basic
+};

package/dist/chunk-QUWJFCWK.js

@@ -0,0 +1,38 @@
+"use client";
+import {
+  require_php
+} from "./chunk-VXO6WZ3Z.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/php-extras.js
+var require_php_extras = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/php-extras.js"(exports, module) {
+    var refractorPhp = require_php();
+    module.exports = phpExtras;
+    phpExtras.displayName = "phpExtras";
+    phpExtras.aliases = [];
+    function phpExtras(Prism) {
+      Prism.register(refractorPhp);
+      Prism.languages.insertBefore("php", "variable", {
+        this: {
+          pattern: /\$this\b/,
+          alias: "keyword"
+        },
+        global: /\$(?:GLOBALS|HTTP_RAW_POST_DATA|_(?:COOKIE|ENV|FILES|GET|POST|REQUEST|SERVER|SESSION)|argc|argv|http_response_header|php_errormsg)\b/,
+        scope: {
+          pattern: /\b[\w\\]+::/,
+          inside: {
+            keyword: /\b(?:parent|self|static)\b/,
+            punctuation: /::|\\/
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_php_extras
+};

package/dist/chunk-R4PER7NZ.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dns-zone-file.js
+var require_dns_zone_file = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dns-zone-file.js"(exports, module) {
+    module.exports = dnsZoneFile;
+    dnsZoneFile.displayName = "dnsZoneFile";
+    dnsZoneFile.aliases = [];
+    function dnsZoneFile(Prism) {
+      Prism.languages["dns-zone-file"] = {
+        comment: /;.*/,
+        string: {
+          pattern: /"(?:\\.|[^"\\\r\n])*"/,
+          greedy: true
+        },
+        variable: [
+          {
+            pattern: /(^\$ORIGIN[ \t]+)\S+/m,
+            lookbehind: true
+          },
+          {
+            pattern: /(^|\s)@(?=\s|$)/,
+            lookbehind: true
+          }
+        ],
+        keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
+        class: {
+          // https://tools.ietf.org/html/rfc1035#page-13
+          pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        type: {
+          // https://en.wikipedia.org/wiki/List_of_DNS_record_types
+          pattern: /(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        punctuation: /[()]/
+      };
+      Prism.languages["dns-zone"] = Prism.languages["dns-zone-file"];
+    }
+  }
+});
+
+export {
+  require_dns_zone_file
+};

package/dist/chunk-R4WHSRPM.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/iecst.js
+var require_iecst = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/iecst.js"(exports, module) {
+    module.exports = iecst;
+    iecst.displayName = "iecst";
+    iecst.aliases = [];
+    function iecst(Prism) {
+      Prism.languages.iecst = {
+        comment: [
+          {
+            pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        },
+        keyword: [
+          /\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i,
+          /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/
+        ],
+        "class-name": /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+        address: {
+          pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+          alias: "symbol"
+        },
+        number: /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+        boolean: /\b(?:FALSE|NULL|TRUE)\b/,
+        operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        punctuation: /[()[\].,;]/
+      };
+    }
+  }
+});
+
+export {
+  require_iecst
+};

package/dist/chunk-R7LE6OT4.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-RNTTNM5P.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-RQJWBEFF.js

@@ -0,0 +1,62 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/erlang.js
+var require_erlang = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/erlang.js"(exports, module) {
+    module.exports = erlang;
+    erlang.displayName = "erlang";
+    erlang.aliases = [];
+    function erlang(Prism) {
+      Prism.languages.erlang = {
+        comment: /%.+/,
+        string: {
+          pattern: /"(?:\\.|[^\\"\r\n])*"/,
+          greedy: true
+        },
+        "quoted-function": {
+          pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
+          alias: "function"
+        },
+        "quoted-atom": {
+          pattern: /'(?:\\.|[^\\'\r\n])+'/,
+          alias: "atom"
+        },
+        boolean: /\b(?:false|true)\b/,
+        keyword: /\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,
+        number: [
+          /\$\\?./,
+          /\b\d+#[a-z0-9]+/i,
+          /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
+        ],
+        function: /\b[a-z][\w@]*(?=\()/,
+        variable: {
+          // Look-behind is used to prevent wrong highlighting of atoms containing "@"
+          pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
+          lookbehind: true
+        },
+        operator: [
+          /[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
+          {
+            // We don't want to match <<
+            pattern: /(^|[^<])<(?!<)/,
+            lookbehind: true
+          },
+          {
+            // We don't want to match >>
+            pattern: /(^|[^>])>(?!>)/,
+            lookbehind: true
+          }
+        ],
+        atom: /\b[a-z][\w@]*/,
+        punctuation: /[()[\]{}:;,.#|]|<<|>>/
+      };
+    }
+  }
+});
+
+export {
+  require_erlang
+};

package/dist/chunk-RSMTA6GK.js

@@ -0,0 +1,95 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/c.js
+var require_c = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/c.js"(exports, module) {
+    module.exports = c;
+    c.displayName = "c";
+    c.aliases = [];
+    function c(Prism) {
+      Prism.languages.c = Prism.languages.extend("clike", {
+        comment: {
+          pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+          greedy: true
+        },
+        string: {
+          // https://en.cppreference.com/w/c/language/string_literal
+          pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+          lookbehind: true
+        },
+        keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+        operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
+      });
+      Prism.languages.insertBefore("c", "string", {
+        char: {
+          // https://en.cppreference.com/w/c/language/character_constant
+          pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+          greedy: true
+        }
+      });
+      Prism.languages.insertBefore("c", "string", {
+        macro: {
+          // allow for multiline macro definitions
+          // spaces after the # character compile fine with gcc
+          pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
+          lookbehind: true,
+          greedy: true,
+          alias: "property",
+          inside: {
+            string: [
+              {
+                // highlight the path of the include statement as a string
+                pattern: /^(#\s*include\s*)<[^>]+>/,
+                lookbehind: true
+              },
+              Prism.languages.c["string"]
+            ],
+            char: Prism.languages.c["char"],
+            comment: Prism.languages.c["comment"],
+            "macro-name": [
+              {
+                pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+                lookbehind: true
+              },
+              {
+                pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+                lookbehind: true,
+                alias: "function"
+              }
+            ],
+            // highlight macro directives as keywords
+            directive: {
+              pattern: /^(#\s*)[a-z]+/,
+              lookbehind: true,
+              alias: "keyword"
+            },
+            "directive-hash": /^#/,
+            punctuation: /##|\\(?=[\r\n])/,
+            expression: {
+              pattern: /\S[\s\S]*/,
+              inside: Prism.languages.c
+            }
+          }
+        }
+      });
+      Prism.languages.insertBefore("c", "function", {
+        // highlight predefined macros as constants
+        constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
+      });
+      delete Prism.languages.c["boolean"];
+    }
+  }
+});
+
+export {
+  require_c
+};

package/dist/chunk-RWBIPKOM.js

@@ -0,0 +1,39 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ebnf.js
+var require_ebnf = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ebnf.js"(exports, module) {
+    module.exports = ebnf;
+    ebnf.displayName = "ebnf";
+    ebnf.aliases = [];
+    function ebnf(Prism) {
+      Prism.languages.ebnf = {
+        comment: /\(\*[\s\S]*?\*\)/,
+        string: {
+          pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+          greedy: true
+        },
+        special: {
+          pattern: /\?[^?\r\n]*\?/,
+          greedy: true,
+          alias: "class-name"
+        },
+        definition: {
+          pattern: /^([\t ]*)[a-z]\w*(?:[ \t]+[a-z]\w*)*(?=\s*=)/im,
+          lookbehind: true,
+          alias: ["rule", "keyword"]
+        },
+        rule: /\b[a-z]\w*(?:[ \t]+[a-z]\w*)*\b/i,
+        punctuation: /\([:/]|[:/]\)|[.,;()[\]{}]/,
+        operator: /[-=|*/!]/
+      };
+    }
+  }
+});
+
+export {
+  require_ebnf
+};

package/dist/chunk-RYLEEMHX.js

@@ -0,0 +1,45 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/verilog.js
+var require_verilog = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/verilog.js"(exports, module) {
+    module.exports = verilog;
+    verilog.displayName = "verilog";
+    verilog.aliases = [];
+    function verilog(Prism) {
+      Prism.languages.verilog = {
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: true
+        },
+        string: {
+          pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+          greedy: true
+        },
+        "kernel-function": {
+          // support for any kernel function (ex: $display())
+          pattern: /\B\$\w+\b/,
+          alias: "property"
+        },
+        // support for user defined constants (ex: `define)
+        constant: /\B`\w+\b/,
+        function: /\b\w+(?=\()/,
+        // support for verilog and system verilog keywords
+        keyword: /\b(?:alias|and|assert|assign|assume|automatic|before|begin|bind|bins|binsof|bit|break|buf|bufif0|bufif1|byte|case|casex|casez|cell|chandle|class|clocking|cmos|config|const|constraint|context|continue|cover|covergroup|coverpoint|cross|deassign|default|defparam|design|disable|dist|do|edge|else|end|endcase|endclass|endclocking|endconfig|endfunction|endgenerate|endgroup|endinterface|endmodule|endpackage|endprimitive|endprogram|endproperty|endsequence|endspecify|endtable|endtask|enum|event|expect|export|extends|extern|final|first_match|for|force|foreach|forever|fork|forkjoin|function|generate|genvar|highz0|highz1|if|iff|ifnone|ignore_bins|illegal_bins|import|incdir|include|initial|inout|input|inside|instance|int|integer|interface|intersect|join|join_any|join_none|large|liblist|library|local|localparam|logic|longint|macromodule|matches|medium|modport|module|nand|negedge|new|nmos|nor|noshowcancelled|not|notif0|notif1|null|or|output|package|packed|parameter|pmos|posedge|primitive|priority|program|property|protected|pull0|pull1|pulldown|pullup|pulsestyle_ondetect|pulsestyle_onevent|pure|rand|randc|randcase|randsequence|rcmos|real|realtime|ref|reg|release|repeat|return|rnmos|rpmos|rtran|rtranif0|rtranif1|scalared|sequence|shortint|shortreal|showcancelled|signed|small|solve|specify|specparam|static|string|strong0|strong1|struct|super|supply0|supply1|table|tagged|task|this|throughout|time|timeprecision|timeunit|tran|tranif0|tranif1|tri|tri0|tri1|triand|trior|trireg|type|typedef|union|unique|unsigned|use|uwire|var|vectored|virtual|void|wait|wait_order|wand|weak0|weak1|while|wildcard|wire|with|within|wor|xnor|xor)\b/,
+        // bold highlighting for all verilog and system verilog logic blocks
+        important: /\b(?:always|always_comb|always_ff|always_latch)\b(?: *@)?/,
+        // support for time ticks, vectors, and real numbers
+        number: /\B##?\d+|(?:\b\d+)?'[odbh] ?[\da-fzx_?]+|\b(?:\d*[._])?\d+(?:e[-+]?\d+)?/i,
+        operator: /[-+{}^~%*\/?=!<>&|]+/,
+        punctuation: /[[\];(),.:]/
+      };
+    }
+  }
+});
+
+export {
+  require_verilog
+};

package/dist/chunk-S22XTUNB.js

@@ -0,0 +1,72 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-DYCT6UGG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tt2.js
+var require_tt2 = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/tt2.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = tt2;
+    tt2.displayName = "tt2";
+    tt2.aliases = [];
+    function tt2(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        Prism2.languages.tt2 = Prism2.languages.extend("clike", {
+          comment: /#.*|\[%#[\s\S]*?%\]/,
+          keyword: /\b(?:BLOCK|CALL|CASE|CATCH|CLEAR|DEBUG|DEFAULT|ELSE|ELSIF|END|FILTER|FINAL|FOREACH|GET|IF|IN|INCLUDE|INSERT|LAST|MACRO|META|NEXT|PERL|PROCESS|RAWPERL|RETURN|SET|STOP|SWITCH|TAGS|THROW|TRY|UNLESS|USE|WHILE|WRAPPER)\b/,
+          punctuation: /[[\]{},()]/
+        });
+        Prism2.languages.insertBefore("tt2", "number", {
+          operator: /=[>=]?|!=?|<=?|>=?|&&|\|\|?|\b(?:and|not|or)\b/,
+          variable: {
+            pattern: /\b[a-z]\w*(?:\s*\.\s*(?:\d+|\$?[a-z]\w*))*\b/i
+          }
+        });
+        Prism2.languages.insertBefore("tt2", "keyword", {
+          delimiter: {
+            pattern: /^(?:\[%|%%)-?|-?%\]$/,
+            alias: "punctuation"
+          }
+        });
+        Prism2.languages.insertBefore("tt2", "string", {
+          "single-quoted-string": {
+            pattern: /'[^\\']*(?:\\[\s\S][^\\']*)*'/,
+            greedy: true,
+            alias: "string"
+          },
+          "double-quoted-string": {
+            pattern: /"[^\\"]*(?:\\[\s\S][^\\"]*)*"/,
+            greedy: true,
+            alias: "string",
+            inside: {
+              variable: {
+                pattern: /\$(?:[a-z]\w*(?:\.(?:\d+|\$?[a-z]\w*))*)/i
+              }
+            }
+          }
+        });
+        delete Prism2.languages.tt2.string;
+        Prism2.hooks.add("before-tokenize", function(env) {
+          var tt2Pattern = /\[%[\s\S]+?%\]/g;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "tt2",
+            tt2Pattern
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "tt2");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_tt2
+};