@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-M4GABTFY.mjs

@@ -0,0 +1,46 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nix.js
+nix.displayName = "nix";
+nix.aliases = [];
+function nix(Prism) {
+  Prism.languages.nix = {
+    comment: {
+      pattern: /\/\*[\s\S]*?\*\/|#.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"\\]|\\[\s\S])*"|''(?:(?!'')[\s\S]|''(?:'|\\|\$\{))*''/,
+      greedy: true,
+      inside: {
+        interpolation: {
+          // The lookbehind ensures the ${} is not preceded by \ or ''
+          pattern: /(^|(?:^|(?!'').)[^\\])\$\{(?:[^{}]|\{[^}]*\})*\}/,
+          lookbehind: true,
+          inside: null
+          // see below
+        }
+      }
+    },
+    url: [
+      /\b(?:[a-z]{3,7}:\/\/)[\w\-+%~\/.:#=?&]+/,
+      {
+        pattern: /([^\/])(?:[\w\-+%~.:#=?&]*(?!\/\/)[\w\-+%~\/.:#=?&])?(?!\/\/)\/[\w\-+%~\/.:#=?&]*/,
+        lookbehind: true
+      }
+    ],
+    antiquotation: {
+      pattern: /\$(?=\{)/,
+      alias: "important"
+    },
+    number: /\b\d+\b/,
+    keyword: /\b(?:assert|builtins|else|if|in|inherit|let|null|or|then|with)\b/,
+    function: /\b(?:abort|add|all|any|attrNames|attrValues|baseNameOf|compareVersions|concatLists|currentSystem|deepSeq|derivation|dirOf|div|elem(?:At)?|fetch(?:Tarball|url)|filter(?:Source)?|fromJSON|genList|getAttr|getEnv|hasAttr|hashString|head|import|intersectAttrs|is(?:Attrs|Bool|Function|Int|List|Null|String)|length|lessThan|listToAttrs|map|mul|parseDrvName|pathExists|read(?:Dir|File)|removeAttrs|replaceStrings|seq|sort|stringLength|sub(?:string)?|tail|throw|to(?:File|JSON|Path|String|XML)|trace|typeOf)\b|\bfoldl'\B/,
+    boolean: /\b(?:false|true)\b/,
+    operator: /[=!<>]=?|\+\+?|\|\||&&|\/\/|->?|[?@]/,
+    punctuation: /[{}()[\].,:;]/
+  };
+  Prism.languages.nix.string.inside.interpolation.inside = Prism.languages.nix;
+}
+
+export {
+  nix
+};

package/dist/chunk-M7NINWV6.mjs

@@ -0,0 +1,86 @@
+import {
+  scheme
+} from "./chunk-OREANV5Y.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/lilypond.js
+lilypond.displayName = "lilypond";
+lilypond.aliases = ["ly"];
+function lilypond(Prism) {
+  Prism.register(scheme);
+  (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 {
+  lilypond
+};

package/dist/chunk-MDHB544N.mjs

@@ -0,0 +1,64 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/stan.js
+stan.displayName = "stan";
+stan.aliases = [];
+function stan(Prism) {
+  ;
+  (function(Prism2) {
+    var higherOrderFunctions = /\b(?:algebra_solver|algebra_solver_newton|integrate_1d|integrate_ode|integrate_ode_bdf|integrate_ode_rk45|map_rect|ode_(?:adams|bdf|ckrk|rk45)(?:_tol)?|ode_adjoint_tol_ctl|reduce_sum|reduce_sum_static)\b/;
+    Prism2.languages.stan = {
+      comment: /\/\/.*|\/\*[\s\S]*?\*\/|#(?!include).*/,
+      string: {
+        // String literals can contain spaces and any printable ASCII characters except for " and \
+        // https://mc-stan.org/docs/2_24/reference-manual/print-statements-section.html#string-literals
+        pattern: /"[\x20\x21\x23-\x5B\x5D-\x7E]*"/,
+        greedy: true
+      },
+      directive: {
+        pattern: /^([ \t]*)#include\b.*/m,
+        lookbehind: true,
+        alias: "property"
+      },
+      "function-arg": {
+        pattern: RegExp(
+          "(" + higherOrderFunctions.source + /\s*\(\s*/.source + ")" + /[a-zA-Z]\w*/.source
+        ),
+        lookbehind: true,
+        alias: "function"
+      },
+      constraint: {
+        pattern: /(\b(?:int|matrix|real|row_vector|vector)\s*)<[^<>]*>/,
+        lookbehind: true,
+        inside: {
+          expression: {
+            pattern: /(=\s*)\S(?:\S|\s+(?!\s))*?(?=\s*(?:>$|,\s*\w+\s*=))/,
+            lookbehind: true,
+            inside: null
+            // see below
+          },
+          property: /\b[a-z]\w*(?=\s*=)/i,
+          operator: /=/,
+          punctuation: /^<|>$|,/
+        }
+      },
+      keyword: [
+        {
+          pattern: /\bdata(?=\s*\{)|\b(?:functions|generated|model|parameters|quantities|transformed)\b/,
+          alias: "program-block"
+        },
+        /\b(?:array|break|cholesky_factor_corr|cholesky_factor_cov|complex|continue|corr_matrix|cov_matrix|data|else|for|if|in|increment_log_prob|int|matrix|ordered|positive_ordered|print|real|reject|return|row_vector|simplex|target|unit_vector|vector|void|while)\b/,
+        // these are functions that are known to take another function as their first argument.
+        higherOrderFunctions
+      ],
+      function: /\b[a-z]\w*(?=\s*\()/i,
+      number: /(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:E[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+      boolean: /\b(?:false|true)\b/,
+      operator: /<-|\.[*/]=?|\|\|?|&&|[!=<>+\-*/]=?|['^%~?:]/,
+      punctuation: /[()\[\]{},;]/
+    };
+    Prism2.languages.stan.constraint.inside.expression.inside = Prism2.languages.stan;
+  })(Prism);
+}
+
+export {
+  stan
+};

package/dist/chunk-MICLKL5C.mjs

@@ -0,0 +1,102 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/zig.js
+zig.displayName = "zig";
+zig.aliases = [];
+function zig(Prism) {
+  ;
+  (function(Prism2) {
+    function literal(str) {
+      return function() {
+        return str;
+      };
+    }
+    var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
+    var IDENTIFIER = "\\b(?!" + keyword.source + ")(?!\\d)\\w+\\b";
+    var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source;
+    var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(
+      /<ALIGN>/g,
+      literal(ALIGN)
+    );
+    var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(
+      /<ID>/g,
+      literal(IDENTIFIER)
+    );
+    var TYPE = "(?!\\s)(?:!?\\s*(?:" + PREFIX_TYPE_OP + "\\s*)*" + SUFFIX_EXPR + ")+";
+    Prism2.languages.zig = {
+      comment: [
+        {
+          pattern: /\/\/[/!].*/,
+          alias: "doc-comment"
+        },
+        /\/{2}.*/
+      ],
+      string: [
+        {
+          // "string" and c"string"
+          pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          // multiline strings and c-strings
+          pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      char: {
+        // characters 'a', '\n', '\xFF', '\u{10FFFF}'
+        pattern: /(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/,
+        lookbehind: true,
+        greedy: true
+      },
+      builtin: /\B@(?!\d)\w+(?=\s*\()/,
+      label: {
+        pattern: /(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/,
+        lookbehind: true
+      },
+      "class-name": [
+        // const Foo = struct {};
+        /\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/,
+        {
+          // const x: i32 = 9;
+          // var x: Bar;
+          // fn foo(x: bool, y: f32) void {}
+          pattern: RegExp(
+            /(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))
+          ),
+          lookbehind: true,
+          inside: null
+          // see below
+        },
+        {
+          // extern fn foo(x: f64) f64; (optional alignment)
+          pattern: RegExp(
+            /(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))
+          ),
+          lookbehind: true,
+          inside: null
+          // see below
+        }
+      ],
+      "builtin-type": {
+        pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,
+        alias: "keyword"
+      },
+      keyword,
+      function: /\b(?!\d)\w+(?=\s*\()/,
+      number: /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,
+      boolean: /\b(?:false|true)\b/,
+      operator: /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,
+      punctuation: /[.:,;(){}[\]]/
+    };
+    Prism2.languages.zig["class-name"].forEach(function(obj) {
+      if (obj.inside === null) {
+        obj.inside = Prism2.languages.zig;
+      }
+    });
+  })(Prism);
+}
+
+export {
+  zig
+};

package/dist/chunk-MIJVA5YD.mjs

@@ -0,0 +1,27 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/xojo.js
+xojo.displayName = "xojo";
+xojo.aliases = [];
+function xojo(Prism) {
+  Prism.languages.xojo = {
+    comment: {
+      pattern: /(?:'|\/\/|Rem\b).+/i,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:""|[^"])*"/,
+      greedy: true
+    },
+    number: [/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i, /&[bchou][a-z\d]+/i],
+    directive: {
+      pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\b/i,
+      alias: "property"
+    },
+    keyword: /\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\b/i,
+    operator: /<[=>]?|>=?|[+\-*\/\\^=]|\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\b/i,
+    punctuation: /[.,;:()]/
+  };
+}
+
+export {
+  xojo
+};

package/dist/chunk-MJEZSXQR.mjs

@@ -0,0 +1,50 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/asmatmel.js
+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 {
+  asmatmel
+};

package/dist/chunk-MOAYWP7F.mjs

@@ -0,0 +1,81 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cue.js
+cue.displayName = "cue";
+cue.aliases = [];
+function cue(Prism) {
+  ;
+  (function(Prism2) {
+    var stringEscape = /\\(?:(?!\2)|\2(?:[^()\r\n]|\([^()]*\)))/.source;
+    var stringTypes = /"""(?:[^\\"]|"(?!""\2)|<esc>)*"""/.source + // eslint-disable-next-line regexp/strict
+    "|" + /'''(?:[^\\']|'(?!''\2)|<esc>)*'''/.source + // eslint-disable-next-line regexp/strict
+    "|" + /"(?:[^\\\r\n"]|"(?!\2)|<esc>)*"/.source + // eslint-disable-next-line regexp/strict
+    "|" + /'(?:[^\\\r\n']|'(?!\2)|<esc>)*'/.source;
+    var stringLiteral = "(?:" + stringTypes.replace(/<esc>/g, stringEscape) + ")";
+    Prism2.languages.cue = {
+      comment: {
+        pattern: /\/\/.*/,
+        greedy: true
+      },
+      "string-literal": {
+        // eslint-disable-next-line regexp/strict
+        pattern: RegExp(
+          /(^|[^#"'\\])(#*)/.source + stringLiteral + /(?!["'])\2/.source
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          // I'm using dirty hack here. We have to know the number hashes at the start of the string somehow,
+          // but we can't look back. So instead, we will use a lookahead, go to the end of the string, and
+          // capture the hashes at the end of the string.
+          escape: {
+            pattern: /(?=[\s\S]*["'](#*)$)\\\1(?:U[a-fA-F0-9]{1,8}|u[a-fA-F0-9]{1,4}|x[a-fA-F0-9]{1,2}|\d{2,3}|[^(])/,
+            greedy: true,
+            alias: "string"
+          },
+          interpolation: {
+            pattern: /(?=[\s\S]*["'](#*)$)\\\1\([^()]*\)/,
+            greedy: true,
+            inside: {
+              punctuation: /^\\#*\(|\)$/,
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: null
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      keyword: {
+        pattern: /(^|[^\w$])(?:for|if|import|in|let|null|package)(?![\w$])/,
+        lookbehind: true
+      },
+      boolean: {
+        pattern: /(^|[^\w$])(?:false|true)(?![\w$])/,
+        lookbehind: true
+      },
+      builtin: {
+        pattern: /(^|[^\w$])(?:bool|bytes|float|float(?:32|64)|u?int(?:8|16|32|64|128)?|number|rune|string)(?![\w$])/,
+        lookbehind: true
+      },
+      attribute: {
+        pattern: /@[\w$]+(?=\s*\()/,
+        alias: "function"
+      },
+      function: {
+        pattern: /(^|[^\w$])[a-z_$][\w$]*(?=\s*\()/i,
+        lookbehind: true
+      },
+      number: {
+        pattern: /(^|[^\w$.])(?:0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|0[xX][0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*|(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[eE][+-]?\d+(?:_\d+)*)?(?:[KMGTP]i?)?)(?![\w$])/,
+        lookbehind: true
+      },
+      operator: /\.{3}|_\|_|&&?|\|\|?|[=!]~|[<>=!]=?|[+\-*/?]/,
+      punctuation: /[()[\]{},.:]/
+    };
+    Prism2.languages.cue["string-literal"].inside.interpolation.inside.expression.inside = Prism2.languages.cue;
+  })(Prism);
+}
+
+export {
+  cue
+};

package/dist/chunk-MRD4O5EG.mjs

@@ -0,0 +1,23 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/hoon.js
+hoon.displayName = "hoon";
+hoon.aliases = [];
+function hoon(Prism) {
+  Prism.languages.hoon = {
+    comment: {
+      pattern: /::.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/,
+      greedy: true
+    },
+    constant: /%(?:\.[ny]|[\w-]+)/,
+    "class-name": /@(?:[a-z0-9-]*[a-z0-9])?|\*/i,
+    function: /(?:\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,
+    keyword: /\.[\^\+\*=\?]|![><:\.=\?!]|=[>|:,\.\-\^<+;/~\*\?]|\?[>|:\.\-\^<\+&~=@!]|\|[\$_%:\.\-\^~\*=@\?]|\+[|\$\+\*]|:[_\-\^\+~\*]|%[_:\.\-\^\+~\*=]|\^[|:\.\-\+&~\*=\?]|\$[|_%:<>\-\^&~@=\?]|;[:<\+;\/~\*=]|~[>|\$_%<\+\/&=\?!]|--|==/
+  };
+}
+
+export {
+  hoon
+};

package/dist/chunk-MTBHIETI.mjs

@@ -0,0 +1,93 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/metafont.js
+metafont.displayName = "metafont";
+metafont.aliases = [];
+function metafont(Prism) {
+  Prism.languages.metafont = {
+    // Syntax of METAFONT with the added (public) elements of PlainMETAFONT. Except for internal quantities they are expected to be rarely redefined. Freely inspired by the syntax of Christophe Grandsire for the Crimson Editor.
+    comment: {
+      pattern: /%.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"[^\r\n"]*"/,
+      greedy: true
+    },
+    number: /\d*\.?\d+/,
+    boolean: /\b(?:false|true)\b/,
+    punctuation: [
+      /[,;()]/,
+      {
+        pattern: /(^|[^{}])(?:\{|\})(?![{}])/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^[])\[(?!\[)/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^\]])\](?!\])/,
+        lookbehind: true
+      }
+    ],
+    constant: [
+      {
+        pattern: /(^|[^!?])\?\?\?(?![!?])/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^/*\\])(?:\\|\\\\)(?![/*\\])/,
+        lookbehind: true
+      },
+      /\b(?:_|blankpicture|bp|cc|cm|dd|ditto|down|eps|epsilon|fullcircle|halfcircle|identity|in|infinity|left|mm|nullpen|nullpicture|origin|pc|penrazor|penspeck|pensquare|penstroke|proof|pt|quartercircle|relax|right|smoke|unitpixel|unitsquare|up)\b/
+    ],
+    quantity: {
+      pattern: /\b(?:autorounding|blacker|boundarychar|charcode|chardp|chardx|chardy|charext|charht|charic|charwd|currentwindow|day|designsize|displaying|fillin|fontmaking|granularity|hppp|join_radius|month|o_correction|pausing|pen_(?:bot|lft|rt|top)|pixels_per_inch|proofing|showstopping|smoothing|time|tolerance|tracingcapsules|tracingchoices|tracingcommands|tracingedges|tracingequations|tracingmacros|tracingonline|tracingoutput|tracingpens|tracingrestores|tracingspecs|tracingstats|tracingtitles|turningcheck|vppp|warningcheck|xoffset|year|yoffset)\b/,
+      alias: "keyword"
+    },
+    command: {
+      pattern: /\b(?:addto|batchmode|charlist|cull|display|errhelp|errmessage|errorstopmode|everyjob|extensible|fontdimen|headerbyte|inner|interim|let|ligtable|message|newinternal|nonstopmode|numspecial|openwindow|outer|randomseed|save|scrollmode|shipout|show|showdependencies|showstats|showtoken|showvariable|special)\b/,
+      alias: "builtin"
+    },
+    operator: [
+      {
+        pattern: /(^|[^>=<:|])(?:<|<=|=|=:|\|=:|\|=:>|=:\|>|=:\||\|=:\||\|=:\|>|\|=:\|>>|>|>=|:|:=|<>|::|\|\|:)(?![>=<:|])/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^+-])(?:\+|\+\+|-{1,3}|\+-\+)(?![+-])/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^/*\\])(?:\*|\*\*|\/)(?![/*\\])/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^.])(?:\.{2,3})(?!\.)/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^@#&$])&(?![@#&$])/,
+        lookbehind: true
+      },
+      /\b(?:and|not|or)\b/
+    ],
+    macro: {
+      pattern: /\b(?:abs|beginchar|bot|byte|capsule_def|ceiling|change_width|clear_pen_memory|clearit|clearpen|clearxy|counterclockwise|cullit|cutdraw|cutoff|decr|define_blacker_pixels|define_corrected_pixels|define_good_x_pixels|define_good_y_pixels|define_horizontal_corrected_pixels|define_pixels|define_whole_blacker_pixels|define_whole_pixels|define_whole_vertical_blacker_pixels|define_whole_vertical_pixels|dir|direction|directionpoint|div|dotprod|downto|draw|drawdot|endchar|erase|fill|filldraw|fix_units|flex|font_coding_scheme|font_extra_space|font_identifier|font_normal_shrink|font_normal_space|font_normal_stretch|font_quad|font_size|font_slant|font_x_height|gfcorners|gobble|gobbled|good\.(?:bot|lft|rt|top|x|y)|grayfont|hide|hround|imagerules|incr|interact|interpath|intersectionpoint|inverse|italcorr|killtext|labelfont|labels|lft|loggingall|lowres_fix|makegrid|makelabel(?:\.(?:bot|lft|rt|top)(?:\.nodot)?)?|max|min|mod|mode_def|mode_setup|nodisplays|notransforms|numtok|openit|penlabels|penpos|pickup|proofoffset|proofrule|proofrulethickness|range|reflectedabout|rotatedabout|rotatedaround|round|rt|savepen|screenchars|screenrule|screenstrokes|shipit|showit|slantfont|softjoin|solve|stop|superellipse|tensepath|thru|titlefont|top|tracingall|tracingnone|undraw|undrawdot|unfill|unfilldraw|upto|vround)\b/,
+      alias: "function"
+    },
+    builtin: /\b(?:ASCII|angle|char|cosd|decimal|directiontime|floor|hex|intersectiontimes|jobname|known|length|makepath|makepen|mexp|mlog|normaldeviate|oct|odd|pencircle|penoffset|point|postcontrol|precontrol|reverse|rotated|sind|sqrt|str|subpath|substring|totalweight|turningnumber|uniformdeviate|unknown|xpart|xxpart|xypart|ypart|yxpart|yypart)\b/,
+    keyword: /\b(?:also|at|atleast|begingroup|charexists|contour|controls|curl|cycle|def|delimiters|doublepath|dropping|dump|else|elseif|end|enddef|endfor|endgroup|endinput|exitif|exitunless|expandafter|fi|for|forever|forsuffixes|from|if|input|inwindow|keeping|kern|of|primarydef|quote|readstring|scaled|scantokens|secondarydef|shifted|skipto|slanted|step|tension|tertiarydef|to|transformed|until|vardef|withpen|withweight|xscaled|yscaled|zscaled)\b/,
+    type: {
+      pattern: /\b(?:boolean|expr|numeric|pair|path|pen|picture|primary|secondary|string|suffix|tertiary|text|transform)\b/,
+      alias: "property"
+    },
+    variable: {
+      pattern: /(^|[^@#&$])(?:@#|#@|#|@)(?![@#&$])|\b(?:aspect_ratio|currentpen|currentpicture|currenttransform|d|extra_beginchar|extra_endchar|extra_setup|h|localfont|mag|mode|screen_cols|screen_rows|w|whatever|x|y|z)\b/,
+      lookbehind: true
+    }
+  };
+}
+
+export {
+  metafont
+};

package/dist/chunk-MW6GNI73.mjs

@@ -0,0 +1,44 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/psl.js
+psl.displayName = "psl";
+psl.aliases = [];
+function psl(Prism) {
+  Prism.languages.psl = {
+    comment: {
+      pattern: /#.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:\\.|[^\\"])*"/,
+      greedy: true,
+      inside: {
+        symbol: /\\[ntrbA-Z"\\]/
+      }
+    },
+    "heredoc-string": {
+      pattern: /<<<([a-zA-Z_]\w*)[\r\n](?:.*[\r\n])*?\1\b/,
+      alias: "string",
+      greedy: true
+    },
+    keyword: /\b(?:__multi|__single|case|default|do|else|elsif|exit|export|for|foreach|function|if|last|line|local|next|requires|return|switch|until|while|word)\b/,
+    constant: /\b(?:ALARM|CHART_ADD_GRAPH|CHART_DELETE_GRAPH|CHART_DESTROY|CHART_LOAD|CHART_PRINT|EOF|OFFLINE|OK|PSL_PROF_LOG|R_CHECK_HORIZ|R_CHECK_VERT|R_CLICKER|R_COLUMN|R_FRAME|R_ICON|R_LABEL|R_LABEL_CENTER|R_LIST_MULTIPLE|R_LIST_MULTIPLE_ND|R_LIST_SINGLE|R_LIST_SINGLE_ND|R_MENU|R_POPUP|R_POPUP_SCROLLED|R_RADIO_HORIZ|R_RADIO_VERT|R_ROW|R_SCALE_HORIZ|R_SCALE_VERT|R_SEP_HORIZ|R_SEP_VERT|R_SPINNER|R_TEXT_FIELD|R_TEXT_FIELD_LABEL|R_TOGGLE|TRIM_LEADING|TRIM_LEADING_AND_TRAILING|TRIM_REDUNDANT|TRIM_TRAILING|VOID|WARN)\b/,
+    boolean: /\b(?:FALSE|False|NO|No|TRUE|True|YES|Yes|false|no|true|yes)\b/,
+    variable: /\b(?:PslDebug|errno|exit_status)\b/,
+    builtin: {
+      pattern: /\b(?:PslExecute|PslFunctionCall|PslFunctionExists|PslSetOptions|_snmp_debug|acos|add_diary|annotate|annotate_get|ascii_to_ebcdic|asctime|asin|atan|atexit|batch_set|blackout|cat|ceil|chan_exists|change_state|close|code_cvt|cond_signal|cond_wait|console_type|convert_base|convert_date|convert_locale_date|cos|cosh|create|date|dcget_text|destroy|destroy_lock|dget_text|difference|dump_hist|ebcdic_to_ascii|encrypt|event_archive|event_catalog_get|event_check|event_query|event_range_manage|event_range_query|event_report|event_schedule|event_trigger|event_trigger2|execute|exists|exp|fabs|file|floor|fmod|fopen|fseek|ftell|full_discovery|get|get_chan_info|get_ranges|get_text|get_vars|getenv|gethostinfo|getpid|getpname|grep|history|history_get_retention|in_transition|index|int|internal|intersection|is_var|isnumber|join|kill|length|lines|lock|lock_info|log|log10|loge|matchline|msg_check|msg_get_format|msg_get_severity|msg_printf|msg_sprintf|ntharg|nthargf|nthline|nthlinef|num_bytes|num_consoles|pconfig|popen|poplines|pow|print|printf|proc_exists|process|random|read|readln|refresh_parameters|remote_check|remote_close|remote_event_query|remote_event_trigger|remote_file_send|remote_open|remove|replace|rindex|sec_check_priv|sec_store_get|sec_store_set|set|set_alarm_ranges|set_locale|share|sin|sinh|sleep|snmp_agent_config|snmp_agent_start|snmp_agent_stop|snmp_close|snmp_config|snmp_get|snmp_get_next|snmp_h_get|snmp_h_get_next|snmp_h_set|snmp_open|snmp_set|snmp_trap_ignore|snmp_trap_listen|snmp_trap_raise_std_trap|snmp_trap_receive|snmp_trap_register_im|snmp_trap_send|snmp_walk|sopen|sort|splitline|sprintf|sqrt|srandom|str_repeat|strcasecmp|subset|substr|system|tail|tan|tanh|text_domain|time|tmpnam|tolower|toupper|trace_psl_process|trim|union|unique|unlock|unset|va_arg|va_start|write)\b/,
+      alias: "builtin-function"
+    },
+    "foreach-variable": {
+      pattern: /(\bforeach\s+(?:(?:\w+\b|"(?:\\.|[^\\"])*")\s+){0,2})[_a-zA-Z]\w*(?=\s*\()/,
+      lookbehind: true,
+      greedy: true
+    },
+    function: /\b[_a-z]\w*\b(?=\s*\()/i,
+    number: /\b(?:0x[0-9a-f]+|\d+(?:\.\d+)?)\b/i,
+    operator: /--|\+\+|&&=?|\|\|=?|<<=?|>>=?|[=!]~|[-+*/%&|^!=<>]=?|\.|[:?]/,
+    punctuation: /[(){}\[\];,]/
+  };
+}
+
+export {
+  psl
+};

package/dist/chunk-MWNE32M5.mjs

@@ -0,0 +1,36 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/roboconf.js
+roboconf.displayName = "roboconf";
+roboconf.aliases = [];
+function roboconf(Prism) {
+  Prism.languages.roboconf = {
+    comment: /#.*/,
+    keyword: {
+      pattern: /(^|\s)(?:(?:external|import)\b|(?:facet|instance of)(?=[ \t]+[\w-]+[ \t]*\{))/,
+      lookbehind: true
+    },
+    component: {
+      pattern: /[\w-]+(?=[ \t]*\{)/,
+      alias: "variable"
+    },
+    property: /[\w.-]+(?=[ \t]*:)/,
+    value: {
+      pattern: /(=[ \t]*(?![ \t]))[^,;]+/,
+      lookbehind: true,
+      alias: "attr-value"
+    },
+    optional: {
+      pattern: /\(optional\)/,
+      alias: "builtin"
+    },
+    wildcard: {
+      pattern: /(\.)\*/,
+      lookbehind: true,
+      alias: "operator"
+    },
+    punctuation: /[{},.;:=]/
+  };
+}
+
+export {
+  roboconf
+};