@photonix/basic 1.5.1 → 1.6.0

package/dist/chunk-HUUYGABV.mjs

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

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

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

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

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

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

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