@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-NW4X76P6.mjs

@@ -0,0 +1,28 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cil.js
+cil.displayName = "cil";
+cil.aliases = [];
+function cil(Prism) {
+  Prism.languages.cil = {
+    comment: /\/\/.*/,
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    directive: {
+      pattern: /(^|\W)\.[a-z]+(?=\s)/,
+      lookbehind: true,
+      alias: "class-name"
+    },
+    // Actually an assembly reference
+    variable: /\[[\w\.]+\]/,
+    keyword: /\b(?:abstract|ansi|assembly|auto|autochar|beforefieldinit|bool|bstr|byvalstr|catch|char|cil|class|currency|date|decimal|default|enum|error|explicit|extends|extern|famandassem|family|famorassem|final(?:ly)?|float32|float64|hidebysig|u?int(?:8|16|32|64)?|iant|idispatch|implements|import|initonly|instance|interface|iunknown|literal|lpstr|lpstruct|lptstr|lpwstr|managed|method|native(?:Type)?|nested|newslot|object(?:ref)?|pinvokeimpl|private|privatescope|public|reqsecobj|rtspecialname|runtime|sealed|sequential|serializable|specialname|static|string|struct|syschar|tbstr|unicode|unmanagedexp|unsigned|value(?:type)?|variant|virtual|void)\b/,
+    function: /\b(?:(?:constrained|no|readonly|tail|unaligned|volatile)\.)?(?:conv\.(?:[iu][1248]?|ovf\.[iu][1248]?(?:\.un)?|r\.un|r4|r8)|ldc\.(?:i4(?:\.\d+|\.[mM]1|\.s)?|i8|r4|r8)|ldelem(?:\.[iu][1248]?|\.r[48]|\.ref|a)?|ldind\.(?:[iu][1248]?|r[48]|ref)|stelem\.?(?:i[1248]?|r[48]|ref)?|stind\.(?:i[1248]?|r[48]|ref)?|end(?:fault|filter|finally)|ldarg(?:\.[0-3s]|a(?:\.s)?)?|ldloc(?:\.\d+|\.s)?|sub(?:\.ovf(?:\.un)?)?|mul(?:\.ovf(?:\.un)?)?|add(?:\.ovf(?:\.un)?)?|stloc(?:\.[0-3s])?|refany(?:type|val)|blt(?:\.un)?(?:\.s)?|ble(?:\.un)?(?:\.s)?|bgt(?:\.un)?(?:\.s)?|bge(?:\.un)?(?:\.s)?|unbox(?:\.any)?|init(?:blk|obj)|call(?:i|virt)?|brfalse(?:\.s)?|bne\.un(?:\.s)?|ldloca(?:\.s)?|brzero(?:\.s)?|brtrue(?:\.s)?|brnull(?:\.s)?|brinst(?:\.s)?|starg(?:\.s)?|leave(?:\.s)?|shr(?:\.un)?|rem(?:\.un)?|div(?:\.un)?|clt(?:\.un)?|alignment|castclass|ldvirtftn|beq(?:\.s)?|ckfinite|ldsflda|ldtoken|localloc|mkrefany|rethrow|cgt\.un|arglist|switch|stsfld|sizeof|newobj|newarr|ldsfld|ldnull|ldflda|isinst|throw|stobj|stfld|ldstr|ldobj|ldlen|ldftn|ldfld|cpobj|cpblk|break|br\.s|xor|shl|ret|pop|not|nop|neg|jmp|dup|cgt|ceq|box|and|or|br)\b/,
+    boolean: /\b(?:false|true)\b/,
+    number: /\b-?(?:0x[0-9a-f]+|\d+)(?:\.[0-9a-f]+)?\b/i,
+    punctuation: /[{}[\];(),:=]|IL_[0-9A-Za-z]+/
+  };
+}
+
+export {
+  cil
+};

package/dist/chunk-NWYU6IMK.mjs

@@ -0,0 +1,58 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/aql.js
+aql.displayName = "aql";
+aql.aliases = [];
+function aql(Prism) {
+  Prism.languages.aql = {
+    comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+    property: {
+      pattern: /([{,]\s*)(?:(?!\d)\w+|(["'´`])(?:(?!\2)[^\\\r\n]|\\.)*\2)(?=\s*:)/,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
+      greedy: true
+    },
+    identifier: {
+      pattern: /([´`])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
+      greedy: true
+    },
+    variable: /@@?\w+/,
+    keyword: [
+      {
+        pattern: /(\bWITH\s+)COUNT(?=\s+INTO\b)/i,
+        lookbehind: true
+      },
+      /\b(?:AGGREGATE|ALL|AND|ANY|ASC|COLLECT|DESC|DISTINCT|FILTER|FOR|GRAPH|IN|INBOUND|INSERT|INTO|K_PATHS|K_SHORTEST_PATHS|LET|LIKE|LIMIT|NONE|NOT|NULL|OR|OUTBOUND|REMOVE|REPLACE|RETURN|SHORTEST_PATH|SORT|UPDATE|UPSERT|WINDOW|WITH)\b/i,
+      // pseudo keywords get a lookbehind to avoid false positives
+      {
+        pattern: /(^|[^\w.[])(?:KEEP|PRUNE|SEARCH|TO)\b/i,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^\w.[])(?:CURRENT|NEW|OLD)\b/,
+        lookbehind: true
+      },
+      {
+        pattern: /\bOPTIONS(?=\s*\{)/i
+      }
+    ],
+    function: /\b(?!\d)\w+(?=\s*\()/,
+    boolean: /\b(?:false|true)\b/i,
+    range: {
+      pattern: /\.\./,
+      alias: "operator"
+    },
+    number: [
+      /\b0b[01]+/i,
+      /\b0x[0-9a-f]+/i,
+      /(?:\B\.\d+|\b(?:0|[1-9]\d*)(?:\.\d+)?)(?:e[+-]?\d+)?/i
+    ],
+    operator: /\*{2,}|[=!]~|[!=<>]=?|&&|\|\||[-+*/%]/,
+    punctuation: /::|[?.:,;()[\]{}]/
+  };
+}
+
+export {
+  aql
+};

package/dist/chunk-O62YTD3V.mjs

@@ -0,0 +1,60 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/abap.js
+abap.displayName = "abap";
+abap.aliases = [];
+function abap(Prism) {
+  Prism.languages.abap = {
+    comment: /^\*.*/m,
+    string: /(`|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+    "string-template": {
+      pattern: /([|}])(?:\\.|[^\\|{\r\n])*(?=[|{])/,
+      lookbehind: true,
+      alias: "string"
+    },
+    /* End Of Line comments should not interfere with strings when the
+    quote character occurs within them. We assume a string being highlighted
+    inside an EOL comment is more acceptable than the opposite.
+    */
+    "eol-comment": {
+      pattern: /(^|\s)".*/m,
+      lookbehind: true,
+      alias: "comment"
+    },
+    keyword: {
+      pattern: /(\s|\.|^)(?:\*-INPUT|\?TO|ABAP-SOURCE|ABBREVIATED|ABS|ABSTRACT|ACCEPT|ACCEPTING|ACCESSPOLICY|ACCORDING|ACOS|ACTIVATION|ACTUAL|ADD|ADD-CORRESPONDING|ADJACENT|AFTER|ALIAS|ALIASES|ALIGN|ALL|ALLOCATE|ALPHA|ANALYSIS|ANALYZER|AND|ANY|APPEND|APPENDAGE|APPENDING|APPLICATION|ARCHIVE|AREA|ARITHMETIC|AS|ASCENDING|ASIN|ASPECT|ASSERT|ASSIGN|ASSIGNED|ASSIGNING|ASSOCIATION|ASYNCHRONOUS|AT|ATAN|ATTRIBUTES|AUTHORITY|AUTHORITY-CHECK|AVG|BACK|BACKGROUND|BACKUP|BACKWARD|BADI|BASE|BEFORE|BEGIN|BETWEEN|BIG|BINARY|BINDING|BIT|BIT-AND|BIT-NOT|BIT-OR|BIT-XOR|BLACK|BLANK|BLANKS|BLOB|BLOCK|BLOCKS|BLUE|BOUND|BOUNDARIES|BOUNDS|BOXED|BREAK-POINT|BT|BUFFER|BY|BYPASSING|BYTE|BYTE-CA|BYTE-CN|BYTE-CO|BYTE-CS|BYTE-NA|BYTE-NS|BYTE-ORDER|C|CA|CALL|CALLING|CASE|CAST|CASTING|CATCH|CEIL|CENTER|CENTERED|CHAIN|CHAIN-INPUT|CHAIN-REQUEST|CHANGE|CHANGING|CHANNELS|CHAR-TO-HEX|CHARACTER|CHARLEN|CHECK|CHECKBOX|CIRCULAR|CI_|CLASS|CLASS-CODING|CLASS-DATA|CLASS-EVENTS|CLASS-METHODS|CLASS-POOL|CLEANUP|CLEAR|CLIENT|CLOB|CLOCK|CLOSE|CN|CNT|CO|COALESCE|CODE|CODING|COLLECT|COLOR|COLUMN|COLUMNS|COL_BACKGROUND|COL_GROUP|COL_HEADING|COL_KEY|COL_NEGATIVE|COL_NORMAL|COL_POSITIVE|COL_TOTAL|COMMENT|COMMENTS|COMMIT|COMMON|COMMUNICATION|COMPARING|COMPONENT|COMPONENTS|COMPRESSION|COMPUTE|CONCAT|CONCATENATE|COND|CONDENSE|CONDITION|CONNECT|CONNECTION|CONSTANTS|CONTEXT|CONTEXTS|CONTINUE|CONTROL|CONTROLS|CONV|CONVERSION|CONVERT|COPIES|COPY|CORRESPONDING|COS|COSH|COUNT|COUNTRY|COVER|CP|CPI|CREATE|CREATING|CRITICAL|CS|CURRENCY|CURRENCY_CONVERSION|CURRENT|CURSOR|CURSOR-SELECTION|CUSTOMER|CUSTOMER-FUNCTION|DANGEROUS|DATA|DATABASE|DATAINFO|DATASET|DATE|DAYLIGHT|DBMAXLEN|DD\/MM\/YY|DD\/MM\/YYYY|DDMMYY|DEALLOCATE|DECIMALS|DECIMAL_SHIFT|DECLARATIONS|DEEP|DEFAULT|DEFERRED|DEFINE|DEFINING|DEFINITION|DELETE|DELETING|DEMAND|DEPARTMENT|DESCENDING|DESCRIBE|DESTINATION|DETAIL|DIALOG|DIRECTORY|DISCONNECT|DISPLAY|DISPLAY-MODE|DISTANCE|DISTINCT|DIV|DIVIDE|DIVIDE-CORRESPONDING|DIVISION|DO|DUMMY|DUPLICATE|DUPLICATES|DURATION|DURING|DYNAMIC|DYNPRO|E|EACH|EDIT|EDITOR-CALL|ELSE|ELSEIF|EMPTY|ENABLED|ENABLING|ENCODING|END|END-ENHANCEMENT-SECTION|END-LINES|END-OF-DEFINITION|END-OF-FILE|END-OF-PAGE|END-OF-SELECTION|ENDAT|ENDCASE|ENDCATCH|ENDCHAIN|ENDCLASS|ENDDO|ENDENHANCEMENT|ENDEXEC|ENDFOR|ENDFORM|ENDFUNCTION|ENDIAN|ENDIF|ENDING|ENDINTERFACE|ENDLOOP|ENDMETHOD|ENDMODULE|ENDON|ENDPROVIDE|ENDSELECT|ENDTRY|ENDWHILE|ENGINEERING|ENHANCEMENT|ENHANCEMENT-POINT|ENHANCEMENT-SECTION|ENHANCEMENTS|ENTRIES|ENTRY|ENVIRONMENT|EQ|EQUAL|EQUIV|ERRORMESSAGE|ERRORS|ESCAPE|ESCAPING|EVENT|EVENTS|EXACT|EXCEPT|EXCEPTION|EXCEPTION-TABLE|EXCEPTIONS|EXCLUDE|EXCLUDING|EXEC|EXECUTE|EXISTS|EXIT|EXIT-COMMAND|EXP|EXPAND|EXPANDING|EXPIRATION|EXPLICIT|EXPONENT|EXPORT|EXPORTING|EXTEND|EXTENDED|EXTENSION|EXTRACT|FAIL|FETCH|FIELD|FIELD-GROUPS|FIELD-SYMBOL|FIELD-SYMBOLS|FIELDS|FILE|FILTER|FILTER-TABLE|FILTERS|FINAL|FIND|FIRST|FIRST-LINE|FIXED-POINT|FKEQ|FKGE|FLOOR|FLUSH|FONT|FOR|FORM|FORMAT|FORWARD|FOUND|FRAC|FRAME|FRAMES|FREE|FRIENDS|FROM|FUNCTION|FUNCTION-POOL|FUNCTIONALITY|FURTHER|GAPS|GE|GENERATE|GET|GIVING|GKEQ|GKGE|GLOBAL|GRANT|GREATER|GREEN|GROUP|GROUPS|GT|HANDLE|HANDLER|HARMLESS|HASHED|HAVING|HDB|HEAD-LINES|HEADER|HEADERS|HEADING|HELP-ID|HELP-REQUEST|HIDE|HIGH|HINT|HOLD|HOTSPOT|I|ICON|ID|IDENTIFICATION|IDENTIFIER|IDS|IF|IGNORE|IGNORING|IMMEDIATELY|IMPLEMENTATION|IMPLEMENTATIONS|IMPLEMENTED|IMPLICIT|IMPORT|IMPORTING|IN|INACTIVE|INCL|INCLUDE|INCLUDES|INCLUDING|INCREMENT|INDEX|INDEX-LINE|INFOTYPES|INHERITING|INIT|INITIAL|INITIALIZATION|INNER|INOUT|INPUT|INSERT|INSTANCES|INTENSIFIED|INTERFACE|INTERFACE-POOL|INTERFACES|INTERNAL|INTERVALS|INTO|INVERSE|INVERTED-DATE|IS|ISO|ITERATOR|ITNO|JOB|JOIN|KEEP|KEEPING|KERNEL|KEY|KEYS|KEYWORDS|KIND|LANGUAGE|LAST|LATE|LAYOUT|LE|LEADING|LEAVE|LEFT|LEFT-JUSTIFIED|LEFTPLUS|LEFTSPACE|LEGACY|LENGTH|LESS|LET|LEVEL|LEVELS|LIKE|LINE|LINE-COUNT|LINE-SELECTION|LINE-SIZE|LINEFEED|LINES|LIST|LIST-PROCESSING|LISTBOX|LITTLE|LLANG|LOAD|LOAD-OF-PROGRAM|LOB|LOCAL|LOCALE|LOCATOR|LOG|LOG-POINT|LOG10|LOGFILE|LOGICAL|LONG|LOOP|LOW|LOWER|LPAD|LPI|LT|M|MAIL|MAIN|MAJOR-ID|MAPPING|MARGIN|MARK|MASK|MATCH|MATCHCODE|MAX|MAXIMUM|MEDIUM|MEMBERS|MEMORY|MESH|MESSAGE|MESSAGE-ID|MESSAGES|MESSAGING|METHOD|METHODS|MIN|MINIMUM|MINOR-ID|MM\/DD\/YY|MM\/DD\/YYYY|MMDDYY|MOD|MODE|MODIF|MODIFIER|MODIFY|MODULE|MOVE|MOVE-CORRESPONDING|MULTIPLY|MULTIPLY-CORRESPONDING|NA|NAME|NAMETAB|NATIVE|NB|NE|NESTED|NESTING|NEW|NEW-LINE|NEW-PAGE|NEW-SECTION|NEXT|NO|NO-DISPLAY|NO-EXTENSION|NO-GAP|NO-GAPS|NO-GROUPING|NO-HEADING|NO-SCROLLING|NO-SIGN|NO-TITLE|NO-TOPOFPAGE|NO-ZERO|NODE|NODES|NON-UNICODE|NON-UNIQUE|NOT|NP|NS|NULL|NUMBER|NUMOFCHAR|O|OBJECT|OBJECTS|OBLIGATORY|OCCURRENCE|OCCURRENCES|OCCURS|OF|OFF|OFFSET|OLE|ON|ONLY|OPEN|OPTION|OPTIONAL|OPTIONS|OR|ORDER|OTHER|OTHERS|OUT|OUTER|OUTPUT|OUTPUT-LENGTH|OVERFLOW|OVERLAY|PACK|PACKAGE|PAD|PADDING|PAGE|PAGES|PARAMETER|PARAMETER-TABLE|PARAMETERS|PART|PARTIALLY|PATTERN|PERCENTAGE|PERFORM|PERFORMING|PERSON|PF|PF-STATUS|PINK|PLACES|POOL|POSITION|POS_HIGH|POS_LOW|PRAGMAS|PRECOMPILED|PREFERRED|PRESERVING|PRIMARY|PRINT|PRINT-CONTROL|PRIORITY|PRIVATE|PROCEDURE|PROCESS|PROGRAM|PROPERTY|PROTECTED|PROVIDE|PUBLIC|PUSHBUTTON|PUT|QUEUE-ONLY|QUICKINFO|RADIOBUTTON|RAISE|RAISING|RANGE|RANGES|RAW|READ|READ-ONLY|READER|RECEIVE|RECEIVED|RECEIVER|RECEIVING|RED|REDEFINITION|REDUCE|REDUCED|REF|REFERENCE|REFRESH|REGEX|REJECT|REMOTE|RENAMING|REPLACE|REPLACEMENT|REPLACING|REPORT|REQUEST|REQUESTED|RESERVE|RESET|RESOLUTION|RESPECTING|RESPONSIBLE|RESULT|RESULTS|RESUMABLE|RESUME|RETRY|RETURN|RETURNCODE|RETURNING|RIGHT|RIGHT-JUSTIFIED|RIGHTPLUS|RIGHTSPACE|RISK|RMC_COMMUNICATION_FAILURE|RMC_INVALID_STATUS|RMC_SYSTEM_FAILURE|ROLE|ROLLBACK|ROUND|ROWS|RTTI|RUN|SAP|SAP-SPOOL|SAVING|SCALE_PRESERVING|SCALE_PRESERVING_SCIENTIFIC|SCAN|SCIENTIFIC|SCIENTIFIC_WITH_LEADING_ZERO|SCREEN|SCROLL|SCROLL-BOUNDARY|SCROLLING|SEARCH|SECONDARY|SECONDS|SECTION|SELECT|SELECT-OPTIONS|SELECTION|SELECTION-SCREEN|SELECTION-SET|SELECTION-SETS|SELECTION-TABLE|SELECTIONS|SELECTOR|SEND|SEPARATE|SEPARATED|SET|SHARED|SHIFT|SHORT|SHORTDUMP-ID|SIGN|SIGN_AS_POSTFIX|SIMPLE|SIN|SINGLE|SINH|SIZE|SKIP|SKIPPING|SMART|SOME|SORT|SORTABLE|SORTED|SOURCE|SPACE|SPECIFIED|SPLIT|SPOOL|SPOTS|SQL|SQLSCRIPT|SQRT|STABLE|STAMP|STANDARD|START-OF-SELECTION|STARTING|STATE|STATEMENT|STATEMENTS|STATIC|STATICS|STATUSINFO|STEP-LOOP|STOP|STRLEN|STRUCTURE|STRUCTURES|STYLE|SUBKEY|SUBMATCHES|SUBMIT|SUBROUTINE|SUBSCREEN|SUBSTRING|SUBTRACT|SUBTRACT-CORRESPONDING|SUFFIX|SUM|SUMMARY|SUMMING|SUPPLIED|SUPPLY|SUPPRESS|SWITCH|SWITCHSTATES|SYMBOL|SYNCPOINTS|SYNTAX|SYNTAX-CHECK|SYNTAX-TRACE|SYSTEM-CALL|SYSTEM-EXCEPTIONS|SYSTEM-EXIT|TAB|TABBED|TABLE|TABLES|TABLEVIEW|TABSTRIP|TAN|TANH|TARGET|TASK|TASKS|TEST|TESTING|TEXT|TEXTPOOL|THEN|THROW|TIME|TIMES|TIMESTAMP|TIMEZONE|TITLE|TITLE-LINES|TITLEBAR|TO|TOKENIZATION|TOKENS|TOP-LINES|TOP-OF-PAGE|TRACE-FILE|TRACE-TABLE|TRAILING|TRANSACTION|TRANSFER|TRANSFORMATION|TRANSLATE|TRANSPORTING|TRMAC|TRUNC|TRUNCATE|TRUNCATION|TRY|TYPE|TYPE-POOL|TYPE-POOLS|TYPES|ULINE|UNASSIGN|UNDER|UNICODE|UNION|UNIQUE|UNIT|UNIT_CONVERSION|UNIX|UNPACK|UNTIL|UNWIND|UP|UPDATE|UPPER|USER|USER-COMMAND|USING|UTF-8|VALID|VALUE|VALUE-REQUEST|VALUES|VARY|VARYING|VERIFICATION-MESSAGE|VERSION|VIA|VIEW|VISIBLE|WAIT|WARNING|WHEN|WHENEVER|WHERE|WHILE|WIDTH|WINDOW|WINDOWS|WITH|WITH-HEADING|WITH-TITLE|WITHOUT|WORD|WORK|WRITE|WRITER|X|XML|XOR|XSD|XSTRLEN|YELLOW|YES|YYMMDD|Z|ZERO|ZONE)(?![\w-])/i,
+      lookbehind: true
+    },
+    /* Numbers can be only integers. Decimal or Hex appear only as strings */
+    number: /\b\d+\b/,
+    /* Operators must always be surrounded by whitespace, they cannot be put
+    adjacent to operands.
+    */
+    operator: {
+      pattern: /(\s)(?:\*\*?|<[=>]?|>=?|\?=|[-+\/=])(?=\s)/,
+      lookbehind: true
+    },
+    "string-operator": {
+      pattern: /(\s)&&?(?=\s)/,
+      lookbehind: true,
+      /* The official editor highlights */
+      alias: "keyword"
+    },
+    "token-operator": [
+      {
+        /* Special operators used to access structure components, class methods/attributes, etc. */
+        pattern: /(\w)(?:->?|=>|[~|{}])(?=\w)/,
+        lookbehind: true,
+        alias: "punctuation"
+      },
+      {
+        /* Special tokens used do delimit string templates */
+        pattern: /[|{}]/,
+        alias: "punctuation"
+      }
+    ],
+    punctuation: /[,.:()]/
+  };
+}
+
+export {
+  abap
+};

package/dist/chunk-OACTYOAR.mjs

@@ -0,0 +1,105 @@
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/soy.js
+soy.displayName = "soy";
+soy.aliases = [];
+function soy(Prism) {
+  Prism.register(markupTemplating);
+  (function(Prism2) {
+    var stringPattern = /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+    var numberPattern = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-F]+\b/;
+    Prism2.languages.soy = {
+      comment: [
+        /\/\*[\s\S]*?\*\//,
+        {
+          pattern: /(\s)\/\/.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      "command-arg": {
+        pattern: /(\{+\/?\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\s+)\.?[\w.]+/,
+        lookbehind: true,
+        alias: "string",
+        inside: {
+          punctuation: /\./
+        }
+      },
+      parameter: {
+        pattern: /(\{+\/?\s*@?param\??\s+)\.?[\w.]+/,
+        lookbehind: true,
+        alias: "variable"
+      },
+      keyword: [
+        {
+          pattern: /(\{+\/?[^\S\r\n]*)(?:\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\??|rb|sp|switch|template|xid)/,
+          lookbehind: true
+        },
+        /\b(?:any|as|attributes|bool|css|float|html|in|int|js|list|map|null|number|string|uri)\b/
+      ],
+      delimiter: {
+        pattern: /^\{+\/?|\/?\}+$/,
+        alias: "punctuation"
+      },
+      property: /\w+(?==)/,
+      variable: {
+        pattern: /\$[^\W\d]\w*(?:\??(?:\.\w+|\[[^\]]+\]))*/,
+        inside: {
+          string: {
+            pattern: stringPattern,
+            greedy: true
+          },
+          number: numberPattern,
+          punctuation: /[\[\].?]/
+        }
+      },
+      string: {
+        pattern: stringPattern,
+        greedy: true
+      },
+      function: [
+        /\w+(?=\()/,
+        {
+          pattern: /(\|[^\S\r\n]*)\w+/,
+          lookbehind: true
+        }
+      ],
+      boolean: /\b(?:false|true)\b/,
+      number: numberPattern,
+      operator: /\?:?|<=?|>=?|==?|!=|[+*/%-]|\b(?:and|not|or)\b/,
+      punctuation: /[{}()\[\]|.,:]/
+    };
+    Prism2.hooks.add("before-tokenize", function(env) {
+      var soyPattern = /\{\{.+?\}\}|\{.+?\}|\s\/\/.*|\/\*[\s\S]*?\*\//g;
+      var soyLitteralStart = "{literal}";
+      var soyLitteralEnd = "{/literal}";
+      var soyLitteralMode = false;
+      Prism2.languages["markup-templating"].buildPlaceholders(
+        env,
+        "soy",
+        soyPattern,
+        function(match) {
+          if (match === soyLitteralEnd) {
+            soyLitteralMode = false;
+          }
+          if (!soyLitteralMode) {
+            if (match === soyLitteralStart) {
+              soyLitteralMode = true;
+            }
+            return true;
+          }
+          return false;
+        }
+      );
+    });
+    Prism2.hooks.add("after-tokenize", function(env) {
+      Prism2.languages["markup-templating"].tokenizePlaceholders(env, "soy");
+    });
+  })(Prism);
+}
+
+export {
+  soy
+};

package/dist/chunk-OADFIOVW.mjs

@@ -0,0 +1,65 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/systemd.js
+systemd.displayName = "systemd";
+systemd.aliases = [];
+function systemd(Prism) {
+  ;
+  (function(Prism2) {
+    var comment = {
+      pattern: /^[;#].*/m,
+      greedy: true
+    };
+    var quotesSource = /"(?:[^\r\n"\\]|\\(?:[^\r]|\r\n?))*"(?!\S)/.source;
+    Prism2.languages.systemd = {
+      comment,
+      section: {
+        pattern: /^\[[^\n\r\[\]]*\](?=[ \t]*$)/m,
+        greedy: true,
+        inside: {
+          punctuation: /^\[|\]$/,
+          "section-name": {
+            pattern: /[\s\S]+/,
+            alias: "selector"
+          }
+        }
+      },
+      key: {
+        pattern: /^[^\s=]+(?=[ \t]*=)/m,
+        greedy: true,
+        alias: "attr-name"
+      },
+      value: {
+        // This pattern is quite complex because of two properties:
+        //  1) Quotes (strings) must be preceded by a space. Since we can't use lookbehinds, we have to "resolve"
+        //     the lookbehind. You will see this in the main loop where spaces are handled separately.
+        //  2) Line continuations.
+        //     After line continuations, empty lines and comments are ignored so we have to consume them.
+        pattern: RegExp(
+          /(=[ \t]*(?!\s))/.source + // the value either starts with quotes or not
+          "(?:" + quotesSource + '|(?=[^"\r\n]))(?:' + (/[^\s\\]/.source + // handle spaces separately because of quotes
+          '|[ 	]+(?:(?![ 	"])|' + quotesSource + ")|" + /\\[\r\n]+(?:[#;].*[\r\n]+)*(?![#;])/.source) + ")*"
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "attr-value",
+        inside: {
+          comment,
+          quoted: {
+            pattern: RegExp(/(^|\s)/.source + quotesSource),
+            lookbehind: true,
+            greedy: true
+          },
+          punctuation: /\\$/m,
+          boolean: {
+            pattern: /^(?:false|no|off|on|true|yes)$/,
+            greedy: true
+          }
+        }
+      },
+      punctuation: /=/
+    };
+  })(Prism);
+}
+
+export {
+  systemd
+};

package/dist/chunk-ODOTE7HV.mjs

@@ -0,0 +1,31 @@
+import {
+  haskell
+} from "./chunk-IZR4QWR2.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/idris.js
+idris.displayName = "idris";
+idris.aliases = ["idr"];
+function idris(Prism) {
+  Prism.register(haskell);
+  Prism.languages.idris = Prism.languages.extend("haskell", {
+    comment: {
+      pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m
+    },
+    keyword: /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,
+    builtin: void 0
+  });
+  Prism.languages.insertBefore("idris", "keyword", {
+    "import-statement": {
+      pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,
+      lookbehind: true,
+      inside: {
+        punctuation: /\./
+      }
+    }
+  });
+  Prism.languages.idr = Prism.languages.idris;
+}
+
+export {
+  idris
+};

package/dist/chunk-OJ2CWGDX.mjs

@@ -0,0 +1,234 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/js-templates.js
+jsTemplates.displayName = "js-templates";
+jsTemplates.aliases = [];
+function jsTemplates(Prism) {
+  Prism.register(javascript);
+  (function(Prism2) {
+    var templateString = Prism2.languages.javascript["template-string"];
+    var templateLiteralPattern = templateString.pattern.source;
+    var interpolationObject = templateString.inside["interpolation"];
+    var interpolationPunctuationObject = interpolationObject.inside["interpolation-punctuation"];
+    var interpolationPattern = interpolationObject.pattern.source;
+    function createTemplate(language, tag) {
+      if (!Prism2.languages[language]) {
+        return void 0;
+      }
+      return {
+        pattern: RegExp("((?:" + tag + ")\\s*)" + templateLiteralPattern),
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          "template-punctuation": {
+            pattern: /^`|`$/,
+            alias: "string"
+          },
+          "embedded-code": {
+            pattern: /[\s\S]+/,
+            alias: language
+          }
+        }
+      };
+    }
+    Prism2.languages.javascript["template-string"] = [
+      // styled-jsx:
+      //   css`a { color: #25F; }`
+      // styled-components:
+      //   styled.h1`color: red;`
+      createTemplate(
+        "css",
+        /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source
+      ),
+      // html`<p></p>`
+      // div.innerHTML = `<p></p>`
+      createTemplate("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source),
+      // svg`<path fill="#fff" d="M55.37 ..."/>`
+      createTemplate("svg", /\bsvg/.source),
+      // md`# h1`, markdown`## h2`
+      createTemplate("markdown", /\b(?:markdown|md)/.source),
+      // gql`...`, graphql`...`, graphql.experimental`...`
+      createTemplate(
+        "graphql",
+        /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source
+      ),
+      // sql`...`
+      createTemplate("sql", /\bsql/.source),
+      // vanilla template string
+      templateString
+    ].filter(Boolean);
+    function getPlaceholder(counter, language) {
+      return "___" + language.toUpperCase() + "_" + counter + "___";
+    }
+    function tokenizeWithHooks(code, grammar, language) {
+      var env = {
+        code,
+        grammar,
+        language
+      };
+      Prism2.hooks.run("before-tokenize", env);
+      env.tokens = Prism2.tokenize(env.code, env.grammar);
+      Prism2.hooks.run("after-tokenize", env);
+      return env.tokens;
+    }
+    function tokenizeInterpolationExpression(expression) {
+      var tempGrammar = {};
+      tempGrammar["interpolation-punctuation"] = interpolationPunctuationObject;
+      var tokens = Prism2.tokenize(expression, tempGrammar);
+      if (tokens.length === 3) {
+        var args = [1, 1];
+        args.push.apply(
+          args,
+          tokenizeWithHooks(tokens[1], Prism2.languages.javascript, "javascript")
+        );
+        tokens.splice.apply(tokens, args);
+      }
+      return new Prism2.Token(
+        "interpolation",
+        tokens,
+        interpolationObject.alias,
+        expression
+      );
+    }
+    function tokenizeEmbedded(code, grammar, language) {
+      var _tokens = Prism2.tokenize(code, {
+        interpolation: {
+          pattern: RegExp(interpolationPattern),
+          lookbehind: true
+        }
+      });
+      var placeholderCounter = 0;
+      var placeholderMap = {};
+      var embeddedCode = _tokens.map(function(token) {
+        if (typeof token === "string") {
+          return token;
+        } else {
+          var interpolationExpression = token.content;
+          var placeholder;
+          while (code.indexOf(
+            placeholder = getPlaceholder(placeholderCounter++, language)
+          ) !== -1) {
+          }
+          placeholderMap[placeholder] = interpolationExpression;
+          return placeholder;
+        }
+      }).join("");
+      var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language);
+      var placeholders = Object.keys(placeholderMap);
+      placeholderCounter = 0;
+      function walkTokens(tokens) {
+        for (var i = 0; i < tokens.length; i++) {
+          if (placeholderCounter >= placeholders.length) {
+            return;
+          }
+          var token = tokens[i];
+          if (typeof token === "string" || typeof token.content === "string") {
+            var placeholder = placeholders[placeholderCounter];
+            var s = typeof token === "string" ? token : (
+              /** @type {string} */
+              token.content
+            );
+            var index = s.indexOf(placeholder);
+            if (index !== -1) {
+              ++placeholderCounter;
+              var before = s.substring(0, index);
+              var middle = tokenizeInterpolationExpression(
+                placeholderMap[placeholder]
+              );
+              var after = s.substring(index + placeholder.length);
+              var replacement = [];
+              if (before) {
+                replacement.push(before);
+              }
+              replacement.push(middle);
+              if (after) {
+                var afterTokens = [after];
+                walkTokens(afterTokens);
+                replacement.push.apply(replacement, afterTokens);
+              }
+              if (typeof token === "string") {
+                tokens.splice.apply(tokens, [i, 1].concat(replacement));
+                i += replacement.length - 1;
+              } else {
+                token.content = replacement;
+              }
+            }
+          } else {
+            var content = token.content;
+            if (Array.isArray(content)) {
+              walkTokens(content);
+            } else {
+              walkTokens([content]);
+            }
+          }
+        }
+      }
+      walkTokens(embeddedTokens);
+      return new Prism2.Token(
+        language,
+        embeddedTokens,
+        "language-" + language,
+        code
+      );
+    }
+    var supportedLanguages = {
+      javascript: true,
+      js: true,
+      typescript: true,
+      ts: true,
+      jsx: true,
+      tsx: true
+    };
+    Prism2.hooks.add("after-tokenize", function(env) {
+      if (!(env.language in supportedLanguages)) {
+        return;
+      }
+      function findTemplateStrings(tokens) {
+        for (var i = 0, l = tokens.length; i < l; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            continue;
+          }
+          var content = token.content;
+          if (!Array.isArray(content)) {
+            if (typeof content !== "string") {
+              findTemplateStrings([content]);
+            }
+            continue;
+          }
+          if (token.type === "template-string") {
+            var embedded = content[1];
+            if (content.length === 3 && typeof embedded !== "string" && embedded.type === "embedded-code") {
+              var code = stringContent(embedded);
+              var alias = embedded.alias;
+              var language = Array.isArray(alias) ? alias[0] : alias;
+              var grammar = Prism2.languages[language];
+              if (!grammar) {
+                continue;
+              }
+              content[1] = tokenizeEmbedded(code, grammar, language);
+            }
+          } else {
+            findTemplateStrings(content);
+          }
+        }
+      }
+      findTemplateStrings(env.tokens);
+    });
+    function stringContent(value) {
+      if (typeof value === "string") {
+        return value;
+      } else if (Array.isArray(value)) {
+        return value.map(stringContent).join("");
+      } else {
+        return stringContent(value.content);
+      }
+    }
+  })(Prism);
+}
+
+export {
+  jsTemplates
+};

package/dist/chunk-OKRAGSKZ.mjs

@@ -0,0 +1,31 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/r.js
+r.displayName = "r";
+r.aliases = [];
+function r(Prism) {
+  Prism.languages.r = {
+    comment: /#.*/,
+    string: {
+      pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    "percent-operator": {
+      // Includes user-defined operators
+      // and %%, %*%, %/%, %in%, %o%, %x%
+      pattern: /%[^%\s]*%/,
+      alias: "operator"
+    },
+    boolean: /\b(?:FALSE|TRUE)\b/,
+    ellipsis: /\.\.(?:\.|\d+)/,
+    number: [
+      /\b(?:Inf|NaN)\b/,
+      /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/
+    ],
+    keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+    operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
+    punctuation: /[(){}\[\],;]/
+  };
+}
+
+export {
+  r
+};

package/dist/chunk-OOK6CL5S.mjs

@@ -0,0 +1,50 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsstacktrace.js
+jsstacktrace.displayName = "jsstacktrace";
+jsstacktrace.aliases = [];
+function jsstacktrace(Prism) {
+  Prism.languages.jsstacktrace = {
+    "error-message": {
+      pattern: /^\S.*/m,
+      alias: "string"
+    },
+    "stack-frame": {
+      pattern: /(^[ \t]+)at[ \t].*/m,
+      lookbehind: true,
+      inside: {
+        "not-my-code": {
+          pattern: /^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m,
+          alias: "comment"
+        },
+        filename: {
+          pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
+          lookbehind: true,
+          alias: "url"
+        },
+        function: {
+          pattern: /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
+          lookbehind: true,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        punctuation: /[()]/,
+        keyword: /\b(?:at|new)\b/,
+        alias: {
+          pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
+          alias: "variable"
+        },
+        "line-number": {
+          pattern: /:\d+(?::\d+)?\b/,
+          alias: "number",
+          inside: {
+            punctuation: /:/
+          }
+        }
+      }
+    }
+  };
+}
+
+export {
+  jsstacktrace
+};