@photonix/basic 2.2.1 → 3.0.0

package/dist/chunk-HUUYGABV.mjs

@@ -1,229 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/asciidoc.js
-asciidoc.displayName = "asciidoc";
-asciidoc.aliases = ["adoc"];
-function asciidoc(Prism) {
-  ;
-  (function(Prism2) {
-    var attributes = {
-      pattern: /(^[ \t]*)\[(?!\[)(?:(["'$`])(?:(?!\2)[^\\]|\\.)*\2|\[(?:[^\[\]\\]|\\.)*\]|[^\[\]\\"'$`]|\\.)*\]/m,
-      lookbehind: true,
-      inside: {
-        quoted: {
-          pattern: /([$`])(?:(?!\1)[^\\]|\\.)*\1/,
-          inside: {
-            punctuation: /^[$`]|[$`]$/
-          }
-        },
-        interpreted: {
-          pattern: /'(?:[^'\\]|\\.)*'/,
-          inside: {
-            punctuation: /^'|'$/
-            // See rest below
-          }
-        },
-        string: /"(?:[^"\\]|\\.)*"/,
-        variable: /\w+(?==)/,
-        punctuation: /^\[|\]$|,/,
-        operator: /=/,
-        // The negative look-ahead prevents blank matches
-        "attr-value": /(?!^\s+$).+/
-      }
-    };
-    var asciidoc2 = Prism2.languages.asciidoc = {
-      "comment-block": {
-        pattern: /^(\/{4,})$[\s\S]*?^\1/m,
-        alias: "comment"
-      },
-      table: {
-        pattern: /^\|={3,}(?:(?:\r?\n|\r(?!\n)).*)*?(?:\r?\n|\r)\|={3,}$/m,
-        inside: {
-          specifiers: {
-            pattern: /(?:(?:(?:\d+(?:\.\d+)?|\.\d+)[+*](?:[<^>](?:\.[<^>])?|\.[<^>])?|[<^>](?:\.[<^>])?|\.[<^>])[a-z]*|[a-z]+)(?=\|)/,
-            alias: "attr-value"
-          },
-          punctuation: {
-            pattern: /(^|[^\\])[|!]=*/,
-            lookbehind: true
-          }
-          // See rest below
-        }
-      },
-      "passthrough-block": {
-        pattern: /^(\+{4,})$[\s\S]*?^\1$/m,
-        inside: {
-          punctuation: /^\++|\++$/
-          // See rest below
-        }
-      },
-      // Literal blocks and listing blocks
-      "literal-block": {
-        pattern: /^(-{4,}|\.{4,})$[\s\S]*?^\1$/m,
-        inside: {
-          punctuation: /^(?:-+|\.+)|(?:-+|\.+)$/
-          // See rest below
-        }
-      },
-      // Sidebar blocks, quote blocks, example blocks and open blocks
-      "other-block": {
-        pattern: /^(--|\*{4,}|_{4,}|={4,})$[\s\S]*?^\1$/m,
-        inside: {
-          punctuation: /^(?:-+|\*+|_+|=+)|(?:-+|\*+|_+|=+)$/
-          // See rest below
-        }
-      },
-      // list-punctuation and list-label must appear before indented-block
-      "list-punctuation": {
-        pattern: /(^[ \t]*)(?:-|\*{1,5}|\.{1,5}|(?:[a-z]|\d+)\.|[xvi]+\))(?= )/im,
-        lookbehind: true,
-        alias: "punctuation"
-      },
-      "list-label": {
-        pattern: /(^[ \t]*)[a-z\d].+(?::{2,4}|;;)(?=\s)/im,
-        lookbehind: true,
-        alias: "symbol"
-      },
-      "indented-block": {
-        pattern: /((\r?\n|\r)\2)([ \t]+)\S.*(?:(?:\r?\n|\r)\3.+)*(?=\2{2}|$)/,
-        lookbehind: true
-      },
-      comment: /^\/\/.*/m,
-      title: {
-        pattern: /^.+(?:\r?\n|\r)(?:={3,}|-{3,}|~{3,}|\^{3,}|\+{3,})$|^={1,5} .+|^\.(?![\s.]).*/m,
-        alias: "important",
-        inside: {
-          punctuation: /^(?:\.|=+)|(?:=+|-+|~+|\^+|\++)$/
-          // See rest below
-        }
-      },
-      "attribute-entry": {
-        pattern: /^:[^:\r\n]+:(?: .*?(?: \+(?:\r?\n|\r).*?)*)?$/m,
-        alias: "tag"
-      },
-      attributes,
-      hr: {
-        pattern: /^'{3,}$/m,
-        alias: "punctuation"
-      },
-      "page-break": {
-        pattern: /^<{3,}$/m,
-        alias: "punctuation"
-      },
-      admonition: {
-        pattern: /^(?:CAUTION|IMPORTANT|NOTE|TIP|WARNING):/m,
-        alias: "keyword"
-      },
-      callout: [
-        {
-          pattern: /(^[ \t]*)<?\d*>/m,
-          lookbehind: true,
-          alias: "symbol"
-        },
-        {
-          pattern: /<\d+>/,
-          alias: "symbol"
-        }
-      ],
-      macro: {
-        pattern: /\b[a-z\d][a-z\d-]*::?(?:[^\s\[\]]*\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
-        inside: {
-          function: /^[a-z\d-]+(?=:)/,
-          punctuation: /^::?/,
-          attributes: {
-            pattern: /(?:\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
-            inside: attributes.inside
-          }
-        }
-      },
-      inline: {
-        /*
-        The initial look-behind prevents the highlighting of escaped quoted text.
-        Quoted text can be multi-line but cannot span an empty line.
-        All quoted text can have attributes before [foobar, 'foobar', baz="bar"].
-        First, we handle the constrained quotes.
-        Those must be bounded by non-word chars and cannot have spaces between the delimiter and the first char.
-        They are, in order: _emphasis_, ``double quotes'', `single quotes', `monospace`, 'emphasis', *strong*, +monospace+ and #unquoted#
-        Then we handle the unconstrained quotes.
-        Those do not have the restrictions of the constrained quotes.
-        They are, in order: __emphasis__, **strong**, ++monospace++, +++passthrough+++, ##unquoted##, $$passthrough$$, ~subscript~, ^superscript^, {attribute-reference}, [[anchor]], [[[bibliography anchor]]], <<xref>>, (((indexes))) and ((indexes))
-        */
-        pattern: /(^|[^\\])(?:(?:\B\[(?:[^\]\\"']|(["'])(?:(?!\2)[^\\]|\\.)*\2|\\.)*\])?(?:\b_(?!\s)(?: _|[^_\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: _|[^_\\\r\n]|\\.)+)*_\b|\B``(?!\s).+?(?:(?:\r?\n|\r).+?)*''\B|\B`(?!\s)(?:[^`'\s]|\s+\S)+['`]\B|\B(['*+#])(?!\s)(?: \3|(?!\3)[^\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: \3|(?!\3)[^\\\r\n]|\\.)+)*\3\B)|(?:\[(?:[^\]\\"']|(["'])(?:(?!\4)[^\\]|\\.)*\4|\\.)*\])?(?:(__|\*\*|\+\+\+?|##|\$\$|[~^]).+?(?:(?:\r?\n|\r).+?)*\5|\{[^}\r\n]+\}|\[\[\[?.+?(?:(?:\r?\n|\r).+?)*\]?\]\]|<<.+?(?:(?:\r?\n|\r).+?)*>>|\(\(\(?.+?(?:(?:\r?\n|\r).+?)*\)?\)\)))/m,
-        lookbehind: true,
-        inside: {
-          attributes,
-          url: {
-            pattern: /^(?:\[\[\[?.+?\]?\]\]|<<.+?>>)$/,
-            inside: {
-              punctuation: /^(?:\[\[\[?|<<)|(?:\]\]\]?|>>)$/
-            }
-          },
-          "attribute-ref": {
-            pattern: /^\{.+\}$/,
-            inside: {
-              variable: {
-                pattern: /(^\{)[a-z\d,+_-]+/,
-                lookbehind: true
-              },
-              operator: /^[=?!#%@$]|!(?=[:}])/,
-              punctuation: /^\{|\}$|::?/
-            }
-          },
-          italic: {
-            pattern: /^(['_])[\s\S]+\1$/,
-            inside: {
-              punctuation: /^(?:''?|__?)|(?:''?|__?)$/
-            }
-          },
-          bold: {
-            pattern: /^\*[\s\S]+\*$/,
-            inside: {
-              punctuation: /^\*\*?|\*\*?$/
-            }
-          },
-          punctuation: /^(?:``?|\+{1,3}|##?|\$\$|[~^]|\(\(\(?)|(?:''?|\+{1,3}|##?|\$\$|[~^`]|\)?\)\))$/
-        }
-      },
-      replacement: {
-        pattern: /\((?:C|R|TM)\)/,
-        alias: "builtin"
-      },
-      entity: /&#?[\da-z]{1,8};/i,
-      "line-continuation": {
-        pattern: /(^| )\+$/m,
-        lookbehind: true,
-        alias: "punctuation"
-      }
-    };
-    function copyFromAsciiDoc(keys) {
-      keys = keys.split(" ");
-      var o = {};
-      for (var i = 0, l = keys.length; i < l; i++) {
-        o[keys[i]] = asciidoc2[keys[i]];
-      }
-      return o;
-    }
-    attributes.inside["interpreted"].inside.rest = copyFromAsciiDoc(
-      "macro inline replacement entity"
-    );
-    asciidoc2["passthrough-block"].inside.rest = copyFromAsciiDoc("macro");
-    asciidoc2["literal-block"].inside.rest = copyFromAsciiDoc("callout");
-    asciidoc2["table"].inside.rest = copyFromAsciiDoc(
-      "comment-block passthrough-block literal-block other-block list-punctuation indented-block comment title attribute-entry attributes hr page-break admonition list-label callout macro inline replacement entity line-continuation"
-    );
-    asciidoc2["other-block"].inside.rest = copyFromAsciiDoc(
-      "table list-punctuation indented-block comment attribute-entry attributes hr page-break admonition list-label macro inline replacement entity line-continuation"
-    );
-    asciidoc2["title"].inside.rest = copyFromAsciiDoc(
-      "macro inline replacement entity"
-    );
-    Prism2.hooks.add("wrap", function(env) {
-      if (env.type === "entity") {
-        env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
-      }
-    });
-    Prism2.languages.adoc = Prism2.languages.asciidoc;
-  })(Prism);
-}
-
-export {
-  asciidoc
-};

package/dist/chunk-I5VVAONE.mjs

@@ -1,37 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gedcom.js
-gedcom.displayName = "gedcom";
-gedcom.aliases = [];
-function gedcom(Prism) {
-  Prism.languages.gedcom = {
-    "line-value": {
-      // Preceded by level, optional pointer, and tag
-      pattern: /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?\w+ ).+/m,
-      lookbehind: true,
-      inside: {
-        pointer: {
-          pattern: /^@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@$/,
-          alias: "variable"
-        }
-      }
-    },
-    record: {
-      // Preceded by level and optional pointer
-      pattern: /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?)\w+/m,
-      lookbehind: true,
-      alias: "tag"
-    },
-    level: {
-      pattern: /(^[\t ]*)\d+/m,
-      lookbehind: true,
-      alias: "number"
-    },
-    pointer: {
-      pattern: /@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@/,
-      alias: "variable"
-    }
-  };
-}
-
-export {
-  gedcom
-};

package/dist/chunk-I7URAA2D.mjs

@@ -1,58 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/parigp.js
-parigp.displayName = "parigp";
-parigp.aliases = [];
-function parigp(Prism) {
-  Prism.languages.parigp = {
-    comment: /\/\*[\s\S]*?\*\/|\\\\.*/,
-    string: {
-      pattern: /"(?:[^"\\\r\n]|\\.)*"/,
-      greedy: true
-    },
-    // PARI/GP does not care about white spaces at all
-    // so let's process the keywords to build an appropriate regexp
-    // (e.g. "b *r *e *a *k", etc.)
-    keyword: (function() {
-      var keywords = [
-        "breakpoint",
-        "break",
-        "dbg_down",
-        "dbg_err",
-        "dbg_up",
-        "dbg_x",
-        "forcomposite",
-        "fordiv",
-        "forell",
-        "forpart",
-        "forprime",
-        "forstep",
-        "forsubgroup",
-        "forvec",
-        "for",
-        "iferr",
-        "if",
-        "local",
-        "my",
-        "next",
-        "return",
-        "until",
-        "while"
-      ];
-      keywords = keywords.map(function(keyword) {
-        return keyword.split("").join(" *");
-      }).join("|");
-      return RegExp("\\b(?:" + keywords + ")\\b");
-    })(),
-    function: /\b\w(?:[\w ]*\w)?(?= *\()/,
-    number: {
-      // The lookbehind and the negative lookahead prevent from breaking the .. operator
-      pattern: /((?:\. *\. *)?)(?:\b\d(?: *\d)*(?: *(?!\. *\.)\.(?: *\d)*)?|\. *\d(?: *\d)*)(?: *e *(?:[+-] *)?\d(?: *\d)*)?/i,
-      lookbehind: true
-    },
-    operator: /\. *\.|[*\/!](?: *=)?|%(?: *=|(?: *#)?(?: *')*)?|\+(?: *[+=])?|-(?: *[-=>])?|<(?: *>|(?: *<)?(?: *=)?)?|>(?: *>)?(?: *=)?|=(?: *=){0,2}|\\(?: *\/)?(?: *=)?|&(?: *&)?|\| *\||['#~^]/,
-    punctuation: /[\[\]{}().,:;|]/
-  };
-}
-
-export {
-  parigp
-};

package/dist/chunk-IDHF73VJ.mjs

@@ -1,93 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/uri.js
-uri.displayName = "uri";
-uri.aliases = ["url"];
-function uri(Prism) {
-  Prism.languages.uri = {
-    scheme: {
-      pattern: /^[a-z][a-z0-9+.-]*:/im,
-      greedy: true,
-      inside: {
-        "scheme-delimiter": /:$/
-      }
-    },
-    fragment: {
-      pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
-      inside: {
-        "fragment-delimiter": /^#/
-      }
-    },
-    query: {
-      pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
-      inside: {
-        "query-delimiter": {
-          pattern: /^\?/,
-          greedy: true
-        },
-        "pair-delimiter": /[&;]/,
-        pair: {
-          pattern: /^[^=][\s\S]*/,
-          inside: {
-            key: /^[^=]+/,
-            value: {
-              pattern: /(^=)[\s\S]+/,
-              lookbehind: true
-            }
-          }
-        }
-      }
-    },
-    authority: {
-      pattern: RegExp(
-        /^\/\//.source + // [ userinfo "@" ]
-        /(?:[\w\-.~!$&'()*+,;=%:]*@)?/.source + // host
-        ("(?:" + // IP-literal
-        /\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\.[\w\-.~!$&'()*+,;=]+)\]/.source + "|" + // IPv4address or registered name
-        /[\w\-.~!$&'()*+,;=%]*/.source + ")") + // [ ":" port ]
-        /(?::\d*)?/.source,
-        "m"
-      ),
-      inside: {
-        "authority-delimiter": /^\/\//,
-        "user-info-segment": {
-          pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
-          inside: {
-            "user-info-delimiter": /@$/,
-            "user-info": /^[\w\-.~!$&'()*+,;=%:]+/
-          }
-        },
-        "port-segment": {
-          pattern: /:\d*$/,
-          inside: {
-            "port-delimiter": /^:/,
-            port: /^\d+/
-          }
-        },
-        host: {
-          pattern: /[\s\S]+/,
-          inside: {
-            "ip-literal": {
-              pattern: /^\[[\s\S]+\]$/,
-              inside: {
-                "ip-literal-delimiter": /^\[|\]$/,
-                "ipv-future": /^v[\s\S]+/,
-                "ipv6-address": /^[\s\S]+/
-              }
-            },
-            "ipv4-address": /^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
-          }
-        }
-      }
-    },
-    path: {
-      pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
-      inside: {
-        "path-separator": /\//
-      }
-    }
-  };
-  Prism.languages.url = Prism.languages.uri;
-}
-
-export {
-  uri
-};

package/dist/chunk-IFHLNQQT.mjs

@@ -1,93 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/d.js
-d.displayName = "d";
-d.aliases = [];
-function d(Prism) {
-  Prism.register(clike);
-  Prism.languages.d = Prism.languages.extend("clike", {
-    comment: [
-      {
-        // Shebang
-        pattern: /^\s*#!.+/,
-        greedy: true
-      },
-      {
-        pattern: RegExp(
-          /(^|[^\\])/.source + "(?:" + [
-            // /+ comment +/
-            // Allow one level of nesting
-            /\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source,
-            // // comment
-            /\/\/.*/.source,
-            // /* comment */
-            /\/\*[\s\S]*?\*\//.source
-          ].join("|") + ")"
-        ),
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    string: [
-      {
-        pattern: RegExp(
-          [
-            // r"", x""
-            /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source,
-            // q"[]", q"()", q"<>", q"{}"
-            /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source,
-            // q"IDENT
-            // ...
-            // IDENT"
-            /\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source,
-            // q"//", q"||", etc.
-            // eslint-disable-next-line regexp/strict
-            /\bq"(.)[\s\S]*?\2"/.source,
-            // eslint-disable-next-line regexp/strict
-            /(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source
-          ].join("|"),
-          "m"
-        ),
-        greedy: true
-      },
-      {
-        pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/,
-        greedy: true,
-        alias: "token-string"
-      }
-    ],
-    // In order: $, keywords and special tokens, globally defined symbols
-    keyword: /\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\b/,
-    number: [
-      // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
-      // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
-      /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]{0,4}/i,
-      {
-        pattern: /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i,
-        lookbehind: true
-      }
-    ],
-    operator: /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
-  });
-  Prism.languages.insertBefore("d", "string", {
-    // Characters
-    // 'a', '\\', '\n', '\xFF', '\377', '\uFFFF', '\U0010FFFF', '\quot'
-    char: /'(?:\\(?:\W|\w+)|[^\\])'/
-  });
-  Prism.languages.insertBefore("d", "keyword", {
-    property: /\B@\w*/
-  });
-  Prism.languages.insertBefore("d", "function", {
-    register: {
-      // Iasm registers
-      pattern: /\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
-      alias: "variable"
-    }
-  });
-}
-
-export {
-  d
-};

package/dist/chunk-IICYJGGM.mjs

@@ -1,73 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/antlr4.js
-antlr4.displayName = "antlr4";
-antlr4.aliases = ["g4"];
-function antlr4(Prism) {
-  Prism.languages.antlr4 = {
-    comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
-    string: {
-      pattern: /'(?:\\.|[^\\'\r\n])*'/,
-      greedy: true
-    },
-    "character-class": {
-      pattern: /\[(?:\\.|[^\\\]\r\n])*\]/,
-      greedy: true,
-      alias: "regex",
-      inside: {
-        range: {
-          pattern: /([^[]|(?:^|[^\\])(?:\\\\)*\\\[)-(?!\])/,
-          lookbehind: true,
-          alias: "punctuation"
-        },
-        escape: /\\(?:u(?:[a-fA-F\d]{4}|\{[a-fA-F\d]+\})|[pP]\{[=\w-]+\}|[^\r\nupP])/,
-        punctuation: /[\[\]]/
-      }
-    },
-    action: {
-      pattern: /\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\}/,
-      greedy: true,
-      inside: {
-        content: {
-          // this might be C, C++, Python, Java, C#, or any other language ANTLR4 compiles to
-          pattern: /(\{)[\s\S]+(?=\})/,
-          lookbehind: true
-        },
-        punctuation: /[{}]/
-      }
-    },
-    command: {
-      pattern: /(->\s*(?!\s))(?:\s*(?:,\s*)?\b[a-z]\w*(?:\s*\([^()\r\n]*\))?)+(?=\s*;)/i,
-      lookbehind: true,
-      inside: {
-        function: /\b\w+(?=\s*(?:[,(]|$))/,
-        punctuation: /[,()]/
-      }
-    },
-    annotation: {
-      pattern: /@\w+(?:::\w+)*/,
-      alias: "keyword"
-    },
-    label: {
-      pattern: /#[ \t]*\w+/,
-      alias: "punctuation"
-    },
-    keyword: /\b(?:catch|channels|finally|fragment|grammar|import|lexer|locals|mode|options|parser|returns|throws|tokens)\b/,
-    definition: [
-      {
-        pattern: /\b[a-z]\w*(?=\s*:)/,
-        alias: ["rule", "class-name"]
-      },
-      {
-        pattern: /\b[A-Z]\w*(?=\s*:)/,
-        alias: ["token", "constant"]
-      }
-    ],
-    constant: /\b[A-Z][A-Z_]*\b/,
-    operator: /\.\.|->|[|~]|[*+?]\??/,
-    punctuation: /[;:()=]/
-  };
-  Prism.languages.g4 = Prism.languages.antlr4;
-}
-
-export {
-  antlr4
-};

package/dist/chunk-IOD54SQ2.mjs

@@ -1,56 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/t4-templating.js
-t4Templating.displayName = "t4-templating";
-t4Templating.aliases = [];
-function t4Templating(Prism) {
-  ;
-  (function(Prism2) {
-    function createBlock(prefix, inside, contentAlias) {
-      return {
-        pattern: RegExp("<#" + prefix + "[\\s\\S]*?#>"),
-        alias: "block",
-        inside: {
-          delimiter: {
-            pattern: RegExp("^<#" + prefix + "|#>$"),
-            alias: "important"
-          },
-          content: {
-            pattern: /[\s\S]+/,
-            inside,
-            alias: contentAlias
-          }
-        }
-      };
-    }
-    function createT4(insideLang) {
-      var grammar = Prism2.languages[insideLang];
-      var className = "language-" + insideLang;
-      return {
-        block: {
-          pattern: /<#[\s\S]+?#>/,
-          inside: {
-            directive: createBlock("@", {
-              "attr-value": {
-                pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/,
-                inside: {
-                  punctuation: /^=|^["']|["']$/
-                }
-              },
-              keyword: /\b\w+(?=\s)/,
-              "attr-name": /\b\w+/
-            }),
-            expression: createBlock("=", grammar, className),
-            "class-feature": createBlock("\\+", grammar, className),
-            standard: createBlock("", grammar, className)
-          }
-        }
-      };
-    }
-    Prism2.languages["t4-templating"] = Object.defineProperty({}, "createT4", {
-      value: createT4
-    });
-  })(Prism);
-}
-
-export {
-  t4Templating
-};