@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-7DNV4OOB.mjs

@@ -0,0 +1,36 @@
+import {
+  basic
+} from "./chunk-ATBA76CY.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/vbnet.js
+vbnet.displayName = "vbnet";
+vbnet.aliases = [];
+function vbnet(Prism) {
+  Prism.register(basic);
+  Prism.languages.vbnet = Prism.languages.extend("basic", {
+    comment: [
+      {
+        pattern: /(?:!|REM\b).+/i,
+        inside: {
+          keyword: /^REM/i
+        }
+      },
+      {
+        pattern: /(^|[^\\:])'.*/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    string: {
+      pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
+      lookbehind: true,
+      greedy: true
+    },
+    keyword: /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
+    punctuation: /[,;:(){}]/
+  });
+}
+
+export {
+  vbnet
+};

package/dist/chunk-7DVLILHM.mjs

@@ -0,0 +1,36 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gdscript.js
+gdscript.displayName = "gdscript";
+gdscript.aliases = [];
+function gdscript(Prism) {
+  Prism.languages.gdscript = {
+    comment: /#.*/,
+    string: {
+      pattern: /@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/,
+      greedy: true
+    },
+    "class-name": {
+      // class_name Foo, extends Bar, class InnerClass
+      // export(int) var baz, export(int, 0) var i
+      // as Node
+      // const FOO: int = 9, var bar: bool = true
+      // func add(reference: Item, amount: int) -> Item:
+      pattern: /(^(?:class|class_name|extends)[ \t]+|^export\([ \t]*|\bas[ \t]+|(?:\b(?:const|var)[ \t]|[,(])[ \t]*\w+[ \t]*:[ \t]*|->[ \t]*)[a-zA-Z_]\w*/m,
+      lookbehind: true
+    },
+    keyword: /\b(?:and|as|assert|break|breakpoint|class|class_name|const|continue|elif|else|enum|export|extends|for|func|if|in|is|master|mastersync|match|not|null|onready|or|pass|preload|puppet|puppetsync|remote|remotesync|return|self|setget|signal|static|tool|var|while|yield)\b/,
+    function: /\b[a-z_]\w*(?=[ \t]*\()/i,
+    variable: /\$\w+/,
+    number: [
+      /\b0b[01_]+\b|\b0x[\da-fA-F_]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.[\d_]+)(?:e[+-]?[\d_]+)?\b/,
+      /\b(?:INF|NAN|PI|TAU)\b/
+    ],
+    constant: /\b[A-Z][A-Z_\d]*\b/,
+    boolean: /\b(?:false|true)\b/,
+    operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/,
+    punctuation: /[.:,;()[\]{}]/
+  };
+}
+
+export {
+  gdscript
+};

package/dist/chunk-7IHZ4YUI.mjs

@@ -0,0 +1,58 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cobol.js
+cobol.displayName = "cobol";
+cobol.aliases = [];
+function cobol(Prism) {
+  Prism.languages.cobol = {
+    comment: {
+      pattern: /\*>.*|(^[ \t]*)\*.*/m,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /[xzgn]?(?:"(?:[^\r\n"]|"")*"(?!")|'(?:[^\r\n']|'')*'(?!'))/i,
+      greedy: true
+    },
+    level: {
+      pattern: /(^[ \t]*)\d+\b/m,
+      lookbehind: true,
+      greedy: true,
+      alias: "number"
+    },
+    "class-name": {
+      // https://github.com/antlr/grammars-v4/blob/42edd5b687d183b5fa679e858a82297bd27141e7/cobol85/Cobol85.g4#L1015
+      pattern: /(\bpic(?:ture)?\s+)(?:(?:[-\w$/,:*+<>]|\.(?!\s|$))(?:\(\d+\))?)+/i,
+      lookbehind: true,
+      inside: {
+        number: {
+          pattern: /(\()\d+/,
+          lookbehind: true
+        },
+        punctuation: /[()]/
+      }
+    },
+    keyword: {
+      pattern: /(^|[^\w-])(?:ABORT|ACCEPT|ACCESS|ADD|ADDRESS|ADVANCING|AFTER|ALIGNED|ALL|ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE|ANY|ARE|AREA|AREAS|AS|ASCENDING|ASCII|ASSIGN|ASSOCIATED-DATA|ASSOCIATED-DATA-LENGTH|AT|ATTRIBUTE|AUTHOR|AUTO|AUTO-SKIP|BACKGROUND-COLOR|BACKGROUND-COLOUR|BASIS|BEEP|BEFORE|BEGINNING|BELL|BINARY|BIT|BLANK|BLINK|BLOCK|BOTTOM|BOUNDS|BY|BYFUNCTION|BYTITLE|CALL|CANCEL|CAPABLE|CCSVERSION|CD|CF|CH|CHAINING|CHANGED|CHANNEL|CHARACTER|CHARACTERS|CLASS|CLASS-ID|CLOCK-UNITS|CLOSE|CLOSE-DISPOSITION|COBOL|CODE|CODE-SET|COL|COLLATING|COLUMN|COM-REG|COMMA|COMMITMENT|COMMON|COMMUNICATION|COMP|COMP-1|COMP-2|COMP-3|COMP-4|COMP-5|COMPUTATIONAL|COMPUTATIONAL-1|COMPUTATIONAL-2|COMPUTATIONAL-3|COMPUTATIONAL-4|COMPUTATIONAL-5|COMPUTE|CONFIGURATION|CONTAINS|CONTENT|CONTINUE|CONTROL|CONTROL-POINT|CONTROLS|CONVENTION|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRUNCH|CURRENCY|CURSOR|DATA|DATA-BASE|DATE|DATE-COMPILED|DATE-WRITTEN|DAY|DAY-OF-WEEK|DBCS|DE|DEBUG-CONTENTS|DEBUG-ITEM|DEBUG-LINE|DEBUG-NAME|DEBUG-SUB-1|DEBUG-SUB-2|DEBUG-SUB-3|DEBUGGING|DECIMAL-POINT|DECLARATIVES|DEFAULT|DEFAULT-DISPLAY|DEFINITION|DELETE|DELIMITED|DELIMITER|DEPENDING|DESCENDING|DESTINATION|DETAIL|DFHRESP|DFHVALUE|DISABLE|DISK|DISPLAY|DISPLAY-1|DIVIDE|DIVISION|DONTCARE|DOUBLE|DOWN|DUPLICATES|DYNAMIC|EBCDIC|EGCS|EGI|ELSE|EMI|EMPTY-CHECK|ENABLE|END|END-ACCEPT|END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|END-PERFORM|END-READ|END-RECEIVE|END-RETURN|END-REWRITE|END-SEARCH|END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|ENDING|ENTER|ENTRY|ENTRY-PROCEDURE|ENVIRONMENT|EOL|EOP|EOS|ERASE|ERROR|ESCAPE|ESI|EVALUATE|EVENT|EVERY|EXCEPTION|EXCLUSIVE|EXHIBIT|EXIT|EXPORT|EXTEND|EXTENDED|EXTERNAL|FD|FILE|FILE-CONTROL|FILLER|FINAL|FIRST|FOOTING|FOR|FOREGROUND-COLOR|FOREGROUND-COLOUR|FROM|FULL|FUNCTION|FUNCTION-POINTER|FUNCTIONNAME|GENERATE|GIVING|GLOBAL|GO|GOBACK|GRID|GROUP|HEADING|HIGH-VALUE|HIGH-VALUES|HIGHLIGHT|I-O|I-O-CONTROL|ID|IDENTIFICATION|IF|IMPLICIT|IMPORT|IN|INDEX|INDEXED|INDICATE|INITIAL|INITIALIZE|INITIATE|INPUT|INPUT-OUTPUT|INSPECT|INSTALLATION|INTEGER|INTO|INVALID|INVOKE|IS|JUST|JUSTIFIED|KANJI|KEPT|KEY|KEYBOARD|LABEL|LANGUAGE|LAST|LB|LD|LEADING|LEFT|LEFTLINE|LENGTH|LENGTH-CHECK|LIBACCESS|LIBPARAMETER|LIBRARY|LIMIT|LIMITS|LINAGE|LINAGE-COUNTER|LINE|LINE-COUNTER|LINES|LINKAGE|LIST|LOCAL|LOCAL-STORAGE|LOCK|LONG-DATE|LONG-TIME|LOW-VALUE|LOW-VALUES|LOWER|LOWLIGHT|MEMORY|MERGE|MESSAGE|MMDDYYYY|MODE|MODULES|MORE-LABELS|MOVE|MULTIPLE|MULTIPLY|NAMED|NATIONAL|NATIONAL-EDITED|NATIVE|NEGATIVE|NETWORK|NEXT|NO|NO-ECHO|NULL|NULLS|NUMBER|NUMERIC|NUMERIC-DATE|NUMERIC-EDITED|NUMERIC-TIME|OBJECT-COMPUTER|OCCURS|ODT|OF|OFF|OMITTED|ON|OPEN|OPTIONAL|ORDER|ORDERLY|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|OVERLINE|OWN|PACKED-DECIMAL|PADDING|PAGE|PAGE-COUNTER|PASSWORD|PERFORM|PF|PH|PIC|PICTURE|PLUS|POINTER|PORT|POSITION|POSITIVE|PRINTER|PRINTING|PRIVATE|PROCEDURE|PROCEDURE-POINTER|PROCEDURES|PROCEED|PROCESS|PROGRAM|PROGRAM-ID|PROGRAM-LIBRARY|PROMPT|PURGE|QUEUE|QUOTE|QUOTES|RANDOM|RD|READ|READER|REAL|RECEIVE|RECEIVED|RECORD|RECORDING|RECORDS|RECURSIVE|REDEFINES|REEL|REF|REFERENCE|REFERENCES|RELATIVE|RELEASE|REMAINDER|REMARKS|REMOTE|REMOVAL|REMOVE|RENAMES|REPLACE|REPLACING|REPORT|REPORTING|REPORTS|REQUIRED|RERUN|RESERVE|RESET|RETURN|RETURN-CODE|RETURNING|REVERSE-VIDEO|REVERSED|REWIND|REWRITE|RF|RH|RIGHT|ROUNDED|RUN|SAME|SAVE|SCREEN|SD|SEARCH|SECTION|SECURE|SECURITY|SEGMENT|SEGMENT-LIMIT|SELECT|SEND|SENTENCE|SEPARATE|SEQUENCE|SEQUENTIAL|SET|SHARED|SHAREDBYALL|SHAREDBYRUNUNIT|SHARING|SHIFT-IN|SHIFT-OUT|SHORT-DATE|SIGN|SIZE|SORT|SORT-CONTROL|SORT-CORE-SIZE|SORT-FILE-SIZE|SORT-MERGE|SORT-MESSAGE|SORT-MODE-SIZE|SORT-RETURN|SOURCE|SOURCE-COMPUTER|SPACE|SPACES|SPECIAL-NAMES|STANDARD|STANDARD-1|STANDARD-2|START|STATUS|STOP|STRING|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUBTRACT|SUM|SUPPRESS|SYMBOL|SYMBOLIC|SYNC|SYNCHRONIZED|TABLE|TALLY|TALLYING|TAPE|TASK|TERMINAL|TERMINATE|TEST|TEXT|THEN|THREAD|THREAD-LOCAL|THROUGH|THRU|TIME|TIMER|TIMES|TITLE|TO|TODAYS-DATE|TODAYS-NAME|TOP|TRAILING|TRUNCATED|TYPE|TYPEDEF|UNDERLINE|UNIT|UNSTRING|UNTIL|UP|UPON|USAGE|USE|USING|VALUE|VALUES|VARYING|VIRTUAL|WAIT|WHEN|WHEN-COMPILED|WITH|WORDS|WORKING-STORAGE|WRITE|YEAR|YYYYDDD|YYYYMMDD|ZERO-FILL|ZEROES|ZEROS)(?![\w-])/i,
+      lookbehind: true
+    },
+    boolean: {
+      pattern: /(^|[^\w-])(?:false|true)(?![\w-])/i,
+      lookbehind: true
+    },
+    number: {
+      pattern: /(^|[^\w-])(?:[+-]?(?:(?:\d+(?:[.,]\d+)?|[.,]\d+)(?:e[+-]?\d+)?|zero))(?![\w-])/i,
+      lookbehind: true
+    },
+    operator: [
+      /<>|[<>]=?|[=+*/&]/,
+      {
+        pattern: /(^|[^\w-])(?:-|and|equal|greater|less|not|or|than)(?![\w-])/i,
+        lookbehind: true
+      }
+    ],
+    punctuation: /[.:,()]/
+  };
+}
+
+export {
+  cobol
+};

package/dist/chunk-7IJONQ5M.mjs

@@ -0,0 +1,87 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/typoscript.js
+typoscript.displayName = "typoscript";
+typoscript.aliases = ["tsconfig"];
+function typoscript(Prism) {
+  ;
+  (function(Prism2) {
+    var keywords = /\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\b/;
+    Prism2.languages.typoscript = {
+      comment: [
+        {
+          // multiline comments /* */
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: true
+        },
+        {
+          // double-slash comments - ignored when backslashes or colon is found in front
+          // also ignored whenever directly after an equal-sign, because it would probably be an url without protocol
+          pattern: /(^|[^\\:= \t]|(?:^|[^= \t])[ \t]+)\/\/.*/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          // hash comments - ignored when leading quote is found for hex colors in strings
+          pattern: /(^|[^"'])#.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      function: [
+        {
+          // old include style
+          pattern: /<INCLUDE_TYPOSCRIPT:\s*source\s*=\s*(?:"[^"\r\n]*"|'[^'\r\n]*')\s*>/,
+          inside: {
+            string: {
+              pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+              inside: {
+                keyword: keywords
+              }
+            },
+            keyword: {
+              pattern: /INCLUDE_TYPOSCRIPT/
+            }
+          }
+        },
+        {
+          // new include style
+          pattern: /@import\s*(?:"[^"\r\n]*"|'[^'\r\n]*')/,
+          inside: {
+            string: /"[^"\r\n]*"|'[^'\r\n]*'/
+          }
+        }
+      ],
+      string: {
+        pattern: /^([^=]*=[< ]?)(?:(?!\]\n).)*/,
+        lookbehind: true,
+        inside: {
+          function: /\{\$.*\}/,
+          // constants include
+          keyword: keywords,
+          number: /^\d+$/,
+          punctuation: /[,|:]/
+        }
+      },
+      keyword: keywords,
+      number: {
+        // special highlighting for indexes of arrays in tags
+        pattern: /\b\d+\s*[.{=]/,
+        inside: {
+          operator: /[.{=]/
+        }
+      },
+      tag: {
+        pattern: /\.?[-\w\\]+\.?/,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      punctuation: /[{}[\];(),.:|]/,
+      operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/
+    };
+    Prism2.languages.tsconfig = Prism2.languages.typoscript;
+  })(Prism);
+}
+
+export {
+  typoscript
+};

package/dist/chunk-7OVDXG5F.mjs

@@ -0,0 +1,64 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ocaml.js
+ocaml.displayName = "ocaml";
+ocaml.aliases = [];
+function ocaml(Prism) {
+  Prism.languages.ocaml = {
+    comment: {
+      pattern: /\(\*[\s\S]*?\*\)/,
+      greedy: true
+    },
+    char: {
+      pattern: /'(?:[^\\\r\n']|\\(?:.|[ox]?[0-9a-f]{1,3}))'/i,
+      greedy: true
+    },
+    string: [
+      {
+        pattern: /"(?:\\(?:[\s\S]|\r\n)|[^\\\r\n"])*"/,
+        greedy: true
+      },
+      {
+        pattern: /\{([a-z_]*)\|[\s\S]*?\|\1\}/,
+        greedy: true
+      }
+    ],
+    number: [
+      // binary and octal
+      /\b(?:0b[01][01_]*|0o[0-7][0-7_]*)\b/i,
+      // hexadecimal
+      /\b0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]*)?(?:p[+-]?\d[\d_]*)?(?!\w)/i,
+      // decimal
+      /\b\d[\d_]*(?:\.[\d_]*)?(?:e[+-]?\d[\d_]*)?(?!\w)/i
+    ],
+    directive: {
+      pattern: /\B#\w+/,
+      alias: "property"
+    },
+    label: {
+      pattern: /\B~\w+/,
+      alias: "property"
+    },
+    "type-variable": {
+      pattern: /\B'\w+/,
+      alias: "function"
+    },
+    variant: {
+      pattern: /`\w+/,
+      alias: "symbol"
+    },
+    // For the list of keywords and operators,
+    // see: http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#sec84
+    keyword: /\b(?:as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|value|virtual|when|where|while|with)\b/,
+    boolean: /\b(?:false|true)\b/,
+    "operator-like-punctuation": {
+      pattern: /\[[<>|]|[>|]\]|\{<|>\}/,
+      alias: "punctuation"
+    },
+    // Custom operators are allowed
+    operator: /\.[.~]|:[=>]|[=<>@^|&+\-*\/$%!?~][!$%&*+\-.\/:<=>?@^|~]*|\b(?:and|asr|land|lor|lsl|lsr|lxor|mod|or)\b/,
+    punctuation: /;;|::|[(){}\[\].,:;#]|\b_\b/
+  };
+}
+
+export {
+  ocaml
+};

package/dist/chunk-7PO46XPE.mjs

@@ -0,0 +1,97 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/coffeescript.js
+coffeescript.displayName = "coffeescript";
+coffeescript.aliases = ["coffee"];
+function coffeescript(Prism) {
+  Prism.register(javascript);
+  (function(Prism2) {
+    var comment = /#(?!\{).+/;
+    var interpolation = {
+      pattern: /#\{[^}]+\}/,
+      alias: "variable"
+    };
+    Prism2.languages.coffeescript = Prism2.languages.extend("javascript", {
+      comment,
+      string: [
+        // Strings are multiline
+        {
+          pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+          greedy: true
+        },
+        {
+          // Strings are multiline
+          pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+          greedy: true,
+          inside: {
+            interpolation
+          }
+        }
+      ],
+      keyword: /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
+      "class-member": {
+        pattern: /@(?!\d)\w+/,
+        alias: "variable"
+      }
+    });
+    Prism2.languages.insertBefore("coffeescript", "comment", {
+      "multiline-comment": {
+        pattern: /###[\s\S]+?###/,
+        alias: "comment"
+      },
+      // Block regexp can contain comments and interpolation
+      "block-regex": {
+        pattern: /\/{3}[\s\S]*?\/{3}/,
+        alias: "regex",
+        inside: {
+          comment,
+          interpolation
+        }
+      }
+    });
+    Prism2.languages.insertBefore("coffeescript", "string", {
+      "inline-javascript": {
+        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+        inside: {
+          delimiter: {
+            pattern: /^`|`$/,
+            alias: "punctuation"
+          },
+          script: {
+            pattern: /[\s\S]+/,
+            alias: "language-javascript",
+            inside: Prism2.languages.javascript
+          }
+        }
+      },
+      // Block strings
+      "multiline-string": [
+        {
+          pattern: /'''[\s\S]*?'''/,
+          greedy: true,
+          alias: "string"
+        },
+        {
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true,
+          alias: "string",
+          inside: {
+            interpolation
+          }
+        }
+      ]
+    });
+    Prism2.languages.insertBefore("coffeescript", "keyword", {
+      // Object property
+      property: /(?!\d)\w+(?=\s*:(?!:))/
+    });
+    delete Prism2.languages.coffeescript["template-string"];
+    Prism2.languages.coffee = Prism2.languages.coffeescript;
+  })(Prism);
+}
+
+export {
+  coffeescript
+};

package/dist/chunk-7QWU4RHN.mjs

@@ -0,0 +1,50 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/dataweave.js
+dataweave.displayName = "dataweave";
+dataweave.aliases = [];
+function dataweave(Prism) {
+  ;
+  (function(Prism2) {
+    Prism2.languages.dataweave = {
+      url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
+      property: {
+        pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
+        greedy: true
+      },
+      string: {
+        pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+        greedy: true
+      },
+      "mime-type": /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
+      date: {
+        pattern: /\|[\w:+-]+\|/,
+        greedy: true
+      },
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      regex: {
+        pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
+        greedy: true
+      },
+      keyword: /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
+      function: /\b[A-Z_]\w*(?=\s*\()/i,
+      number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      punctuation: /[{}[\];(),.:@]/,
+      operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
+      boolean: /\b(?:false|true)\b/
+    };
+  })(Prism);
+}
+
+export {
+  dataweave
+};

package/dist/chunk-7S3O473U.mjs

@@ -0,0 +1,44 @@
+import {
+  php
+} from "./chunk-4PP7IENX.mjs";
+import {
+  javadoclike
+} from "./chunk-NHRQUFUX.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/phpdoc.js
+phpdoc.displayName = "phpdoc";
+phpdoc.aliases = [];
+function phpdoc(Prism) {
+  Prism.register(javadoclike);
+  Prism.register(php);
+  (function(Prism2) {
+    var typeExpression = /(?:\b[a-zA-Z]\w*|[|\\[\]])+/.source;
+    Prism2.languages.phpdoc = Prism2.languages.extend("javadoclike", {
+      parameter: {
+        pattern: RegExp(
+          "(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" + typeExpression + "\\s+)?)\\$\\w+"
+        ),
+        lookbehind: true
+      }
+    });
+    Prism2.languages.insertBefore("phpdoc", "keyword", {
+      "class-name": [
+        {
+          pattern: RegExp(
+            "(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\s+)" + typeExpression
+          ),
+          lookbehind: true,
+          inside: {
+            keyword: /\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\b/,
+            punctuation: /[|\\[\]()]/
+          }
+        }
+      ]
+    });
+    Prism2.languages.javadoclike.addSupport("php", Prism2.languages.phpdoc);
+  })(Prism);
+}
+
+export {
+  phpdoc
+};

package/dist/chunk-7V4UZYAP.mjs

@@ -0,0 +1,177 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/avisynth.js
+avisynth.displayName = "avisynth";
+avisynth.aliases = ["avs"];
+function avisynth(Prism) {
+  ;
+  (function(Prism2) {
+    function replace(pattern, replacements) {
+      return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+        return replacements[+index];
+      });
+    }
+    function re(pattern, replacements, flags) {
+      return RegExp(replace(pattern, replacements), flags || "");
+    }
+    var types = /bool|clip|float|int|string|val/.source;
+    var internals = [
+      // bools
+      /is(?:bool|clip|float|int|string)|defined|(?:(?:internal)?function|var)?exists?/.source,
+      // control
+      /apply|assert|default|eval|import|nop|select|undefined/.source,
+      // global
+      /opt_(?:allowfloataudio|avipadscanlines|dwchannelmask|enable_(?:b64a|planartopackedrgb|v210|y3_10_10|y3_10_16)|usewaveextensible|vdubplanarhack)|set(?:cachemode|maxcpu|memorymax|planarlegacyalignment|workingdir)/.source,
+      // conv
+      /hex(?:value)?|value/.source,
+      // numeric
+      /abs|ceil|continued(?:denominator|numerator)?|exp|floor|fmod|frac|log(?:10)?|max|min|muldiv|pi|pow|rand|round|sign|spline|sqrt/.source,
+      // trig
+      /a?sinh?|a?cosh?|a?tan[2h]?/.source,
+      // bit
+      /(?:bit(?:and|not|x?or|[lr]?shift[aslu]?|sh[lr]|sa[lr]|[lr]rotatel?|ro[rl]|te?st|set(?:count)?|cl(?:ea)?r|ch(?:an)?ge?))/.source,
+      // runtime
+      /average(?:[bgr]|chroma[uv]|luma)|(?:[rgb]|chroma[uv]|luma|rgb|[yuv](?=difference(?:fromprevious|tonext)))difference(?:fromprevious|tonext)?|[yuvrgb]plane(?:median|min|max|minmaxdifference)/.source,
+      // script
+      /getprocessinfo|logmsg|script(?:dir(?:utf8)?|file(?:utf8)?|name(?:utf8)?)|setlogparams/.source,
+      // string
+      /chr|(?:fill|find|left|mid|replace|rev|right)str|format|[lu]case|ord|str(?:cmpi?|fromutf8|len|toutf8)|time|trim(?:all|left|right)/.source,
+      // version
+      /isversionorgreater|version(?:number|string)/.source,
+      // helper
+      /buildpixeltype|colorspacenametopixeltype/.source,
+      // avsplus
+      /addautoloaddir|on(?:cpu|cuda)|prefetch|setfiltermtmode/.source
+    ].join("|");
+    var properties = [
+      // content
+      /has(?:audio|video)/.source,
+      // resolution
+      /height|width/.source,
+      // framerate
+      /frame(?:count|rate)|framerate(?:denominator|numerator)/.source,
+      // interlacing
+      /getparity|is(?:field|frame)based/.source,
+      // color format
+      /bitspercomponent|componentsize|hasalpha|is(?:planar(?:rgba?)?|interleaved|rgb(?:24|32|48|64)?|y(?:8|u(?:va?|y2))?|yv(?:12|16|24|411)|420|422|444|packedrgb)|numcomponents|pixeltype/.source,
+      // audio
+      /audio(?:bits|channels|duration|length(?:[fs]|hi|lo)?|rate)|isaudio(?:float|int)/.source
+    ].join("|");
+    var filters = [
+      // source
+      /avi(?:file)?source|directshowsource|image(?:reader|source|sourceanim)|opendmlsource|segmented(?:avisource|directshowsource)|wavsource/.source,
+      // color
+      /coloryuv|convertbacktoyuy2|convertto(?:RGB(?:24|32|48|64)|(?:planar)?RGBA?|Y8?|YV(?:12|16|24|411)|YUVA?(?:411|420|422|444)|YUY2)|fixluminance|gr[ae]yscale|invert|levels|limiter|mergea?rgb|merge(?:chroma|luma)|rgbadjust|show(?:alpha|blue|green|red)|swapuv|tweak|[uv]toy8?|ytouv/.source,
+      // overlay
+      /(?:colorkey|reset)mask|layer|mask(?:hs)?|merge|overlay|subtract/.source,
+      // geometry
+      /addborders|(?:bicubic|bilinear|blackman|gauss|lanczos4|lanczos|point|sinc|spline(?:16|36|64))resize|crop(?:bottom)?|flip(?:horizontal|vertical)|(?:horizontal|vertical)?reduceby2|letterbox|skewrows|turn(?:180|left|right)/.source,
+      // pixel
+      /blur|fixbrokenchromaupsampling|generalconvolution|(?:spatial|temporal)soften|sharpen/.source,
+      // timeline
+      /trim|(?:un)?alignedsplice|(?:assume|assumescaled|change|convert)FPS|(?:delete|duplicate)frame|dissolve|fade(?:in|io|out)[02]?|freezeframe|interleave|loop|reverse|select(?:even|odd|(?:range)?every)/.source,
+      // interlace
+      /assume[bt]ff|assume(?:field|frame)based|bob|complementparity|doubleweave|peculiarblend|pulldown|separate(?:columns|fields|rows)|swapfields|weave(?:columns|rows)?/.source,
+      // audio
+      /amplify(?:db)?|assumesamplerate|audiodub(?:ex)?|audiotrim|convertaudioto(?:(?:8|16|24|32)bit|float)|converttomono|delayaudio|ensurevbrmp3sync|get(?:left|right)?channel|kill(?:audio|video)|mergechannels|mixaudio|monotostereo|normalize|resampleaudio|ssrc|supereq|timestretch/.source,
+      // conditional
+      /animate|applyrange|conditional(?:filter|reader|select)|frameevaluate|scriptclip|tcp(?:server|source)|writefile(?:end|if|start)?/.source,
+      // export
+      /imagewriter/.source,
+      // debug
+      /blackness|blankclip|colorbars(?:hd)?|compare|dumpfiltergraph|echo|histogram|info|messageclip|preroll|setgraphanalysis|show(?:framenumber|smpte|time)|showfiveversions|stack(?:horizontal|vertical)|subtitle|tone|version/.source
+    ].join("|");
+    var allinternals = [internals, properties, filters].join("|");
+    Prism2.languages.avisynth = {
+      comment: [
+        {
+          // Matches [* *] nestable block comments, but only supports 1 level of nested comments
+          // /\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|<self>)*\*\]/
+          pattern: /(^|[^\\])\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|\[\*(?:[^\[*]|\[(?!\*)|\*(?!\]))*\*\])*\*\]/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          // Matches /* */ block comments
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          // Matches # comments
+          pattern: /(^|[^\\$])#.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      // Handle before strings because optional arguments are surrounded by double quotes
+      argument: {
+        pattern: re(/\b(?:<<0>>)\s+("?)\w+\1/.source, [types], "i"),
+        inside: {
+          keyword: /^\w+/
+        }
+      },
+      // Optional argument assignment
+      "argument-label": {
+        pattern: /([,(][\s\\]*)\w+\s*=(?!=)/,
+        lookbehind: true,
+        inside: {
+          "argument-name": {
+            pattern: /^\w+/,
+            alias: "punctuation"
+          },
+          punctuation: /=$/
+        }
+      },
+      string: [
+        {
+          // triple double-quoted
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true
+        },
+        {
+          // single double-quoted
+          pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+          greedy: true,
+          inside: {
+            constant: {
+              // These *are* case-sensitive!
+              pattern: /\b(?:DEFAULT_MT_MODE|(?:MAINSCRIPT|PROGRAM|SCRIPT)DIR|(?:MACHINE|USER)_(?:CLASSIC|PLUS)_PLUGINS)\b/
+            }
+          }
+        }
+      ],
+      // The special "last" variable that takes the value of the last implicitly returned clip
+      variable: /\b(?:last)\b/i,
+      boolean: /\b(?:false|no|true|yes)\b/i,
+      keyword: /\b(?:catch|else|for|function|global|if|return|try|while|__END__)\b/i,
+      constant: /\bMT_(?:MULTI_INSTANCE|NICE_FILTER|SERIALIZED|SPECIAL_MT)\b/,
+      // AviSynth's internal functions, filters, and properties
+      "builtin-function": {
+        pattern: re(/\b(?:<<0>>)\b/.source, [allinternals], "i"),
+        alias: "function"
+      },
+      "type-cast": {
+        pattern: re(/\b(?:<<0>>)(?=\s*\()/.source, [types], "i"),
+        alias: "keyword"
+      },
+      // External/user-defined filters
+      function: {
+        pattern: /\b[a-z_]\w*(?=\s*\()|(\.)[a-z_]\w*\b/i,
+        lookbehind: true
+      },
+      // Matches a \ as the first or last character on a line
+      "line-continuation": {
+        pattern: /(^[ \t]*)\\|\\(?=[ \t]*$)/m,
+        lookbehind: true,
+        alias: "punctuation"
+      },
+      number: /\B\$(?:[\da-f]{6}|[\da-f]{8})\b|(?:(?:\b|\B-)\d+(?:\.\d*)?\b|\B\.\d+\b)/i,
+      operator: /\+\+?|[!=<>]=?|&&|\|\||[?:*/%-]/,
+      punctuation: /[{}\[\]();,.]/
+    };
+    Prism2.languages.avs = Prism2.languages.avisynth;
+  })(Prism);
+}
+
+export {
+  avisynth
+};