@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-ZANS26VH.mjs

@@ -1,145 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/puppet.js
-puppet.displayName = "puppet";
-puppet.aliases = [];
-function puppet(Prism) {
-  ;
-  (function(Prism2) {
-    Prism2.languages.puppet = {
-      heredoc: [
-        // Matches the content of a quoted heredoc string (subject to interpolation)
-        {
-          pattern: /(@\("([^"\r\n\/):]+)"(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
-          lookbehind: true,
-          alias: "string",
-          inside: {
-            // Matches the end tag
-            punctuation: /(?=\S).*\S(?= *$)/
-            // See interpolation below
-          }
-        },
-        // Matches the content of an unquoted heredoc string (no interpolation)
-        {
-          pattern: /(@\(([^"\r\n\/):]+)(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
-          lookbehind: true,
-          greedy: true,
-          alias: "string",
-          inside: {
-            // Matches the end tag
-            punctuation: /(?=\S).*\S(?= *$)/
-          }
-        },
-        // Matches the start tag of heredoc strings
-        {
-          pattern: /@\("?(?:[^"\r\n\/):]+)"?(?:\/[nrts$uL]*)?\)/,
-          alias: "string",
-          inside: {
-            punctuation: {
-              pattern: /(\().+?(?=\))/,
-              lookbehind: true
-            }
-          }
-        }
-      ],
-      "multiline-comment": {
-        pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
-        lookbehind: true,
-        greedy: true,
-        alias: "comment"
-      },
-      regex: {
-        // Must be prefixed with the keyword "node" or a non-word char
-        pattern: /((?:\bnode\s+|[~=\(\[\{,]\s*|[=+]>\s*|^\s*))\/(?:[^\/\\]|\\[\s\S])+\/(?:[imx]+\b|\B)/,
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          // Extended regexes must have the x flag. They can contain single-line comments.
-          "extended-regex": {
-            pattern: /^\/(?:[^\/\\]|\\[\s\S])+\/[im]*x[im]*$/,
-            inside: {
-              comment: /#.*/
-            }
-          }
-        }
-      },
-      comment: {
-        pattern: /(^|[^\\])#.*/,
-        lookbehind: true,
-        greedy: true
-      },
-      string: {
-        // Allow for one nested level of double quotes inside interpolation
-        pattern: /(["'])(?:\$\{(?:[^'"}]|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}|\$(?!\{)|(?!\1)[^\\$]|\\[\s\S])*\1/,
-        greedy: true,
-        inside: {
-          "double-quoted": {
-            pattern: /^"[\s\S]*"$/,
-            inside: {
-              // See interpolation below
-            }
-          }
-        }
-      },
-      variable: {
-        pattern: /\$(?:::)?\w+(?:::\w+)*/,
-        inside: {
-          punctuation: /::/
-        }
-      },
-      "attr-name": /(?:\b\w+|\*)(?=\s*=>)/,
-      function: [
-        {
-          pattern: /(\.)(?!\d)\w+/,
-          lookbehind: true
-        },
-        /\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\b|\b(?!\d)\w+(?=\()/
-      ],
-      number: /\b(?:0x[a-f\d]+|\d+(?:\.\d+)?(?:e-?\d+)?)\b/i,
-      boolean: /\b(?:false|true)\b/,
-      // Includes words reserved for future use
-      keyword: /\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\b/,
-      datatype: {
-        pattern: /\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\b/,
-        alias: "symbol"
-      },
-      operator: /=[=~>]?|![=~]?|<(?:<\|?|[=~|-])?|>[>=]?|->?|~>|\|>?>?|[*\/%+?]|\b(?:and|in|or)\b/,
-      punctuation: /[\[\]{}().,;]|:+/
-    };
-    var interpolation = [
-      {
-        // Allow for one nested level of braces inside interpolation
-        pattern: /(^|[^\\])\$\{(?:[^'"{}]|\{[^}]*\}|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}/,
-        lookbehind: true,
-        inside: {
-          "short-variable": {
-            // Negative look-ahead prevent wrong highlighting of functions
-            pattern: /(^\$\{)(?!\w+\()(?:::)?\w+(?:::\w+)*/,
-            lookbehind: true,
-            alias: "variable",
-            inside: {
-              punctuation: /::/
-            }
-          },
-          delimiter: {
-            pattern: /^\$/,
-            alias: "variable"
-          },
-          rest: Prism2.languages.puppet
-        }
-      },
-      {
-        pattern: /(^|[^\\])\$(?:::)?\w+(?:::\w+)*/,
-        lookbehind: true,
-        alias: "variable",
-        inside: {
-          punctuation: /::/
-        }
-      }
-    ];
-    Prism2.languages.puppet["heredoc"][0].inside.interpolation = interpolation;
-    Prism2.languages.puppet["string"].inside["double-quoted"].inside.interpolation = interpolation;
-  })(Prism);
-}
-
-export {
-  puppet
-};

package/dist/chunk-ZAOYQDOD.mjs

@@ -1,57 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/squirrel.js
-squirrel.displayName = "squirrel";
-squirrel.aliases = [];
-function squirrel(Prism) {
-  Prism.register(clike);
-  Prism.languages.squirrel = Prism.languages.extend("clike", {
-    comment: [
-      Prism.languages.clike["comment"][0],
-      {
-        pattern: /(^|[^\\:])(?:\/\/|#).*/,
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    string: {
-      pattern: /(^|[^\\"'@])(?:@"(?:[^"]|"")*"(?!")|"(?:[^\\\r\n"]|\\.)*")/,
-      lookbehind: true,
-      greedy: true
-    },
-    "class-name": {
-      pattern: /(\b(?:class|enum|extends|instanceof)\s+)\w+(?:\.\w+)*/,
-      lookbehind: true,
-      inside: {
-        punctuation: /\./
-      }
-    },
-    keyword: /\b(?:__FILE__|__LINE__|base|break|case|catch|class|clone|const|constructor|continue|default|delete|else|enum|extends|for|foreach|function|if|in|instanceof|local|null|resume|return|static|switch|this|throw|try|typeof|while|yield)\b/,
-    number: /\b(?:0x[0-9a-fA-F]+|\d+(?:\.(?:\d+|[eE][+-]?\d+))?)\b/,
-    operator: /\+\+|--|<=>|<[-<]|>>>?|&&?|\|\|?|[-+*/%!=<>]=?|[~^]|::?/,
-    punctuation: /[(){}\[\],;.]/
-  });
-  Prism.languages.insertBefore("squirrel", "string", {
-    char: {
-      pattern: /(^|[^\\"'])'(?:[^\\']|\\(?:[xuU][0-9a-fA-F]{0,8}|[\s\S]))'/,
-      lookbehind: true,
-      greedy: true
-    }
-  });
-  Prism.languages.insertBefore("squirrel", "operator", {
-    "attribute-punctuation": {
-      pattern: /<\/|\/>/,
-      alias: "important"
-    },
-    lambda: {
-      pattern: /@(?=\()/,
-      alias: "operator"
-    }
-  });
-}
-
-export {
-  squirrel
-};

package/dist/chunk-ZDDMHBHL.mjs

@@ -1,31 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/io.js
-io.displayName = "io";
-io.aliases = [];
-function io(Prism) {
-  Prism.languages.io = {
-    comment: {
-      pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*|#.*)/,
-      lookbehind: true,
-      greedy: true
-    },
-    "triple-quoted-string": {
-      pattern: /"""(?:\\[\s\S]|(?!""")[^\\])*"""/,
-      greedy: true,
-      alias: "string"
-    },
-    string: {
-      pattern: /"(?:\\.|[^\\\r\n"])*"/,
-      greedy: true
-    },
-    keyword: /\b(?:activate|activeCoroCount|asString|block|break|call|catch|clone|collectGarbage|compileString|continue|do|doFile|doMessage|doString|else|elseif|exit|for|foreach|forward|getEnvironmentVariable|getSlot|hasSlot|if|ifFalse|ifNil|ifNilEval|ifTrue|isActive|isNil|isResumable|list|message|method|parent|pass|pause|perform|performWithArgList|print|println|proto|raise|raiseResumable|removeSlot|resend|resume|schedulerSleepSeconds|self|sender|setSchedulerSleepSeconds|setSlot|shallowCopy|slotNames|super|system|then|thisBlock|thisContext|try|type|uniqueId|updateSlot|wait|while|write|yield)\b/,
-    builtin: /\b(?:Array|AudioDevice|AudioMixer|BigNum|Block|Box|Buffer|CFunction|CGI|Color|Curses|DBM|DNSResolver|DOConnection|DOProxy|DOServer|Date|Directory|Duration|DynLib|Error|Exception|FFT|File|Fnmatch|Font|Future|GL|GLE|GLScissor|GLU|GLUCylinder|GLUQuadric|GLUSphere|GLUT|Host|Image|Importer|LinkList|List|Lobby|Locals|MD5|MP3Decoder|MP3Encoder|Map|Message|Movie|Notification|Number|Object|OpenGL|Point|Protos|Random|Regex|SGML|SGMLElement|SGMLParser|SQLite|Sequence|Server|ShowMessage|SleepyCat|SleepyCatCursor|Socket|SocketManager|Sound|Soup|Store|String|Tree|UDPSender|UPDReceiver|URL|User|Warning|WeakLink)\b/,
-    boolean: /\b(?:false|nil|true)\b/,
-    number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?/i,
-    operator: /[=!*/%+\-^&|]=|>>?=?|<<?=?|:?:?=|\+\+?|--?|\*\*?|\/\/?|%|\|\|?|&&?|\b(?:and|not|or|return)\b|@@?|\?\??|\.\./,
-    punctuation: /[{}[\];(),.:]/
-  };
-}
-
-export {
-  io
-};

package/dist/chunk-ZJHA5XZO.mjs

@@ -1,22 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ichigojam.js
-ichigojam.displayName = "ichigojam";
-ichigojam.aliases = [];
-function ichigojam(Prism) {
-  Prism.languages.ichigojam = {
-    comment: /(?:\B'|REM)(?:[^\n\r]*)/i,
-    string: {
-      pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
-      greedy: true
-    },
-    number: /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
-    keyword: /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,
-    function: /\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i,
-    label: /(?:\B@\S+)/,
-    operator: /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,
-    punctuation: /[\[,;:()\]]/
-  };
-}
-
-export {
-  ichigojam
-};

package/dist/chunk-ZJYVOTZA.mjs

@@ -1,154 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/javascript.js
-javascript.displayName = "javascript";
-javascript.aliases = ["js"];
-function javascript(Prism) {
-  Prism.register(clike);
-  Prism.languages.javascript = Prism.languages.extend("clike", {
-    "class-name": [
-      Prism.languages.clike["class-name"],
-      {
-        pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-        lookbehind: true
-      }
-    ],
-    keyword: [
-      {
-        pattern: /((?:^|\})\s*)catch\b/,
-        lookbehind: true
-      },
-      {
-        pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
-        lookbehind: true
-      }
-    ],
-    // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-    function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
-    number: {
-      pattern: RegExp(
-        /(^|[^\w$])/.source + "(?:" + // constant
-        (/NaN|Infinity/.source + "|" + // binary integer
-        /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
-        /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
-        /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
-        /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
-        /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
-      ),
-      lookbehind: true
-    },
-    operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-  });
-  Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
-  Prism.languages.insertBefore("javascript", "keyword", {
-    regex: {
-      pattern: RegExp(
-        // lookbehind
-        // eslint-disable-next-line regexp/no-dupe-characters-character-class
-        /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
-        // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
-        // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
-        // with the only syntax, so we have to define 2 different regex patterns.
-        /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
-        /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
-        /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
-      ),
-      lookbehind: true,
-      greedy: true,
-      inside: {
-        "regex-source": {
-          pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-          lookbehind: true,
-          alias: "language-regex",
-          inside: Prism.languages.regex
-        },
-        "regex-delimiter": /^\/|\/$/,
-        "regex-flags": /^[a-z]+$/
-      }
-    },
-    // This must be declared before keyword because we use "function" inside the look-forward
-    "function-variable": {
-      pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
-      alias: "function"
-    },
-    parameter: [
-      {
-        pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
-        lookbehind: true,
-        inside: Prism.languages.javascript
-      },
-      {
-        pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-        lookbehind: true,
-        inside: Prism.languages.javascript
-      },
-      {
-        pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-        lookbehind: true,
-        inside: Prism.languages.javascript
-      },
-      {
-        pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
-        lookbehind: true,
-        inside: Prism.languages.javascript
-      }
-    ],
-    constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-  });
-  Prism.languages.insertBefore("javascript", "string", {
-    hashbang: {
-      pattern: /^#!.*/,
-      greedy: true,
-      alias: "comment"
-    },
-    "template-string": {
-      pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
-      greedy: true,
-      inside: {
-        "template-punctuation": {
-          pattern: /^`|`$/,
-          alias: "string"
-        },
-        interpolation: {
-          pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-          lookbehind: true,
-          inside: {
-            "interpolation-punctuation": {
-              pattern: /^\$\{|\}$/,
-              alias: "punctuation"
-            },
-            rest: Prism.languages.javascript
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    "string-property": {
-      pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-      lookbehind: true,
-      greedy: true,
-      alias: "property"
-    }
-  });
-  Prism.languages.insertBefore("javascript", "operator", {
-    "literal-property": {
-      pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-      lookbehind: true,
-      alias: "property"
-    }
-  });
-  if (Prism.languages.markup) {
-    Prism.languages.markup.tag.addInlined("script", "javascript");
-    Prism.languages.markup.tag.addAttribute(
-      /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
-      "javascript"
-    );
-  }
-  Prism.languages.js = Prism.languages.javascript;
-}
-
-export {
-  javascript
-};

package/dist/chunk-ZUKZIHVA.mjs

@@ -1,88 +0,0 @@
-import {
-  markup
-} from "./chunk-ACDTS7FW.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/parser.js
-parser.displayName = "parser";
-parser.aliases = [];
-function parser(Prism) {
-  Prism.register(markup);
-  (function(Prism2) {
-    var parser2 = Prism2.languages.parser = Prism2.languages.extend("markup", {
-      keyword: {
-        pattern: /(^|[^^])(?:\^(?:case|eval|for|if|switch|throw)\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\b)/,
-        lookbehind: true
-      },
-      variable: {
-        pattern: /(^|[^^])\B\$(?:\w+|(?=[.{]))(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
-        lookbehind: true,
-        inside: {
-          punctuation: /\.|:+/
-        }
-      },
-      function: {
-        pattern: /(^|[^^])\B[@^]\w+(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
-        lookbehind: true,
-        inside: {
-          keyword: {
-            pattern: /(^@)(?:GET_|SET_)/,
-            lookbehind: true
-          },
-          punctuation: /\.|:+/
-        }
-      },
-      escape: {
-        pattern: /\^(?:[$^;@()\[\]{}"':]|#[a-f\d]*)/i,
-        alias: "builtin"
-      },
-      punctuation: /[\[\](){};]/
-    });
-    parser2 = Prism2.languages.insertBefore("parser", "keyword", {
-      "parser-comment": {
-        pattern: /(\s)#.*/,
-        lookbehind: true,
-        alias: "comment"
-      },
-      expression: {
-        // Allow for 3 levels of depth
-        pattern: /(^|[^^])\((?:[^()]|\((?:[^()]|\((?:[^()])*\))*\))*\)/,
-        greedy: true,
-        lookbehind: true,
-        inside: {
-          string: {
-            pattern: /(^|[^^])(["'])(?:(?!\2)[^^]|\^[\s\S])*\2/,
-            lookbehind: true
-          },
-          keyword: parser2.keyword,
-          variable: parser2.variable,
-          function: parser2.function,
-          boolean: /\b(?:false|true)\b/,
-          number: /\b(?:0x[a-f\d]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?)\b/i,
-          escape: parser2.escape,
-          operator: /[~+*\/\\%]|!(?:\|\|?|=)?|&&?|\|\|?|==|<[<=]?|>[>=]?|-[fd]?|\b(?:def|eq|ge|gt|in|is|le|lt|ne)\b/,
-          punctuation: parser2.punctuation
-        }
-      }
-    });
-    Prism2.languages.insertBefore(
-      "inside",
-      "punctuation",
-      {
-        expression: parser2.expression,
-        keyword: parser2.keyword,
-        variable: parser2.variable,
-        function: parser2.function,
-        escape: parser2.escape,
-        "parser-punctuation": {
-          pattern: parser2.punctuation,
-          alias: "punctuation"
-        }
-      },
-      parser2["tag"].inside["attr-value"]
-    );
-  })(Prism);
-}
-
-export {
-  parser
-};

package/dist/chunk-ZXGNAYWP.mjs

@@ -1,57 +0,0 @@
-import {
-  css
-} from "./chunk-4RG7ZGOZ.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/less.js
-less.displayName = "less";
-less.aliases = [];
-function less(Prism) {
-  Prism.register(css);
-  Prism.languages.less = Prism.languages.extend("css", {
-    comment: [
-      /\/\*[\s\S]*?\*\//,
-      {
-        pattern: /(^|[^\\])\/\/.*/,
-        lookbehind: true
-      }
-    ],
-    atrule: {
-      pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
-      inside: {
-        punctuation: /[:()]/
-      }
-    },
-    // selectors and mixins are considered the same
-    selector: {
-      pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
-      inside: {
-        // mixin parameters
-        variable: /@+[\w-]+/
-      }
-    },
-    property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
-    operator: /[+\-*\/]/
-  });
-  Prism.languages.insertBefore("less", "property", {
-    variable: [
-      // Variable declaration (the colon must be consumed!)
-      {
-        pattern: /@[\w-]+\s*:/,
-        inside: {
-          punctuation: /:/
-        }
-      },
-      // Variable usage
-      /@@?[\w-]+/
-    ],
-    "mixin-usage": {
-      pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
-      lookbehind: true,
-      alias: "function"
-    }
-  });
-}
-
-export {
-  less
-};

package/dist/cil-YRE4UURD.mjs

@@ -1,7 +0,0 @@
-import {
-  cil
-} from "./chunk-NW4X76P6.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  cil as default
-};

package/dist/cilkc-G572IBC7.mjs

@@ -1,9 +0,0 @@
-import {
-  cilkc
-} from "./chunk-KTTPS6E5.mjs";
-import "./chunk-PEEMT7UZ.mjs";
-import "./chunk-XWTEQUC3.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  cilkc as default
-};

package/dist/cilkcpp-6SAZDXPW.mjs

@@ -1,10 +0,0 @@
-import {
-  cilkcpp
-} from "./chunk-BAH7KB65.mjs";
-import "./chunk-BCCX6KVT.mjs";
-import "./chunk-PEEMT7UZ.mjs";
-import "./chunk-XWTEQUC3.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  cilkcpp as default
-};

package/dist/clean-FJLAWUXX.mjs

@@ -1,36 +0,0 @@
-import {
-  __commonJS
-} from "./chunk-XGB3TDIC.mjs";
-
-// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/clean.js
-var require_clean = __commonJS({
-  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/clean.js"(exports, module) {
-    function clean(hljs) {
-      return {
-        name: "Clean",
-        aliases: [
-          "icl",
-          "dcl"
-        ],
-        keywords: {
-          keyword: "if let in with where case of class instance otherwise implementation definition system module from import qualified as special code inline foreign export ccall stdcall generic derive infix infixl infixr",
-          built_in: "Int Real Char Bool",
-          literal: "True False"
-        },
-        contains: [
-          hljs.C_LINE_COMMENT_MODE,
-          hljs.C_BLOCK_COMMENT_MODE,
-          hljs.APOS_STRING_MODE,
-          hljs.QUOTE_STRING_MODE,
-          hljs.C_NUMBER_MODE,
-          {
-            // relevance booster
-            begin: "->|<-[|:]?|#!?|>>=|\\{\\||\\|\\}|:==|=:|<>"
-          }
-        ]
-      };
-    }
-    module.exports = clean;
-  }
-});
-export default require_clean();

package/dist/clike-FS7B7WW3.mjs

@@ -1,7 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  clike as default
-};