@photonix/basic 2.2.1 → 3.0.0

package/dist/chunk-M4GABTFY.mjs

@@ -1,46 +0,0 @@
-// ../../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

@@ -1,86 +0,0 @@
-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

@@ -1,64 +0,0 @@
-// ../../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

@@ -1,102 +0,0 @@
-// ../../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

@@ -1,27 +0,0 @@
-// ../../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

@@ -1,50 +0,0 @@
-// ../../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

@@ -1,81 +0,0 @@
-// ../../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

@@ -1,23 +0,0 @@
-// ../../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

@@ -1,93 +0,0 @@
-// ../../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

@@ -1,44 +0,0 @@
-// ../../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

@@ -1,36 +0,0 @@
-// ../../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
-};