@distri/react 0.2.7 → 0.2.8

package/dist/chunk-P7WAXOIZ.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-PAB77QMV.js

@@ -0,0 +1,64 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gn.js
+var require_gn = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gn.js"(exports, module) {
+    module.exports = gn;
+    gn.displayName = "gn";
+    gn.aliases = ["gni"];
+    function gn(Prism) {
+      Prism.languages.gn = {
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        "string-literal": {
+          pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/,
+              lookbehind: true,
+              inside: {
+                number: /^\$0x[\s\S]{2}$/,
+                variable: /^\$\w+$/,
+                "interpolation-punctuation": {
+                  pattern: /^\$\{|\}$/,
+                  alias: "punctuation"
+                },
+                expression: {
+                  pattern: /[\s\S]+/,
+                  inside: null
+                  // see below
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        },
+        keyword: /\b(?:else|if)\b/,
+        boolean: /\b(?:false|true)\b/,
+        "builtin-function": {
+          // a few functions get special highlighting to improve readability
+          pattern: /\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i,
+          alias: "keyword"
+        },
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        constant: /\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/,
+        number: /-?\b\d+\b/,
+        operator: /[-+!=<>]=?|&&|\|\|/,
+        punctuation: /[(){}[\],.]/
+      };
+      Prism.languages.gn["string-literal"].inside["interpolation"].inside["expression"].inside = Prism.languages.gn;
+      Prism.languages.gni = Prism.languages.gn;
+    }
+  }
+});
+
+export {
+  require_gn
+};

package/dist/chunk-PC37JIIX.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-PO4QV4WT.js

@@ -0,0 +1,68 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cobol.js
+var require_cobol = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cobol.js"(exports, module) {
+    module.exports = cobol;
+    cobol.displayName = "cobol";
+    cobol.aliases = [];
+    function cobol(Prism) {
+      Prism.languages.cobol = {
+        comment: {
+          pattern: /\*>.*|(^[ \t]*)\*.*/m,
+          lookbehind: true,
+          greedy: true
+        },
+        string: {
+          pattern: /[xzgn]?(?:"(?:[^\r\n"]|"")*"(?!")|'(?:[^\r\n']|'')*'(?!'))/i,
+          greedy: true
+        },
+        level: {
+          pattern: /(^[ \t]*)\d+\b/m,
+          lookbehind: true,
+          greedy: true,
+          alias: "number"
+        },
+        "class-name": {
+          // https://github.com/antlr/grammars-v4/blob/42edd5b687d183b5fa679e858a82297bd27141e7/cobol85/Cobol85.g4#L1015
+          pattern: /(\bpic(?:ture)?\s+)(?:(?:[-\w$/,:*+<>]|\.(?!\s|$))(?:\(\d+\))?)+/i,
+          lookbehind: true,
+          inside: {
+            number: {
+              pattern: /(\()\d+/,
+              lookbehind: true
+            },
+            punctuation: /[()]/
+          }
+        },
+        keyword: {
+          pattern: /(^|[^\w-])(?:ABORT|ACCEPT|ACCESS|ADD|ADDRESS|ADVANCING|AFTER|ALIGNED|ALL|ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE|ANY|ARE|AREA|AREAS|AS|ASCENDING|ASCII|ASSIGN|ASSOCIATED-DATA|ASSOCIATED-DATA-LENGTH|AT|ATTRIBUTE|AUTHOR|AUTO|AUTO-SKIP|BACKGROUND-COLOR|BACKGROUND-COLOUR|BASIS|BEEP|BEFORE|BEGINNING|BELL|BINARY|BIT|BLANK|BLINK|BLOCK|BOTTOM|BOUNDS|BY|BYFUNCTION|BYTITLE|CALL|CANCEL|CAPABLE|CCSVERSION|CD|CF|CH|CHAINING|CHANGED|CHANNEL|CHARACTER|CHARACTERS|CLASS|CLASS-ID|CLOCK-UNITS|CLOSE|CLOSE-DISPOSITION|COBOL|CODE|CODE-SET|COL|COLLATING|COLUMN|COM-REG|COMMA|COMMITMENT|COMMON|COMMUNICATION|COMP|COMP-1|COMP-2|COMP-3|COMP-4|COMP-5|COMPUTATIONAL|COMPUTATIONAL-1|COMPUTATIONAL-2|COMPUTATIONAL-3|COMPUTATIONAL-4|COMPUTATIONAL-5|COMPUTE|CONFIGURATION|CONTAINS|CONTENT|CONTINUE|CONTROL|CONTROL-POINT|CONTROLS|CONVENTION|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRUNCH|CURRENCY|CURSOR|DATA|DATA-BASE|DATE|DATE-COMPILED|DATE-WRITTEN|DAY|DAY-OF-WEEK|DBCS|DE|DEBUG-CONTENTS|DEBUG-ITEM|DEBUG-LINE|DEBUG-NAME|DEBUG-SUB-1|DEBUG-SUB-2|DEBUG-SUB-3|DEBUGGING|DECIMAL-POINT|DECLARATIVES|DEFAULT|DEFAULT-DISPLAY|DEFINITION|DELETE|DELIMITED|DELIMITER|DEPENDING|DESCENDING|DESTINATION|DETAIL|DFHRESP|DFHVALUE|DISABLE|DISK|DISPLAY|DISPLAY-1|DIVIDE|DIVISION|DONTCARE|DOUBLE|DOWN|DUPLICATES|DYNAMIC|EBCDIC|EGCS|EGI|ELSE|EMI|EMPTY-CHECK|ENABLE|END|END-ACCEPT|END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|END-PERFORM|END-READ|END-RECEIVE|END-RETURN|END-REWRITE|END-SEARCH|END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|ENDING|ENTER|ENTRY|ENTRY-PROCEDURE|ENVIRONMENT|EOL|EOP|EOS|ERASE|ERROR|ESCAPE|ESI|EVALUATE|EVENT|EVERY|EXCEPTION|EXCLUSIVE|EXHIBIT|EXIT|EXPORT|EXTEND|EXTENDED|EXTERNAL|FD|FILE|FILE-CONTROL|FILLER|FINAL|FIRST|FOOTING|FOR|FOREGROUND-COLOR|FOREGROUND-COLOUR|FROM|FULL|FUNCTION|FUNCTION-POINTER|FUNCTIONNAME|GENERATE|GIVING|GLOBAL|GO|GOBACK|GRID|GROUP|HEADING|HIGH-VALUE|HIGH-VALUES|HIGHLIGHT|I-O|I-O-CONTROL|ID|IDENTIFICATION|IF|IMPLICIT|IMPORT|IN|INDEX|INDEXED|INDICATE|INITIAL|INITIALIZE|INITIATE|INPUT|INPUT-OUTPUT|INSPECT|INSTALLATION|INTEGER|INTO|INVALID|INVOKE|IS|JUST|JUSTIFIED|KANJI|KEPT|KEY|KEYBOARD|LABEL|LANGUAGE|LAST|LB|LD|LEADING|LEFT|LEFTLINE|LENGTH|LENGTH-CHECK|LIBACCESS|LIBPARAMETER|LIBRARY|LIMIT|LIMITS|LINAGE|LINAGE-COUNTER|LINE|LINE-COUNTER|LINES|LINKAGE|LIST|LOCAL|LOCAL-STORAGE|LOCK|LONG-DATE|LONG-TIME|LOW-VALUE|LOW-VALUES|LOWER|LOWLIGHT|MEMORY|MERGE|MESSAGE|MMDDYYYY|MODE|MODULES|MORE-LABELS|MOVE|MULTIPLE|MULTIPLY|NAMED|NATIONAL|NATIONAL-EDITED|NATIVE|NEGATIVE|NETWORK|NEXT|NO|NO-ECHO|NULL|NULLS|NUMBER|NUMERIC|NUMERIC-DATE|NUMERIC-EDITED|NUMERIC-TIME|OBJECT-COMPUTER|OCCURS|ODT|OF|OFF|OMITTED|ON|OPEN|OPTIONAL|ORDER|ORDERLY|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|OVERLINE|OWN|PACKED-DECIMAL|PADDING|PAGE|PAGE-COUNTER|PASSWORD|PERFORM|PF|PH|PIC|PICTURE|PLUS|POINTER|PORT|POSITION|POSITIVE|PRINTER|PRINTING|PRIVATE|PROCEDURE|PROCEDURE-POINTER|PROCEDURES|PROCEED|PROCESS|PROGRAM|PROGRAM-ID|PROGRAM-LIBRARY|PROMPT|PURGE|QUEUE|QUOTE|QUOTES|RANDOM|RD|READ|READER|REAL|RECEIVE|RECEIVED|RECORD|RECORDING|RECORDS|RECURSIVE|REDEFINES|REEL|REF|REFERENCE|REFERENCES|RELATIVE|RELEASE|REMAINDER|REMARKS|REMOTE|REMOVAL|REMOVE|RENAMES|REPLACE|REPLACING|REPORT|REPORTING|REPORTS|REQUIRED|RERUN|RESERVE|RESET|RETURN|RETURN-CODE|RETURNING|REVERSE-VIDEO|REVERSED|REWIND|REWRITE|RF|RH|RIGHT|ROUNDED|RUN|SAME|SAVE|SCREEN|SD|SEARCH|SECTION|SECURE|SECURITY|SEGMENT|SEGMENT-LIMIT|SELECT|SEND|SENTENCE|SEPARATE|SEQUENCE|SEQUENTIAL|SET|SHARED|SHAREDBYALL|SHAREDBYRUNUNIT|SHARING|SHIFT-IN|SHIFT-OUT|SHORT-DATE|SIGN|SIZE|SORT|SORT-CONTROL|SORT-CORE-SIZE|SORT-FILE-SIZE|SORT-MERGE|SORT-MESSAGE|SORT-MODE-SIZE|SORT-RETURN|SOURCE|SOURCE-COMPUTER|SPACE|SPACES|SPECIAL-NAMES|STANDARD|STANDARD-1|STANDARD-2|START|STATUS|STOP|STRING|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUBTRACT|SUM|SUPPRESS|SYMBOL|SYMBOLIC|SYNC|SYNCHRONIZED|TABLE|TALLY|TALLYING|TAPE|TASK|TERMINAL|TERMINATE|TEST|TEXT|THEN|THREAD|THREAD-LOCAL|THROUGH|THRU|TIME|TIMER|TIMES|TITLE|TO|TODAYS-DATE|TODAYS-NAME|TOP|TRAILING|TRUNCATED|TYPE|TYPEDEF|UNDERLINE|UNIT|UNSTRING|UNTIL|UP|UPON|USAGE|USE|USING|VALUE|VALUES|VARYING|VIRTUAL|WAIT|WHEN|WHEN-COMPILED|WITH|WORDS|WORKING-STORAGE|WRITE|YEAR|YYYYDDD|YYYYMMDD|ZERO-FILL|ZEROES|ZEROS)(?![\w-])/i,
+          lookbehind: true
+        },
+        boolean: {
+          pattern: /(^|[^\w-])(?:false|true)(?![\w-])/i,
+          lookbehind: true
+        },
+        number: {
+          pattern: /(^|[^\w-])(?:[+-]?(?:(?:\d+(?:[.,]\d+)?|[.,]\d+)(?:e[+-]?\d+)?|zero))(?![\w-])/i,
+          lookbehind: true
+        },
+        operator: [
+          /<>|[<>]=?|[=+*/&]/,
+          {
+            pattern: /(^|[^\w-])(?:-|and|equal|greater|less|not|or|than)(?![\w-])/i,
+            lookbehind: true
+          }
+        ],
+        punctuation: /[.:,()]/
+      };
+    }
+  }
+});
+
+export {
+  require_cobol
+};

package/dist/chunk-Q7YUTUXA.js

@@ -0,0 +1,96 @@
+"use client";
+import {
+  require_scheme
+} from "./chunk-TYBQXIHB.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lilypond.js
+var require_lilypond = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lilypond.js"(exports, module) {
+    var refractorScheme = require_scheme();
+    module.exports = lilypond;
+    lilypond.displayName = "lilypond";
+    lilypond.aliases = [];
+    function lilypond(Prism) {
+      Prism.register(refractorScheme);
+      (function(Prism2) {
+        var schemeExpression = /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source;
+        var recursivenessLog2 = 5;
+        for (var i = 0; i < recursivenessLog2; i++) {
+          schemeExpression = schemeExpression.replace(/<expr>/g, function() {
+            return schemeExpression;
+          });
+        }
+        schemeExpression = schemeExpression.replace(/<expr>/g, /[^\s\S]/.source);
+        var lilypond2 = Prism2.languages.lilypond = {
+          comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/,
+          "embedded-scheme": {
+            pattern: RegExp(
+              /(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(
+                /<expr>/g,
+                function() {
+                  return schemeExpression;
+                }
+              ),
+              "m"
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              scheme: {
+                pattern: /^(#)[\s\S]+$/,
+                lookbehind: true,
+                alias: "language-scheme",
+                inside: {
+                  "embedded-lilypond": {
+                    pattern: /#\{[\s\S]*?#\}/,
+                    greedy: true,
+                    inside: {
+                      punctuation: /^#\{|#\}$/,
+                      lilypond: {
+                        pattern: /[\s\S]+/,
+                        alias: "language-lilypond",
+                        inside: null
+                        // see below
+                      }
+                    }
+                  },
+                  rest: Prism2.languages.scheme
+                }
+              },
+              punctuation: /#/
+            }
+          },
+          string: {
+            pattern: /"(?:[^"\\]|\\.)*"/,
+            greedy: true
+          },
+          "class-name": {
+            pattern: /(\\new\s+)[\w-]+/,
+            lookbehind: true
+          },
+          keyword: {
+            pattern: /\\[a-z][-\w]*/i,
+            inside: {
+              punctuation: /^\\/
+            }
+          },
+          operator: /[=|]|<<|>>/,
+          punctuation: {
+            pattern: /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/,
+            lookbehind: true
+          },
+          number: /\b\d+(?:\/\d+)?\b/
+        };
+        lilypond2["embedded-scheme"].inside["scheme"].inside["embedded-lilypond"].inside["lilypond"].inside = lilypond2;
+        Prism2.languages.ly = lilypond2;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_lilypond
+};

package/dist/chunk-QCTJEID3.js

@@ -0,0 +1,60 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/asmatmel.js
+var require_asmatmel = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/asmatmel.js"(exports, module) {
+    module.exports = asmatmel;
+    asmatmel.displayName = "asmatmel";
+    asmatmel.aliases = [];
+    function asmatmel(Prism) {
+      Prism.languages.asmatmel = {
+        comment: {
+          pattern: /;.*/,
+          greedy: true
+        },
+        string: {
+          pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        },
+        constant: /\b(?:PORT[A-Z]|DDR[A-Z]|(?:DD|P)[A-Z](?:\d|[0-2]\d|3[01]))\b/,
+        directive: {
+          pattern: /\.\w+(?= )/,
+          alias: "property"
+        },
+        "r-register": {
+          pattern: /\br(?:\d|[12]\d|3[01])\b/,
+          alias: "variable"
+        },
+        "op-code": {
+          pattern: /\b(?:ADC|ADD|ADIW|AND|ANDI|ASR|BCLR|BLD|BRBC|BRBS|BRCC|BRCS|BREAK|BREQ|BRGE|BRHC|BRHS|BRID|BRIE|BRLO|BRLT|BRMI|BRNE|BRPL|BRSH|BRTC|BRTS|BRVC|BRVS|BSET|BST|CALL|CBI|CBR|CLC|CLH|CLI|CLN|CLR|CLS|CLT|CLV|CLZ|COM|CP|CPC|CPI|CPSE|DEC|DES|EICALL|EIJMP|ELPM|EOR|FMUL|FMULS|FMULSU|ICALL|IJMP|IN|INC|JMP|LAC|LAS|LAT|LD|LD[A-Za-z0-9]|LPM|LSL|LSR|MOV|MOVW|MUL|MULS|MULSU|NEG|NOP|OR|ORI|OUT|POP|PUSH|RCALL|RET|RETI|RJMP|ROL|ROR|SBC|SBCI|SBI|SBIC|SBIS|SBIW|SBR|SBRC|SBRS|SEC|SEH|SEI|SEN|SER|SES|SET|SEV|SEZ|SLEEP|SPM|ST|ST[A-Z0-9]|SUB|SUBI|SWAP|TST|WDR|XCH|adc|add|adiw|and|andi|asr|bclr|bld|brbc|brbs|brcc|brcs|break|breq|brge|brhc|brhs|brid|brie|brlo|brlt|brmi|brne|brpl|brsh|brtc|brts|brvc|brvs|bset|bst|call|cbi|cbr|clc|clh|cli|cln|clr|cls|clt|clv|clz|com|cp|cpc|cpi|cpse|dec|des|eicall|eijmp|elpm|eor|fmul|fmuls|fmulsu|icall|ijmp|in|inc|jmp|lac|las|lat|ld|ld[a-z0-9]|lpm|lsl|lsr|mov|movw|mul|muls|mulsu|neg|nop|or|ori|out|pop|push|rcall|ret|reti|rjmp|rol|ror|sbc|sbci|sbi|sbic|sbis|sbiw|sbr|sbrc|sbrs|sec|seh|sei|sen|ser|ses|set|sev|sez|sleep|spm|st|st[a-zA-Z0-9]|sub|subi|swap|tst|wdr|xch)\b/,
+          alias: "keyword"
+        },
+        "hex-number": {
+          pattern: /#?\$[\da-f]{2,4}\b/i,
+          alias: "number"
+        },
+        "binary-number": {
+          pattern: /#?%[01]+\b/,
+          alias: "number"
+        },
+        "decimal-number": {
+          pattern: /#?\b\d+\b/,
+          alias: "number"
+        },
+        register: {
+          pattern: /\b[acznvshtixy]\b/i,
+          alias: "variable"
+        },
+        operator: />>=?|<<=?|&&?|\|\|?|[-+*/%&|^!=<>?]=?/,
+        punctuation: /[(),:]/
+      };
+    }
+  }
+});
+
+export {
+  require_asmatmel
+};

package/dist/chunk-QINIWGYX.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apl.js
+var require_apl = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apl.js"(exports, module) {
+    module.exports = apl;
+    apl.displayName = "apl";
+    apl.aliases = [];
+    function apl(Prism) {
+      Prism.languages.apl = {
+        comment: /(?:⍝|#[! ]).*$/m,
+        string: {
+          pattern: /'(?:[^'\r\n]|'')*'/,
+          greedy: true
+        },
+        number: /¯?(?:\d*\.?\b\d+(?:e[+¯]?\d+)?|¯|∞)(?:j¯?(?:(?:\d+(?:\.\d+)?|\.\d+)(?:e[+¯]?\d+)?|¯|∞))?/i,
+        statement: /:[A-Z][a-z][A-Za-z]*\b/,
+        "system-function": {
+          pattern: /⎕[A-Z]+/i,
+          alias: "function"
+        },
+        constant: /[⍬⌾#⎕⍞]/,
+        function: /[-+×÷⌈⌊∣|⍳⍸?*⍟○!⌹<≤=>≥≠≡≢∊⍷∪∩~∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⊆⊇⌷⍋⍒⊤⊥⍕⍎⊣⊢⍁⍂≈⍯↗¤→]/,
+        "monadic-operator": {
+          pattern: /[\\\/⌿⍀¨⍨⌶&∥]/,
+          alias: "operator"
+        },
+        "dyadic-operator": {
+          pattern: /[.⍣⍠⍤∘⌸@⌺⍥]/,
+          alias: "operator"
+        },
+        assignment: {
+          pattern: /←/,
+          alias: "keyword"
+        },
+        punctuation: /[\[;\]()◇⋄]/,
+        dfn: {
+          pattern: /[{}⍺⍵⍶⍹∇⍫:]/,
+          alias: "builtin"
+        }
+      };
+    }
+  }
+});
+
+export {
+  require_apl
+};

package/dist/chunk-QL55MSIZ.js

@@ -0,0 +1,49 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xml-doc.js
+var require_xml_doc = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xml-doc.js"(exports, module) {
+    module.exports = xmlDoc;
+    xmlDoc.displayName = "xmlDoc";
+    xmlDoc.aliases = [];
+    function xmlDoc(Prism) {
+      ;
+      (function(Prism2) {
+        function insertDocComment(lang, docComment) {
+          if (Prism2.languages[lang]) {
+            Prism2.languages.insertBefore(lang, "comment", {
+              "doc-comment": docComment
+            });
+          }
+        }
+        var tag = Prism2.languages.markup.tag;
+        var slashDocComment = {
+          pattern: /\/\/\/.*/,
+          greedy: true,
+          alias: "comment",
+          inside: {
+            tag
+          }
+        };
+        var tickDocComment = {
+          pattern: /'''.*/,
+          greedy: true,
+          alias: "comment",
+          inside: {
+            tag
+          }
+        };
+        insertDocComment("csharp", slashDocComment);
+        insertDocComment("fsharp", slashDocComment);
+        insertDocComment("vbnet", tickDocComment);
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_xml_doc
+};

package/dist/chunk-QLTOG4MT.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-QPFIT7U6.js

@@ -0,0 +1,54 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-DYCT6UGG.js";
+import {
+  require_ruby
+} from "./chunk-3NZA4542.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/erb.js
+var require_erb = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/erb.js"(exports, module) {
+    var refractorRuby = require_ruby();
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = erb;
+    erb.displayName = "erb";
+    erb.aliases = [];
+    function erb(Prism) {
+      Prism.register(refractorRuby);
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        Prism2.languages.erb = {
+          delimiter: {
+            pattern: /^(\s*)<%=?|%>(?=\s*$)/,
+            lookbehind: true,
+            alias: "punctuation"
+          },
+          ruby: {
+            pattern: /\s*\S[\s\S]*/,
+            alias: "language-ruby",
+            inside: Prism2.languages.ruby
+          }
+        };
+        Prism2.hooks.add("before-tokenize", function(env) {
+          var erbPattern = /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "erb",
+            erbPattern
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "erb");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_erb
+};