@tamagui/code-to-html 1.1.8 → 1.1.10

package/dist/esm/index.js

@@ -20,6 +20,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -130,11 +134,17 @@ var require_unicode = __commonJS({
     };
     exports.CODE_POINT_SEQUENCES = {
       DASH_DASH_STRING: [45, 45],
+      //--
       DOCTYPE_STRING: [68, 79, 67, 84, 89, 80, 69],
+      //DOCTYPE
       CDATA_START_STRING: [91, 67, 68, 65, 84, 65, 91],
+      //[CDATA[
       SCRIPT_STRING: [115, 99, 114, 105, 112, 116],
+      //script
       PUBLIC_STRING: [80, 85, 66, 76, 73, 67],
+      //PUBLIC
       SYSTEM_STRING: [83, 89, 83, 84, 69, 77]
+      //SYSTEM
     };
     exports.isSurrogate = function(cp) {
       return cp >= 55296 && cp <= 57343;
@@ -537,6 +547,7 @@ var require_tokenizer = __commonJS({
         this.currentToken = null;
         this.currentAttr = null;
       }
+      //Errors
       _err() {
       }
       _errOnNextCodePoint(err) {
@@ -544,6 +555,7 @@ var require_tokenizer = __commonJS({
         this._err(err);
         this._unconsume();
       }
+      //API
       getNextToken() {
         while (!this.tokenQueue.length && this.active) {
           this.consumedAfterSnapshot = 0;
@@ -562,6 +574,7 @@ var require_tokenizer = __commonJS({
         this.active = true;
         this.preprocessor.insertHtmlAtCurrentPos(chunk);
       }
+      //Hibernation
       _ensureHibernation() {
         if (this.preprocessor.endOfChunkHit) {
           for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) {
@@ -573,6 +586,7 @@ var require_tokenizer = __commonJS({
         }
         return false;
       }
+      //Consumption
       _consume() {
         this.consumedAfterSnapshot++;
         return this.preprocessor.advance();
@@ -614,6 +628,7 @@ var require_tokenizer = __commonJS({
         }
         return isMatch;
       }
+      //Temp buffer
       _isTempBufferEqualToScriptString() {
         if (this.tempBuff.length !== $$.SCRIPT_STRING.length) {
           return false;
@@ -625,6 +640,7 @@ var require_tokenizer = __commonJS({
         }
         return true;
       }
+      //Token creation
       _createStartTagToken() {
         this.currentToken = {
           type: Tokenizer.START_TAG_TOKEN,
@@ -666,6 +682,7 @@ var require_tokenizer = __commonJS({
       _createEOFToken() {
         this.currentToken = { type: Tokenizer.EOF_TOKEN };
       }
+      //Tag attributes
       _createAttr(attrNameFirstCh) {
         this.currentAttr = {
           name: attrNameFirstCh,
@@ -683,6 +700,7 @@ var require_tokenizer = __commonJS({
       _leaveAttrValue(toState) {
         this.state = toState;
       }
+      //Token emission
       _emitCurrentToken() {
         this._emitCurrentCharacterToken();
         const ct = this.currentToken;
@@ -709,6 +727,15 @@ var require_tokenizer = __commonJS({
         this._createEOFToken();
         this._emitCurrentToken();
       }
+      //Characters emission
+      //OPTIMIZATION: specification uses only one type of character tokens (one token per character).
+      //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
+      //If we have a sequence of characters that belong to the same group, parser can process it
+      //as a single solid character token.
+      //So, there are 3 types of character tokens in parse5:
+      //1)NULL_CHARACTER_TOKEN - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
+      //2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\n  \r\t   \f')
+      //3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
       _appendCharToCurrentCharacterToken(type, ch) {
         if (this.currentCharacterToken && this.currentCharacterToken.type !== type) {
           this._emitCurrentCharacterToken();
@@ -733,9 +760,12 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(codePoints[i]);
         }
       }
+      //NOTE: used then we emit character explicitly. This is always a non-whitespace and a non-null character.
+      //So we can avoid additional checks here.
       _emitChars(ch) {
         this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch);
       }
+      // Character reference helpers
       _matchNamedCharacterReference(startCp) {
         let result = null;
         let excess = 1;
@@ -788,6 +818,9 @@ var require_tokenizer = __commonJS({
         }
         this.tempBuff = [];
       }
+      // State machine
+      // Data state
+      //------------------------------------------------------------------
       [DATA_STATE](cp) {
         this.preprocessor.dropParsedChunk();
         if (cp === $.LESS_THAN_SIGN) {
@@ -804,6 +837,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      //  RCDATA state
+      //------------------------------------------------------------------
       [RCDATA_STATE](cp) {
         this.preprocessor.dropParsedChunk();
         if (cp === $.AMPERSAND) {
@@ -820,6 +855,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // RAWTEXT state
+      //------------------------------------------------------------------
       [RAWTEXT_STATE](cp) {
         this.preprocessor.dropParsedChunk();
         if (cp === $.LESS_THAN_SIGN) {
@@ -833,6 +870,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Script data state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_STATE](cp) {
         this.preprocessor.dropParsedChunk();
         if (cp === $.LESS_THAN_SIGN) {
@@ -846,6 +885,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // PLAINTEXT state
+      //------------------------------------------------------------------
       [PLAINTEXT_STATE](cp) {
         this.preprocessor.dropParsedChunk();
         if (cp === $.NULL) {
@@ -857,6 +898,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Tag open state
+      //------------------------------------------------------------------
       [TAG_OPEN_STATE](cp) {
         if (cp === $.EXCLAMATION_MARK) {
           this.state = MARKUP_DECLARATION_OPEN_STATE;
@@ -879,6 +922,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(DATA_STATE);
         }
       }
+      // End tag open state
+      //------------------------------------------------------------------
       [END_TAG_OPEN_STATE](cp) {
         if (isAsciiLetter(cp)) {
           this._createEndTagToken();
@@ -896,6 +941,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_COMMENT_STATE);
         }
       }
+      // Tag name state
+      //------------------------------------------------------------------
       [TAG_NAME_STATE](cp) {
         if (isWhitespace(cp)) {
           this.state = BEFORE_ATTRIBUTE_NAME_STATE;
@@ -916,6 +963,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.tagName += toChar(cp);
         }
       }
+      // RCDATA less-than sign state
+      //------------------------------------------------------------------
       [RCDATA_LESS_THAN_SIGN_STATE](cp) {
         if (cp === $.SOLIDUS) {
           this.tempBuff = [];
@@ -925,6 +974,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(RCDATA_STATE);
         }
       }
+      // RCDATA end tag open state
+      //------------------------------------------------------------------
       [RCDATA_END_TAG_OPEN_STATE](cp) {
         if (isAsciiLetter(cp)) {
           this._createEndTagToken();
@@ -934,6 +985,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(RCDATA_STATE);
         }
       }
+      // RCDATA end tag name state
+      //------------------------------------------------------------------
       [RCDATA_END_TAG_NAME_STATE](cp) {
         if (isAsciiUpper(cp)) {
           this.currentToken.tagName += toAsciiLowerChar(cp);
@@ -962,6 +1015,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(RCDATA_STATE);
         }
       }
+      // RAWTEXT less-than sign state
+      //------------------------------------------------------------------
       [RAWTEXT_LESS_THAN_SIGN_STATE](cp) {
         if (cp === $.SOLIDUS) {
           this.tempBuff = [];
@@ -971,6 +1026,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(RAWTEXT_STATE);
         }
       }
+      // RAWTEXT end tag open state
+      //------------------------------------------------------------------
       [RAWTEXT_END_TAG_OPEN_STATE](cp) {
         if (isAsciiLetter(cp)) {
           this._createEndTagToken();
@@ -980,6 +1037,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(RAWTEXT_STATE);
         }
       }
+      // RAWTEXT end tag name state
+      //------------------------------------------------------------------
       [RAWTEXT_END_TAG_NAME_STATE](cp) {
         if (isAsciiUpper(cp)) {
           this.currentToken.tagName += toAsciiLowerChar(cp);
@@ -1008,6 +1067,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(RAWTEXT_STATE);
         }
       }
+      // Script data less-than sign state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_LESS_THAN_SIGN_STATE](cp) {
         if (cp === $.SOLIDUS) {
           this.tempBuff = [];
@@ -1020,6 +1081,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_STATE);
         }
       }
+      // Script data end tag open state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_END_TAG_OPEN_STATE](cp) {
         if (isAsciiLetter(cp)) {
           this._createEndTagToken();
@@ -1029,6 +1092,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_STATE);
         }
       }
+      // Script data end tag name state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_END_TAG_NAME_STATE](cp) {
         if (isAsciiUpper(cp)) {
           this.currentToken.tagName += toAsciiLowerChar(cp);
@@ -1055,6 +1120,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_STATE);
         }
       }
+      // Script data escape start state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPE_START_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE;
@@ -1063,6 +1130,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_STATE);
         }
       }
+      // Script data escape start dash state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPE_START_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
@@ -1071,6 +1140,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_STATE);
         }
       }
+      // Script data escaped state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPED_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = SCRIPT_DATA_ESCAPED_DASH_STATE;
@@ -1087,6 +1158,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Script data escaped dash state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPED_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
@@ -1105,6 +1178,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Script data escaped dash dash state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPED_DASH_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this._emitChars("-");
@@ -1125,6 +1200,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Script data escaped less-than sign state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
         if (cp === $.SOLIDUS) {
           this.tempBuff = [];
@@ -1138,6 +1215,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
         }
       }
+      // Script data escaped end tag open state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE](cp) {
         if (isAsciiLetter(cp)) {
           this._createEndTagToken();
@@ -1147,6 +1226,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
         }
       }
+      // Script data escaped end tag name state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE](cp) {
         if (isAsciiUpper(cp)) {
           this.currentToken.tagName += toAsciiLowerChar(cp);
@@ -1175,6 +1256,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
         }
       }
+      // Script data double escape start state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE](cp) {
         if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
           this.state = this._isTempBufferEqualToScriptString() ? SCRIPT_DATA_DOUBLE_ESCAPED_STATE : SCRIPT_DATA_ESCAPED_STATE;
@@ -1189,6 +1272,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
         }
       }
+      // Script data double escaped state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_DOUBLE_ESCAPED_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE;
@@ -1206,6 +1291,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Script data double escaped dash state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE;
@@ -1225,6 +1312,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Script data double escaped dash dash state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this._emitChars("-");
@@ -1246,6 +1335,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // Script data double escaped less-than sign state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
         if (cp === $.SOLIDUS) {
           this.tempBuff = [];
@@ -1255,6 +1346,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
         }
       }
+      // Script data double escape end state
+      //------------------------------------------------------------------
       [SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE](cp) {
         if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
           this.state = this._isTempBufferEqualToScriptString() ? SCRIPT_DATA_ESCAPED_STATE : SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
@@ -1269,6 +1362,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
         }
       }
+      // Before attribute name state
+      //------------------------------------------------------------------
       [BEFORE_ATTRIBUTE_NAME_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1284,6 +1379,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(ATTRIBUTE_NAME_STATE);
         }
       }
+      // Attribute name state
+      //------------------------------------------------------------------
       [ATTRIBUTE_NAME_STATE](cp) {
         if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
           this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE);
@@ -1302,6 +1399,8 @@ var require_tokenizer = __commonJS({
           this.currentAttr.name += toChar(cp);
         }
       }
+      // After attribute name state
+      //------------------------------------------------------------------
       [AFTER_ATTRIBUTE_NAME_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1321,6 +1420,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(ATTRIBUTE_NAME_STATE);
         }
       }
+      // Before attribute value state
+      //------------------------------------------------------------------
       [BEFORE_ATTRIBUTE_VALUE_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1337,6 +1438,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE);
         }
       }
+      // Attribute value (double-quoted) state
+      //------------------------------------------------------------------
       [ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE](cp) {
         if (cp === $.QUOTATION_MARK) {
           this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
@@ -1353,6 +1456,8 @@ var require_tokenizer = __commonJS({
           this.currentAttr.value += toChar(cp);
         }
       }
+      // Attribute value (single-quoted) state
+      //------------------------------------------------------------------
       [ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE](cp) {
         if (cp === $.APOSTROPHE) {
           this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
@@ -1369,6 +1474,8 @@ var require_tokenizer = __commonJS({
           this.currentAttr.value += toChar(cp);
         }
       }
+      // Attribute value (unquoted) state
+      //------------------------------------------------------------------
       [ATTRIBUTE_VALUE_UNQUOTED_STATE](cp) {
         if (isWhitespace(cp)) {
           this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
@@ -1391,6 +1498,8 @@ var require_tokenizer = __commonJS({
           this.currentAttr.value += toChar(cp);
         }
       }
+      // After attribute value (quoted) state
+      //------------------------------------------------------------------
       [AFTER_ATTRIBUTE_VALUE_QUOTED_STATE](cp) {
         if (isWhitespace(cp)) {
           this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
@@ -1407,6 +1516,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
         }
       }
+      // Self-closing start tag state
+      //------------------------------------------------------------------
       [SELF_CLOSING_START_TAG_STATE](cp) {
         if (cp === $.GREATER_THAN_SIGN) {
           this.currentToken.selfClosing = true;
@@ -1420,6 +1531,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
         }
       }
+      // Bogus comment state
+      //------------------------------------------------------------------
       [BOGUS_COMMENT_STATE](cp) {
         if (cp === $.GREATER_THAN_SIGN) {
           this.state = DATA_STATE;
@@ -1434,6 +1547,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.data += toChar(cp);
         }
       }
+      // Markup declaration open state
+      //------------------------------------------------------------------
       [MARKUP_DECLARATION_OPEN_STATE](cp) {
         if (this._consumeSequenceIfMatch($$.DASH_DASH_STRING, cp, true)) {
           this._createCommentToken();
@@ -1455,6 +1570,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_COMMENT_STATE);
         }
       }
+      // Comment start state
+      //------------------------------------------------------------------
       [COMMENT_START_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = COMMENT_START_DASH_STATE;
@@ -1466,6 +1583,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_STATE);
         }
       }
+      // Comment start dash state
+      //------------------------------------------------------------------
       [COMMENT_START_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = COMMENT_END_STATE;
@@ -1482,6 +1601,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_STATE);
         }
       }
+      // Comment state
+      //------------------------------------------------------------------
       [COMMENT_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = COMMENT_END_DASH_STATE;
@@ -1499,6 +1620,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.data += toChar(cp);
         }
       }
+      // Comment less-than sign state
+      //------------------------------------------------------------------
       [COMMENT_LESS_THAN_SIGN_STATE](cp) {
         if (cp === $.EXCLAMATION_MARK) {
           this.currentToken.data += "!";
@@ -1509,6 +1632,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_STATE);
         }
       }
+      // Comment less-than sign bang state
+      //------------------------------------------------------------------
       [COMMENT_LESS_THAN_SIGN_BANG_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE;
@@ -1516,6 +1641,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_STATE);
         }
       }
+      // Comment less-than sign bang dash state
+      //------------------------------------------------------------------
       [COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE;
@@ -1523,12 +1650,16 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_END_DASH_STATE);
         }
       }
+      // Comment less-than sign bang dash dash state
+      //------------------------------------------------------------------
       [COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE](cp) {
         if (cp !== $.GREATER_THAN_SIGN && cp !== $.EOF) {
           this._err(ERR.nestedComment);
         }
         this._reconsumeInState(COMMENT_END_STATE);
       }
+      // Comment end dash state
+      //------------------------------------------------------------------
       [COMMENT_END_DASH_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.state = COMMENT_END_STATE;
@@ -1541,6 +1672,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_STATE);
         }
       }
+      // Comment end state
+      //------------------------------------------------------------------
       [COMMENT_END_STATE](cp) {
         if (cp === $.GREATER_THAN_SIGN) {
           this.state = DATA_STATE;
@@ -1558,6 +1691,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_STATE);
         }
       }
+      // Comment end bang state
+      //------------------------------------------------------------------
       [COMMENT_END_BANG_STATE](cp) {
         if (cp === $.HYPHEN_MINUS) {
           this.currentToken.data += "--!";
@@ -1575,6 +1710,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(COMMENT_STATE);
         }
       }
+      // DOCTYPE state
+      //------------------------------------------------------------------
       [DOCTYPE_STATE](cp) {
         if (isWhitespace(cp)) {
           this.state = BEFORE_DOCTYPE_NAME_STATE;
@@ -1591,6 +1728,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
         }
       }
+      // Before DOCTYPE name state
+      //------------------------------------------------------------------
       [BEFORE_DOCTYPE_NAME_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1619,6 +1758,8 @@ var require_tokenizer = __commonJS({
           this.state = DOCTYPE_NAME_STATE;
         }
       }
+      // DOCTYPE name state
+      //------------------------------------------------------------------
       [DOCTYPE_NAME_STATE](cp) {
         if (isWhitespace(cp)) {
           this.state = AFTER_DOCTYPE_NAME_STATE;
@@ -1639,6 +1780,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.name += toChar(cp);
         }
       }
+      // After DOCTYPE name state
+      //------------------------------------------------------------------
       [AFTER_DOCTYPE_NAME_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1661,6 +1804,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // After DOCTYPE public keyword state
+      //------------------------------------------------------------------
       [AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE](cp) {
         if (isWhitespace(cp)) {
           this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
@@ -1688,6 +1833,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // Before DOCTYPE public identifier state
+      //------------------------------------------------------------------
       [BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1714,6 +1861,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // DOCTYPE public identifier (double-quoted) state
+      //------------------------------------------------------------------
       [DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
         if (cp === $.QUOTATION_MARK) {
           this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
@@ -1734,6 +1883,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.publicId += toChar(cp);
         }
       }
+      // DOCTYPE public identifier (single-quoted) state
+      //------------------------------------------------------------------
       [DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
         if (cp === $.APOSTROPHE) {
           this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
@@ -1754,6 +1905,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.publicId += toChar(cp);
         }
       }
+      // After DOCTYPE public identifier state
+      //------------------------------------------------------------------
       [AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
         if (isWhitespace(cp)) {
           this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;
@@ -1779,6 +1932,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // Between DOCTYPE public and system identifiers state
+      //------------------------------------------------------------------
       [BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1803,6 +1958,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // After DOCTYPE system keyword state
+      //------------------------------------------------------------------
       [AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE](cp) {
         if (isWhitespace(cp)) {
           this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
@@ -1830,6 +1987,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // Before DOCTYPE system identifier state
+      //------------------------------------------------------------------
       [BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1856,6 +2015,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // DOCTYPE system identifier (double-quoted) state
+      //------------------------------------------------------------------
       [DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
         if (cp === $.QUOTATION_MARK) {
           this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
@@ -1876,6 +2037,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.systemId += toChar(cp);
         }
       }
+      // DOCTYPE system identifier (single-quoted) state
+      //------------------------------------------------------------------
       [DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
         if (cp === $.APOSTROPHE) {
           this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
@@ -1896,6 +2059,8 @@ var require_tokenizer = __commonJS({
           this.currentToken.systemId += toChar(cp);
         }
       }
+      // After DOCTYPE system identifier state
+      //------------------------------------------------------------------
       [AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
         if (isWhitespace(cp)) {
           return;
@@ -1913,6 +2078,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(BOGUS_DOCTYPE_STATE);
         }
       }
+      // Bogus DOCTYPE state
+      //------------------------------------------------------------------
       [BOGUS_DOCTYPE_STATE](cp) {
         if (cp === $.GREATER_THAN_SIGN) {
           this._emitCurrentToken();
@@ -1924,6 +2091,8 @@ var require_tokenizer = __commonJS({
           this._emitEOFToken();
         }
       }
+      // CDATA section state
+      //------------------------------------------------------------------
       [CDATA_SECTION_STATE](cp) {
         if (cp === $.RIGHT_SQUARE_BRACKET) {
           this.state = CDATA_SECTION_BRACKET_STATE;
@@ -1934,6 +2103,8 @@ var require_tokenizer = __commonJS({
           this._emitCodePoint(cp);
         }
       }
+      // CDATA section bracket state
+      //------------------------------------------------------------------
       [CDATA_SECTION_BRACKET_STATE](cp) {
         if (cp === $.RIGHT_SQUARE_BRACKET) {
           this.state = CDATA_SECTION_END_STATE;
@@ -1942,6 +2113,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(CDATA_SECTION_STATE);
         }
       }
+      // CDATA section end state
+      //------------------------------------------------------------------
       [CDATA_SECTION_END_STATE](cp) {
         if (cp === $.GREATER_THAN_SIGN) {
           this.state = DATA_STATE;
@@ -1952,6 +2125,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(CDATA_SECTION_STATE);
         }
       }
+      // Character reference state
+      //------------------------------------------------------------------
       [CHARACTER_REFERENCE_STATE](cp) {
         this.tempBuff = [$.AMPERSAND];
         if (cp === $.NUMBER_SIGN) {
@@ -1964,6 +2139,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(this.returnState);
         }
       }
+      // Named character reference state
+      //------------------------------------------------------------------
       [NAMED_CHARACTER_REFERENCE_STATE](cp) {
         const matchResult = this._matchNamedCharacterReference(cp);
         if (this._ensureHibernation()) {
@@ -1983,6 +2160,8 @@ var require_tokenizer = __commonJS({
           this.state = AMBIGUOUS_AMPERSAND_STATE;
         }
       }
+      // Ambiguos ampersand state
+      //------------------------------------------------------------------
       [AMBIGUOUS_AMPERSAND_STATE](cp) {
         if (isAsciiAlphaNumeric(cp)) {
           if (this._isCharacterReferenceInAttribute()) {
@@ -1997,6 +2176,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(this.returnState);
         }
       }
+      // Numeric character reference state
+      //------------------------------------------------------------------
       [NUMERIC_CHARACTER_REFERENCE_STATE](cp) {
         this.charRefCode = 0;
         if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {
@@ -2006,6 +2187,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_START_STATE);
         }
       }
+      // Hexademical character reference start state
+      //------------------------------------------------------------------
       [HEXADEMICAL_CHARACTER_REFERENCE_START_STATE](cp) {
         if (isAsciiHexDigit(cp)) {
           this._reconsumeInState(HEXADEMICAL_CHARACTER_REFERENCE_STATE);
@@ -2015,6 +2198,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(this.returnState);
         }
       }
+      // Decimal character reference start state
+      //------------------------------------------------------------------
       [DECIMAL_CHARACTER_REFERENCE_START_STATE](cp) {
         if (isAsciiDigit(cp)) {
           this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_STATE);
@@ -2024,6 +2209,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(this.returnState);
         }
       }
+      // Hexademical character reference state
+      //------------------------------------------------------------------
       [HEXADEMICAL_CHARACTER_REFERENCE_STATE](cp) {
         if (isAsciiUpperHexDigit(cp)) {
           this.charRefCode = this.charRefCode * 16 + cp - 55;
@@ -2038,6 +2225,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
         }
       }
+      // Decimal character reference state
+      //------------------------------------------------------------------
       [DECIMAL_CHARACTER_REFERENCE_STATE](cp) {
         if (isAsciiDigit(cp)) {
           this.charRefCode = this.charRefCode * 10 + cp - 48;
@@ -2048,6 +2237,8 @@ var require_tokenizer = __commonJS({
           this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
         }
       }
+      // Numeric character reference end state
+      //------------------------------------------------------------------
       [NUMERIC_CHARACTER_REFERENCE_END_STATE]() {
         if (this.charRefCode === $.NULL) {
           this._err(ERR.nullCharacterReference);
@@ -2441,6 +2632,7 @@ var require_open_element_stack = __commonJS({
         this.tmplCount = 0;
         this.treeAdapter = treeAdapter;
       }
+      //Index of element
       _indexOf(element4) {
         let idx = -1;
         for (let i = this.stackTop; i >= 0; i--) {
@@ -2451,6 +2643,7 @@ var require_open_element_stack = __commonJS({
         }
         return idx;
       }
+      //Update current element
       _isInTemplate() {
         return this.currentTagName === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;
       }
@@ -2459,6 +2652,7 @@ var require_open_element_stack = __commonJS({
         this.currentTagName = this.current && this.treeAdapter.getTagName(this.current);
         this.currentTmplContent = this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : null;
       }
+      //Mutations
       push(element4) {
         this.items[++this.stackTop] = element4;
         this._updateCurrentElement();
@@ -2555,6 +2749,7 @@ var require_open_element_stack = __commonJS({
           }
         }
       }
+      //Search
       tryPeekProperlyNestedBodyElement() {
         const element4 = this.items[1];
         return element4 && this.treeAdapter.getTagName(element4) === $.BODY ? element4 : null;
@@ -2569,6 +2764,7 @@ var require_open_element_stack = __commonJS({
       isRootHtmlElementCurrent() {
         return this.stackTop === 0 && this.currentTagName === $.HTML;
       }
+      //Element in scope
       hasInScope(tagName) {
         for (let i = this.stackTop; i >= 0; i--) {
           const tn = this.treeAdapter.getTagName(this.items[i]);
@@ -2669,6 +2865,7 @@ var require_open_element_stack = __commonJS({
         }
         return true;
       }
+      //Implied end tags
       generateImpliedEndTags() {
         while (isImpliedEndTagRequired(this.currentTagName)) {
           this.pop();
@@ -2701,6 +2898,9 @@ var require_formatting_element_list = __commonJS({
         this.treeAdapter = treeAdapter;
         this.bookmark = null;
       }
+      //Noah Ark's condition
+      //OPTIMIZATION: at first we try to find possible candidates for exclusion using
+      //lightweight heuristics without thorough attributes check.
       _getNoahArkConditionCandidates(newElement) {
         const candidates = [];
         if (this.length >= NOAH_ARK_CAPACITY) {
@@ -2751,6 +2951,7 @@ var require_formatting_element_list = __commonJS({
           }
         }
       }
+      //Mutations
       insertMarker() {
         this.entries.push({ type: FormattingElementList.MARKER_ENTRY });
         this.length++;
@@ -2796,6 +2997,7 @@ var require_formatting_element_list = __commonJS({
           }
         }
       }
+      //Search
       getElementEntryInScopeWithTagName(tagName) {
         for (let i = this.length - 1; i >= 0; i--) {
           const entry = this.entries[i];
@@ -3133,6 +3335,7 @@ var require_parser_mixin = __commonJS({
               mxn._setEndLocation(this.openElements.items[i], mxn.currentToken);
             }
           },
+          //Token processing
           _processTokenInForeignContent(token) {
             mxn.currentToken = token;
             orig._processTokenInForeignContent.call(this, token);
@@ -3151,6 +3354,7 @@ var require_parser_mixin = __commonJS({
               }
             }
           },
+          //Doctype
           _setDocumentType(token) {
             orig._setDocumentType.call(this, token);
             const documentChildren = this.treeAdapter.getChildNodes(this.document);
@@ -3163,6 +3367,7 @@ var require_parser_mixin = __commonJS({
               }
             }
           },
+          //Elements
           _attachElementToTree(element4) {
             mxn._setStartLocation(element4);
             mxn.lastStartTagToken = null;
@@ -3186,12 +3391,14 @@ var require_parser_mixin = __commonJS({
             orig._insertFakeRootElement.call(this);
             this.treeAdapter.setNodeSourceCodeLocation(this.openElements.current, null);
           },
+          //Comments
           _appendCommentNode(token, parent) {
             orig._appendCommentNode.call(this, token, parent);
             const children = this.treeAdapter.getChildNodes(parent);
             const commentNode = children[children.length - 1];
             this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);
           },
+          //Text
           _findFosterParentingLocation() {
             mxn.lastFosterParentingLocation = orig._findFosterParentingLocation.call(this);
             return mxn.lastFosterParentingLocation;
@@ -4228,6 +4435,7 @@ var require_parser = __commonJS({
           Mixin.install(this, ErrorReportingParserMixin, { onParseError: this.options.onParseError });
         }
       }
+      // API
       parse(html5) {
         const document2 = this.treeAdapter.createDocument();
         this._bootstrap(document2, null);
@@ -4255,6 +4463,7 @@ var require_parser = __commonJS({
         this._adoptNodes(rootElement, fragment);
         return fragment;
       }
+      //Bootstrap parser
       _bootstrap(document2, fragmentContext) {
         this.tokenizer = new Tokenizer(this.options);
         this.stopped = false;
@@ -4275,8 +4484,10 @@ var require_parser = __commonJS({
         this.skipNextNewLine = false;
         this.fosterParentingEnabled = false;
       }
+      //Errors
       _err() {
       }
+      //Parsing loop
       _runParsingLoop(scriptHandler) {
         while (!this.stopped) {
           this._setupTokenizerCDATAMode();
@@ -4311,6 +4522,7 @@ var require_parser = __commonJS({
           writeCallback();
         }
       }
+      //Text parsing
       _setupTokenizerCDATAMode() {
         const current = this._getAdjustedCurrentElement();
         this.tokenizer.allowCDATA = current && current !== this.document && this.treeAdapter.getNamespaceURI(current) !== NS.HTML && !this._isIntegrationPoint(current);
@@ -4326,6 +4538,7 @@ var require_parser = __commonJS({
         this.originalInsertionMode = IN_BODY_MODE;
         this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
       }
+      //Fragment parsing
       _getAdjustedCurrentElement() {
         return this.openElements.stackTop === 0 && this.fragmentContext ? this.fragmentContext : this.openElements.current;
       }
@@ -4353,6 +4566,7 @@ var require_parser = __commonJS({
           }
         }
       }
+      //Tree mutation
       _setDocumentType(token) {
         const name = token.name || "";
         const publicId = token.publicId || "";
@@ -4411,6 +4625,7 @@ var require_parser = __commonJS({
           this.treeAdapter.appendChild(recipient, child);
         }
       }
+      //Token processing
       _shouldProcessTokenInForeignContent(token) {
         const current = this._getAdjustedCurrentElement();
         if (!current || current === this.document) {
@@ -4464,12 +4679,14 @@ var require_parser = __commonJS({
           this._err(ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);
         }
       }
+      //Integration points
       _isIntegrationPoint(element4, foreignNS) {
         const tn = this.treeAdapter.getTagName(element4);
         const ns = this.treeAdapter.getNamespaceURI(element4);
         const attrs = this.treeAdapter.getAttrList(element4);
         return foreignContent.isIntegrationPoint(tn, ns, attrs, foreignNS);
       }
+      //Active formatting elements reconstruction
       _reconstructActiveFormattingElements() {
         const listLength = this.activeFormattingElements.length;
         if (listLength) {
@@ -4490,6 +4707,7 @@ var require_parser = __commonJS({
           }
         }
       }
+      //Close elements
       _closeTableCell() {
         this.openElements.generateImpliedEndTags();
         this.openElements.popUntilTableCellPopped();
@@ -4500,6 +4718,7 @@ var require_parser = __commonJS({
         this.openElements.generateImpliedEndTagsWithExclusion($.P);
         this.openElements.popUntilTagNamePopped($.P);
       }
+      //Insertion modes
       _resetInsertionMode() {
         for (let i = this.openElements.stackTop, last = false; i >= 0; i--) {
           let element4 = this.openElements.items[i];
@@ -4560,6 +4779,7 @@ var require_parser = __commonJS({
         this.tmplInsertionModeStackTop--;
         this.currentTmplInsertionMode = this.tmplInsertionModeStack[this.tmplInsertionModeStackTop];
       }
+      //Foster parenting
       _isElementCausesFosterParenting(element4) {
         const tn = this.treeAdapter.getTagName(element4);
         return tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR;
@@ -4610,6 +4830,7 @@ var require_parser = __commonJS({
           this.treeAdapter.insertText(location2.parent, chars);
         }
       }
+      //Special elements
       _isSpecialElement(element4) {
         const tn = this.treeAdapter.getTagName(element4);
         const ns = this.treeAdapter.getNamespaceURI(element4);
@@ -6258,6 +6479,12 @@ var require_is_buffer2 = __commonJS({
 
 // ../../node_modules/property-information/lib/util/schema.js
 var Schema = class {
+  /**
+   * @constructor
+   * @param {Properties} property
+   * @param {Normal} normal
+   * @param {string} [space]
+   */
   constructor(property, normal, space) {
     this.property = property;
     this.normal = normal;
@@ -6289,6 +6516,11 @@ function normalize(value) {
 
 // ../../node_modules/property-information/lib/util/info.js
 var Info = class {
+  /**
+   * @constructor
+   * @param {string} property
+   * @param {string} attribute
+   */
   constructor(property, attribute) {
     this.property = property;
     this.attribute = attribute;
@@ -6331,6 +6563,13 @@ function increment() {
 // ../../node_modules/property-information/lib/util/defined-info.js
 var checks = Object.keys(types_exports);
 var DefinedInfo = class extends Info {
+  /**
+   * @constructor
+   * @param {string} property
+   * @param {string} attribute
+   * @param {number|null} [mask]
+   * @param {string} [space]
+   */
   constructor(property, attribute, mask, space) {
     let index2 = -1;
     super(property, attribute);
@@ -6490,6 +6729,7 @@ var html = create({
   transform: caseInsensitiveTransform,
   mustUseProperty: ["checked", "multiple", "muted", "selected"],
   properties: {
+    // Standard Properties.
     abbr: null,
     accept: commaSeparated,
     acceptCharset: spaceSeparated,
@@ -6708,59 +6948,115 @@ var html = create({
     value: booleanish,
     width: number,
     wrap: null,
+    // Legacy.
+    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
     align: null,
+    // Several. Use CSS `text-align` instead,
     aLink: null,
+    // `<body>`. Use CSS `a:active {color}` instead
     archive: spaceSeparated,
+    // `<object>`. List of URIs to archives
     axis: null,
+    // `<td>` and `<th>`. Use `scope` on `<th>`
     background: null,
+    // `<body>`. Use CSS `background-image` instead
     bgColor: null,
+    // `<body>` and table elements. Use CSS `background-color` instead
     border: number,
+    // `<table>`. Use CSS `border-width` instead,
     borderColor: null,
+    // `<table>`. Use CSS `border-color` instead,
     bottomMargin: number,
+    // `<body>`
     cellPadding: null,
+    // `<table>`
     cellSpacing: null,
+    // `<table>`
     char: null,
+    // Several table elements. When `align=char`, sets the character to align on
     charOff: null,
+    // Several table elements. When `char`, offsets the alignment
     classId: null,
+    // `<object>`
     clear: null,
+    // `<br>`. Use CSS `clear` instead
     code: null,
+    // `<object>`
     codeBase: null,
+    // `<object>`
     codeType: null,
+    // `<object>`
     color: null,
+    // `<font>` and `<hr>`. Use CSS instead
     compact: boolean,
+    // Lists. Use CSS to reduce space between items instead
     declare: boolean,
+    // `<object>`
     event: null,
+    // `<script>`
     face: null,
+    // `<font>`. Use CSS instead
     frame: null,
+    // `<table>`
     frameBorder: null,
+    // `<iframe>`. Use CSS `border` instead
     hSpace: number,
+    // `<img>` and `<object>`
     leftMargin: number,
+    // `<body>`
     link: null,
+    // `<body>`. Use CSS `a:link {color: *}` instead
     longDesc: null,
+    // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
     lowSrc: null,
+    // `<img>`. Use a `<picture>`
     marginHeight: number,
+    // `<body>`
     marginWidth: number,
+    // `<body>`
     noResize: boolean,
+    // `<frame>`
     noHref: boolean,
+    // `<area>`. Use no href instead of an explicit `nohref`
     noShade: boolean,
+    // `<hr>`. Use background-color and height instead of borders
     noWrap: boolean,
+    // `<td>` and `<th>`
     object: null,
+    // `<applet>`
     profile: null,
+    // `<head>`
     prompt: null,
+    // `<isindex>`
     rev: null,
+    // `<link>`
     rightMargin: number,
+    // `<body>`
     rules: null,
+    // `<table>`
     scheme: null,
+    // `<meta>`
     scrolling: booleanish,
+    // `<frame>`. Use overflow in the child context
     standby: null,
+    // `<object>`
     summary: null,
+    // `<table>`
     text: null,
+    // `<body>`. Use CSS `color` instead
     topMargin: number,
+    // `<body>`
     valueType: null,
+    // `<param>`
     version: null,
+    // `<html>`. Use a doctype.
     vAlign: null,
+    // Several. Use CSS `vertical-align` instead
     vLink: null,
+    // `<body>`. Use CSS `a:visited {color}` instead
     vSpace: number,
+    // `<img>` and `<object>`
+    // Non-standard Properties.
     allowTransparency: null,
     autoCorrect: null,
     autoSave: null,
@@ -6947,6 +7243,7 @@ var svg = create({
     wordSpacing: "word-spacing",
     writingMode: "writing-mode",
     xHeight: "x-height",
+    // These were camelcased in Tiny. Now lowercased in SVG 2
     playbackOrder: "playbackorder",
     timelineBegin: "timelinebegin"
   },
@@ -7067,8 +7364,11 @@ var svg = create({
     kernelMatrix: commaOrSpaceSeparated,
     kernelUnitLength: null,
     keyPoints: null,
+    // SEMI_COLON_SEPARATED
     keySplines: null,
+    // SEMI_COLON_SEPARATED
     keyTimes: null,
+    // SEMI_COLON_SEPARATED
     kerning: null,
     lang: null,
     lengthAdjust: null,
@@ -7398,37 +7698,82 @@ var htmlVoidElements = [
 ];
 
 // ../../node_modules/hast-util-is-element/index.js
-var isElement = function(node, test, index2, parent, context) {
-  const check = convertElement(test);
-  if (index2 !== void 0 && index2 !== null && (typeof index2 !== "number" || index2 < 0 || index2 === Number.POSITIVE_INFINITY)) {
-    throw new Error("Expected positive finite index for child node");
-  }
-  if (parent !== void 0 && parent !== null && (!parent.type || !parent.children)) {
-    throw new Error("Expected parent node");
-  }
-  if (!node || !node.type || typeof node.type !== "string") {
-    return false;
-  }
-  if ((parent === void 0 || parent === null) !== (index2 === void 0 || index2 === null)) {
-    throw new Error("Expected both parent and index");
-  }
-  return check.call(context, node, index2, parent);
-};
-var convertElement = function(test) {
-  if (test === void 0 || test === null) {
-    return element;
-  }
-  if (typeof test === "string") {
-    return tagNameFactory(test);
-  }
-  if (typeof test === "object") {
-    return anyFactory(test);
+var isElement = (
+  /**
+   * Check if a node is an element and passes a test.
+   * When a `parent` node is known the `index` of node should also be given.
+   *
+   * @type {(
+   *   (() => false) &
+   *   (<T extends Element = Element>(node: unknown, test?: PredicateTest<T>, index?: number, parent?: Parent, context?: unknown) => node is T) &
+   *   ((node: unknown, test: Test, index?: number, parent?: Parent, context?: unknown) => boolean)
+   * )}
+   */
+  /**
+   * Check if a node passes a test.
+   * When a `parent` node is known the `index` of node should also be given.
+   *
+   * @param {unknown} [node] Node to check
+   * @param {Test} [test] When nullish, checks if `node` is a `Node`.
+   * When `string`, works like passing `function (node) {return node.type === test}`.
+   * When `function` checks if function passed the node is true.
+   * When `array`, checks any one of the subtests pass.
+   * @param {number} [index] Position of `node` in `parent`
+   * @param {Parent} [parent] Parent of `node`
+   * @param {unknown} [context] Context object to invoke `test` with
+   * @returns {boolean} Whether test passed and `node` is an `Element` (object with `type` set to `element` and `tagName` set to a non-empty string).
+   */
+  // eslint-disable-next-line max-params
+  function(node, test, index2, parent, context) {
+    const check = convertElement(test);
+    if (index2 !== void 0 && index2 !== null && (typeof index2 !== "number" || index2 < 0 || index2 === Number.POSITIVE_INFINITY)) {
+      throw new Error("Expected positive finite index for child node");
+    }
+    if (parent !== void 0 && parent !== null && (!parent.type || !parent.children)) {
+      throw new Error("Expected parent node");
+    }
+    if (!node || !node.type || typeof node.type !== "string") {
+      return false;
+    }
+    if ((parent === void 0 || parent === null) !== (index2 === void 0 || index2 === null)) {
+      throw new Error("Expected both parent and index");
+    }
+    return check.call(context, node, index2, parent);
   }
-  if (typeof test === "function") {
-    return castFactory(test);
+);
+var convertElement = (
+  /**
+   * @type {(
+   *   (<T extends Element>(test: T['tagName']|TestFunctionPredicate<T>) => AssertPredicate<T>) &
+   *   ((test?: Test) => AssertAnything)
+   * )}
+   */
+  /**
+   * Generate an assertion from a check.
+   * @param {Test} [test]
+   * When nullish, checks if `node` is a `Node`.
+   * When `string`, works like passing `function (node) {return node.type === test}`.
+   * When `function` checks if function passed the node is true.
+   * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+   * When `array`, checks any one of the subtests pass.
+   * @returns {AssertAnything}
+   */
+  function(test) {
+    if (test === void 0 || test === null) {
+      return element;
+    }
+    if (typeof test === "string") {
+      return tagNameFactory(test);
+    }
+    if (typeof test === "object") {
+      return anyFactory(test);
+    }
+    if (typeof test === "function") {
+      return castFactory(test);
+    }
+    throw new Error("Expected function, string, or array as test");
   }
-  throw new Error("Expected function, string, or array as test");
-};
+);
 function anyFactory(tests) {
   const checks2 = [];
   let index2 = -1;
@@ -7460,26 +7805,46 @@ function castFactory(check) {
 }
 function element(node) {
   return Boolean(
-    node && typeof node === "object" && node.type === "element" && typeof node.tagName === "string"
+    node && typeof node === "object" && // @ts-expect-error Looks like a node.
+    node.type === "element" && // @ts-expect-error Looks like an element.
+    typeof node.tagName === "string"
   );
 }
 
 // ../../node_modules/unist-util-is/index.js
-var convert = function(test) {
-  if (test === void 0 || test === null) {
-    return ok;
-  }
-  if (typeof test === "string") {
-    return typeFactory(test);
+var convert = (
+  /**
+   * @type {(
+   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
+   *   ((test?: Test) => AssertAnything)
+   * )}
+   */
+  /**
+   * Generate an assertion from a check.
+   * @param {Test} [test]
+   * When nullish, checks if `node` is a `Node`.
+   * When `string`, works like passing `function (node) {return node.type === test}`.
+   * When `function` checks if function passed the node is true.
+   * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+   * When `array`, checks any one of the subtests pass.
+   * @returns {AssertAnything}
+   */
+  function(test) {
+    if (test === void 0 || test === null) {
+      return ok;
+    }
+    if (typeof test === "string") {
+      return typeFactory(test);
+    }
+    if (typeof test === "object") {
+      return Array.isArray(test) ? anyFactory2(test) : propsFactory(test);
+    }
+    if (typeof test === "function") {
+      return castFactory2(test);
+    }
+    throw new Error("Expected function, string, or object as test");
   }
-  if (typeof test === "object") {
-    return Array.isArray(test) ? anyFactory2(test) : propsFactory(test);
-  }
-  if (typeof test === "function") {
-    return castFactory2(test);
-  }
-  throw new Error("Expected function, string, or object as test");
-};
+);
 function anyFactory2(tests) {
   const checks2 = [];
   let index2 = -1;
@@ -7528,7 +7893,13 @@ var comment = convert("comment");
 
 // ../../node_modules/hast-util-whitespace/index.js
 function whitespace(thing) {
-  var value = thing && typeof thing === "object" && thing.type === "text" ? thing.value || "" : thing;
+  var value = (
+    // @ts-ignore looks like a node.
+    thing && typeof thing === "object" && thing.type === "text" ? (
+      // @ts-ignore looks like a text.
+      thing.value || ""
+    ) : thing
+  );
   return typeof value === "string" && value.replace(/[ \t\n\f\r]/g, "") === "";
 }
 
@@ -7634,7 +8005,8 @@ function p(_2, index2, parent) {
     "section",
     "table",
     "ul"
-  ]) : !parent || !isElement(parent, [
+  ]) : !parent || // Confusing parent.
+  !isElement(parent, [
     "a",
     "audio",
     "del",
@@ -7791,6 +8163,7 @@ function core(value, options) {
     return value;
   }
   return value.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, surrogate).replace(
+    // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
     /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,
     basic2
   );
@@ -8273,19 +8646,23 @@ function ccount(value, character) {
 
 // ../../node_modules/hast-util-to-html/lib/constants.js
 var constants = {
+  // See: <https://html.spec.whatwg.org/#attribute-name-state>.
   name: [
     ["	\n\f\r &/=>".split(""), "	\n\f\r \"&'/=>`".split("")],
     [`\0	
 \f\r "&'/<=>`.split(""), "\0	\n\f\r \"&'/<=>`".split("")]
   ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(unquoted)-state>.
   unquoted: [
     ["	\n\f\r &>".split(""), "\0	\n\f\r \"&'<=>`".split("")],
     ["\0	\n\f\r \"&'<=>`".split(""), "\0	\n\f\r \"&'<=>`".split("")]
   ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state>.
   single: [
     ["&'".split(""), "\"&'`".split("")],
     ["\0&'".split(""), "\0\"&'`".split("")]
   ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state>.
   double: [
     ['"&'.split(""), "\"&'`".split("")],
     ['\0"&'.split(""), "\0\"&'`".split("")]
@@ -8313,7 +8690,8 @@ function doctype(ctx) {
 
 // ../../node_modules/hast-util-to-html/lib/text.js
 function text(ctx, node, _2, parent) {
-  return parent && parent.type === "element" && (parent.tagName === "script" || parent.tagName === "style") ? node.value : stringifyEntities(
+  return parent && parent.type === "element" && // @ts-expect-error: hush.
+  (parent.tagName === "script" || parent.tagName === "style") ? node.value : stringifyEntities(
     node.value,
     Object.assign({}, ctx.entities, { subset: ["<", "&"] })
   );
@@ -8329,7 +8707,9 @@ var handlers = {
   comment: comment2,
   doctype,
   element: element2,
+  // @ts-ignore `raw` is nonstandard
   raw,
+  // @ts-ignore `root` is a parent.
   root: all,
   text
 };
@@ -8422,14 +8802,19 @@ function serializeAttribute(ctx, key2, value) {
   const name = stringifyEntities(
     info.attribute,
     Object.assign({}, ctx.entities, {
+      // Always encode without parse errors in non-HTML.
       subset: constants.name[ctx.schema.space === "html" ? ctx.valid : 1][ctx.safe]
     })
   );
   if (value === true)
     return name;
-  value = typeof value === "object" && "length" in value ? (info.commaSeparated ? stringify2 : stringify)(value, {
-    padLeft: !ctx.tightLists
-  }) : String(value);
+  value = typeof value === "object" && "length" in value ? (
+    // `spaces` doesn’t accept a second argument, but it’s given here just to
+    // keep the code cleaner.
+    (info.commaSeparated ? stringify2 : stringify)(value, {
+      padLeft: !ctx.tightLists
+    })
+  ) : String(value);
   if (ctx.collapseEmpty && !value)
     return name;
   if (ctx.unquoted) {
@@ -8448,6 +8833,7 @@ function serializeAttribute(ctx, key2, value) {
     result = quote + stringifyEntities(
       value,
       Object.assign({}, ctx.entities, {
+        // Always encode without parse errors in non-HTML.
         subset: (quote === "'" ? constants.single : constants.double)[ctx.schema.space === "html" ? ctx.valid : 1][ctx.safe],
         attribute: true
       })
@@ -8487,6 +8873,7 @@ function toHtml(node, options = {}) {
   };
   return one(
     context,
+    // @ts-ignore Assume `node` does not contain a root.
     Array.isArray(node) ? { type: "root", children: node } : node,
     null,
     null
@@ -8544,6 +8931,7 @@ function c(Prism2) {
       greedy: true
     },
     string: {
+      // https://en.cppreference.com/w/c/language/string_literal
       pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
       greedy: true
     },
@@ -8558,12 +8946,15 @@ function c(Prism2) {
   });
   Prism2.languages.insertBefore("c", "string", {
     char: {
+      // https://en.cppreference.com/w/c/language/character_constant
       pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
       greedy: true
     }
   });
   Prism2.languages.insertBefore("c", "string", {
     macro: {
+      // allow for multiline macro definitions
+      // spaces after the # character compile fine with gcc
       pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
       lookbehind: true,
       greedy: true,
@@ -8571,6 +8962,7 @@ function c(Prism2) {
       inside: {
         string: [
           {
+            // highlight the path of the include statement as a string
             pattern: /^(#\s*include\s*)<[^>]+>/,
             lookbehind: true
           },
@@ -8589,6 +8981,7 @@ function c(Prism2) {
             alias: "function"
           }
         ],
+        // highlight macro directives as keywords
         directive: {
           pattern: /^(#\s*)[a-z]+/,
           lookbehind: true,
@@ -8604,6 +8997,7 @@ function c(Prism2) {
     }
   });
   Prism2.languages.insertBefore("c", "function", {
+    // highlight predefined macros as constants
     constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
   });
   delete Prism2.languages.c["boolean"];
@@ -8635,8 +9029,16 @@ function cpp(Prism2) {
           ),
           lookbehind: true
         },
+        // This is intended to capture the class name of method implementations like:
+        //   void foo::bar() const {}
+        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+        // it starts with an uppercase letter. This approximation should give decent results.
         /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
+        // This will capture the class name before destructors like:
+        //   Foo::~Foo() {}
         /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
+        // This also intends to capture the class name of method implementations but here the class has template
+        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
         /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
       ],
       keyword,
@@ -8649,8 +9051,11 @@ function cpp(Prism2) {
     });
     Prism3.languages.insertBefore("cpp", "string", {
       module: {
+        // https://en.cppreference.com/w/cpp/language/modules
         pattern: RegExp(
-          /(\b(?:import|module)\s+)/.source + "(?:" + /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
+          /(\b(?:import|module)\s+)/.source + "(?:" + // header-name
+          /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + // module name or partition or both
+          /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
             /<mod-name>/g,
             function() {
               return modName;
@@ -8691,6 +9096,8 @@ function cpp(Prism2) {
       }
     });
     Prism3.languages.insertBefore("cpp", "class-name", {
+      // the base clause is an optional list of parent classes
+      // https://en.cppreference.com/w/cpp/language/class
       "base-clause": {
         pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
         lookbehind: true,
@@ -8702,6 +9109,7 @@ function cpp(Prism2) {
       "inside",
       "double-colon",
       {
+        // All untokenized words that are not namespaces should be class names
         "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
       },
       Prism3.languages.cpp["base-clause"]
@@ -8733,7 +9141,9 @@ function bash(Prism2) {
       pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
       lookbehind: true,
       alias: "punctuation",
+      // this looks reasonably well in all themes
       inside: null
+      // see below
     };
     var insideString = {
       bash: commandAfterHeredoc,
@@ -8742,10 +9152,12 @@ function bash(Prism2) {
         alias: "constant"
       },
       variable: [
+        // [0]: Arithmetic Environment
         {
           pattern: /\$?\(\([\s\S]+?\)\)/,
           greedy: true,
           inside: {
+            // If there is a $ sign at the beginning highlight $(( and )) as variable
             variable: [
               {
                 pattern: /(^\$\(\([\s\S]+)\)\)/,
@@ -8754,10 +9166,13 @@ function bash(Prism2) {
               /^\$\(\(/
             ],
             number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+            // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
             operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+            // If there is no $ sign at the beginning highlight (( and )) as punctuation
             punctuation: /\(\(?|\)\)?|,|;/
           }
         },
+        // [1]: Command Substitution
         {
           pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
           greedy: true,
@@ -8765,6 +9180,7 @@ function bash(Prism2) {
             variable: /^\$\(|^`|\)$|`$/
           }
         },
+        // [2]: Brace expansion
         {
           pattern: /\$\{[^}]+\}/,
           greedy: true,
@@ -8780,6 +9196,7 @@ function bash(Prism2) {
         },
         /\$(?:\w+|[#?*!@$])/
       ],
+      // Escape sequences from echo and printf's manuals, and escaped quotes.
       entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
     };
     Prism3.languages.bash = {
@@ -8792,21 +9209,30 @@ function bash(Prism2) {
         lookbehind: true
       },
       "function-name": [
+        // a) function foo {
+        // b) foo() {
+        // c) function foo() {
+        // but not “foo {”
         {
+          // a) and c)
           pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
           lookbehind: true,
           alias: "function"
         },
         {
+          // b)
           pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
           alias: "function"
         }
       ],
+      // Highlight variable names as variables in for and select beginnings.
       "for-or-select": {
         pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
         alias: "variable",
         lookbehind: true
       },
+      // Highlight variable names as variables in the left-hand part
+      // of assignments (“=” and “+=”).
       "assign-left": {
         pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
         inside: {
@@ -8819,18 +9245,22 @@ function bash(Prism2) {
         alias: "variable",
         lookbehind: true
       },
+      // Highlight parameter names as variables
       parameter: {
         pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
         alias: "variable",
         lookbehind: true
       },
       string: [
+        // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
         {
           pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
           lookbehind: true,
           greedy: true,
           inside: insideString
         },
+        // Here-document with quotes around the tag
+        // → No expansion (so no “inside”).
         {
           pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
           lookbehind: true,
@@ -8839,18 +9269,22 @@ function bash(Prism2) {
             bash: commandAfterHeredoc
           }
         },
+        // “Normal” string
         {
+          // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
           pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
           lookbehind: true,
           greedy: true,
           inside: insideString
         },
         {
+          // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
           pattern: /(^|[^$\\])'[^']*'/,
           lookbehind: true,
           greedy: true
         },
         {
+          // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
           pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
           greedy: true,
           inside: {
@@ -8871,9 +9305,11 @@ function bash(Prism2) {
         pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
         lookbehind: true
       },
+      // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
       builtin: {
         pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
         lookbehind: true,
+        // Alias added to make those easier to distinguish from strings.
         alias: "class-name"
       },
       boolean: {
@@ -8885,6 +9321,7 @@ function bash(Prism2) {
         alias: "important"
       },
       operator: {
+        // Lots of redirections here, but not just that.
         pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
         inside: {
           "file-descriptor": {
@@ -8949,9 +9386,14 @@ function csharp(Prism2) {
       return pattern.replace(/<<self>>/g, "[^\\s\\S]");
     }
     var keywordKinds = {
+      // keywords which represent a return or variable type
       type: "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+      // keywords which are used to declare a type
       typeDeclaration: "class enum interface record struct",
+      // contextual keywords
+      // ("var" and "dynamic" are missing because they are used like types)
       contextual: "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
+      // all other keywords
       other: "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield"
     };
     function keywordsToPattern(words) {
@@ -9015,6 +9457,8 @@ function csharp(Prism2) {
       ],
       "class-name": [
         {
+          // Using static
+          // using static System.Math;
           pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [
             identifier
           ]),
@@ -9022,6 +9466,8 @@ function csharp(Prism2) {
           inside: typeInside
         },
         {
+          // Using alias (type)
+          // using Project = PC.MyCompany.Project;
           pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
             name,
             typeExpression
@@ -9030,10 +9476,15 @@ function csharp(Prism2) {
           inside: typeInside
         },
         {
+          // Using alias (alias)
+          // using Project = PC.MyCompany.Project;
           pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
           lookbehind: true
         },
         {
+          // Type declarations
+          // class Foo<A, B>
+          // interface Foo<out A, B>
           pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
             typeDeclarationKeywords,
             genericName
@@ -9042,15 +9493,23 @@ function csharp(Prism2) {
           inside: typeInside
         },
         {
+          // Single catch exception declaration
+          // catch(Foo)
+          // (things like catch(Foo e) is covered by variable declaration)
           pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
           lookbehind: true,
           inside: typeInside
         },
         {
+          // Name of the type parameter of generic constraints
+          // where Foo : class
           pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
           lookbehind: true
         },
         {
+          // Casts and checks via as and is.
+          // as Foo<A>, is Bar<B>
+          // (things like if(a is Foo b) is covered by variable declaration)
           pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [
             typeExpressionWithoutTuple
           ]),
@@ -9058,6 +9517,8 @@ function csharp(Prism2) {
           inside: typeInside
         },
         {
+          // Variable, field and parameter declaration
+          // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
           pattern: re(
             /\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source,
             [typeExpression, nonContextualKeywords, name]
@@ -9066,6 +9527,7 @@ function csharp(Prism2) {
         }
       ],
       keyword: keywords,
+      // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
       number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
       operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
       punctuation: /\?\.?|::|[{}[\];(),.:]/
@@ -9085,6 +9547,8 @@ function csharp(Prism2) {
     });
     Prism3.languages.insertBefore("csharp", "class-name", {
       namespace: {
+        // namespace Foo.Bar {}
+        // using Foo.Bar;
         pattern: re(
           /(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,
           [name]
@@ -9095,6 +9559,7 @@ function csharp(Prism2) {
         }
       },
       "type-expression": {
+        // default(Foo), typeof(Foo<Bar>), sizeof(int)
         pattern: re(
           /(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source,
           [nestedRound]
@@ -9104,6 +9569,9 @@ function csharp(Prism2) {
         inside: typeInside
       },
       "return-type": {
+        // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+        // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+        // int Foo => 0; int Foo { get; set } = 0;
         pattern: re(
           /<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,
           [typeExpression, identifier]
@@ -9112,12 +9580,20 @@ function csharp(Prism2) {
         alias: "class-name"
       },
       "constructor-invocation": {
+        // new List<Foo<Bar[]>> { }
         pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
         lookbehind: true,
         inside: typeInside,
         alias: "class-name"
       },
+      /*'explicit-implementation': {
+      // int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+      pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
+      inside: classNameInside,
+      alias: 'class-name'
+      },*/
       "generic-method": {
+        // foo<Bar>()
         pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [name, generic]),
         inside: {
           function: re(/^<<0>>/.source, [name]),
@@ -9129,6 +9605,9 @@ function csharp(Prism2) {
         }
       },
       "type-list": {
+        // The list of types inherited or of generic constraints
+        // class Foo<F> : Bar, IList<FooBar>
+        // where F : Bar, IList<int>
         pattern: re(
           /\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source,
           [
@@ -9166,6 +9645,7 @@ function csharp(Prism2) {
         lookbehind: true,
         alias: "property",
         inside: {
+          // highlight preprocessor directives as keywords
           directive: {
             pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
             lookbehind: true,
@@ -9192,6 +9672,8 @@ function csharp(Prism2) {
     ]);
     Prism3.languages.insertBefore("csharp", "class-name", {
       attribute: {
+        // Attributes
+        // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
         pattern: re(
           /((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source,
           [attrTarget, attr]
@@ -9309,6 +9791,7 @@ function markup(Prism2) {
       greedy: true
     },
     doctype: {
+      // https://www.w3.org/TR/xml/#NT-doctypedecl
       pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
       greedy: true,
       inside: {
@@ -9317,6 +9800,7 @@ function markup(Prism2) {
           lookbehind: true,
           greedy: true,
           inside: null
+          // see below
         },
         string: {
           pattern: /"[^"]*"|'[^']*'/,
@@ -9383,6 +9867,17 @@ function markup(Prism2) {
     }
   });
   Object.defineProperty(Prism2.languages.markup.tag, "addInlined", {
+    /**
+     * Adds an inlined language to markup.
+     *
+     * An example of an inlined language is CSS with `<style>` tags.
+     *
+     * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addInlined('style', 'css');
+     */
     value: function addInlined(tagName, lang) {
       var includedCdataInside = {};
       includedCdataInside["language-" + lang] = {
@@ -9420,6 +9915,17 @@ function markup(Prism2) {
     }
   });
   Object.defineProperty(Prism2.languages.markup.tag, "addAttribute", {
+    /**
+     * Adds an pattern to highlight languages embedded in HTML attributes.
+     *
+     * An example of an inlined language is CSS with `style` attributes.
+     *
+     * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addAttribute('style', 'css');
+     */
     value: function(attrName, lang) {
       Prism2.languages.markup.tag.inside["special-attr"].push({
         pattern: RegExp(
@@ -9484,9 +9990,11 @@ function css(Prism2) {
             pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
             lookbehind: true
           }
+          // See rest below
         }
       },
       url: {
+        // https://drafts.csswg.org/css-values-3/#urls
         pattern: RegExp(
           "\\burl\\((?:" + string.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)",
           "i"
@@ -9539,10 +10047,14 @@ function diff(Prism2) {
   (function(Prism3) {
     Prism3.languages.diff = {
       coord: [
+        // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
         /^(?:\*{3}|-{3}|\+{3}).*$/m,
+        // Match "@@ ... @@" coord lines in unified diff.
         /^@@.*@@$/m,
+        // Match coord lines in normal diff (starts with a number).
         /^\d.*$/m
       ]
+      // deleted, inserted, unchanged, diff
     };
     var PREFIXES = {
       "deleted-sign": "-",
@@ -9599,8 +10111,11 @@ function go(Prism2) {
     keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
     boolean: /\b(?:_|false|iota|nil|true)\b/,
     number: [
+      // binary and octal integers
       /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
+      // hexadecimal integers and floats
       /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+      // decimal integers and floats
       /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
     ],
     operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
@@ -9620,6 +10135,11 @@ ini.displayName = "ini";
 ini.aliases = [];
 function ini(Prism2) {
   Prism2.languages.ini = {
+    /**
+     * The component mimics the behavior of the Win32 API parser.
+     *
+     * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}
+     */
     comment: {
       pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m,
       lookbehind: true
@@ -9688,6 +10208,8 @@ function java(Prism2) {
       "class-name": [
         className,
         {
+          // variables, parameters, and constructor references
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
           pattern: RegExp(
             /(^|[^\w.])/.source + classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source
           ),
@@ -9695,6 +10217,8 @@ function java(Prism2) {
           inside: className.inside
         },
         {
+          // class names based on keyword
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
           pattern: RegExp(
             /(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + classNamePrefix + /[A-Z]\w*\b/.source
           ),
@@ -9719,6 +10243,7 @@ function java(Prism2) {
     });
     Prism3.languages.insertBefore("java", "string", {
       "triple-quoted-string": {
+        // http://openjdk.java.net/jeps/355#Description
         pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
         greedy: true,
         alias: "string"
@@ -9848,6 +10373,7 @@ function regex(Prism2) {
       "char-set": charSet,
       backreference: [
         {
+          // a backreference which is not an octal escape
           pattern: /\\(?![123][0-7]{2})[1-9]/,
           alias: "keyword"
         },
@@ -9866,6 +10392,9 @@ function regex(Prism2) {
       escape,
       group: [
         {
+          // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+          // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+          // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
           pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
           alias: "punctuation",
           inside: {
@@ -9912,10 +10441,17 @@ function javascript(Prism2) {
         lookbehind: true
       }
     ],
+    // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
     function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
     number: {
       pattern: RegExp(
-        /(^|[^\w$])/.source + "(?:" + (/NaN|Infinity/.source + "|" + /0[bB][01]+(?:_[01]+)*n?/.source + "|" + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + /\d+(?:_\d+)*n/.source + "|" + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
+        /(^|[^\w$])/.source + "(?:" + // constant
+        (/NaN|Infinity/.source + "|" + // binary integer
+        /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
+        /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
+        /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
+        /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
+        /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
       ),
       lookbehind: true
     },
@@ -9925,7 +10461,15 @@ function javascript(Prism2) {
   Prism2.languages.insertBefore("javascript", "keyword", {
     regex: {
       pattern: RegExp(
-        /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
+        // lookbehind
+        // eslint-disable-next-line regexp/no-dupe-characters-character-class
+        /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
+        // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
+        // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
+        // with the only syntax, so we have to define 2 different regex patterns.
+        /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
+        /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
+        /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
       ),
       lookbehind: true,
       greedy: true,
@@ -9940,6 +10484,7 @@ function javascript(Prism2) {
         "regex-flags": /^[a-z]+$/
       }
     },
+    // This must be declared before keyword because we use "function" inside the look-forward
     "function-variable": {
       pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
       alias: "function"
@@ -10059,6 +10604,7 @@ function kotlin(Prism2) {
   (function(Prism3) {
     Prism3.languages.kotlin = Prism3.languages.extend("clike", {
       keyword: {
+        // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
         pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
         lookbehind: true
       },
@@ -10088,6 +10634,7 @@ function kotlin(Prism2) {
       }
     };
     Prism3.languages.insertBefore("kotlin", "string", {
+      // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
       "string-literal": [
         {
           pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
@@ -10114,6 +10661,7 @@ function kotlin(Prism2) {
         }
       ],
       char: {
+        // https://kotlinlang.org/spec/expressions.html#character-literals
         pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
         greedy: true
       }
@@ -10155,9 +10703,11 @@ function less(Prism2) {
         punctuation: /[:()]/
       }
     },
+    // selectors and mixins are considered the same
     selector: {
       pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
       inside: {
+        // mixin parameters
         variable: /@+[\w-]+/
       }
     },
@@ -10166,12 +10716,14 @@ function less(Prism2) {
   });
   Prism2.languages.insertBefore("less", "property", {
     variable: [
+      // Variable declaration (the colon must be consumed!)
       {
         pattern: /@[\w-]+\s*:/,
         inside: {
           punctuation: /:/
         }
       },
+      // Variable usage
       /@@?[\w-]+/
     ],
     "mixin-usage": {
@@ -10188,6 +10740,7 @@ lua.aliases = [];
 function lua(Prism2) {
   Prism2.languages.lua = {
     comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
+    // \z may be used to skip the following space
     string: {
       pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
       greedy: true
@@ -10198,6 +10751,7 @@ function lua(Prism2) {
     operator: [
       /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
       {
+        // Match ".." but don't break "..."
         pattern: /(^|[^.])\.\.(?!\.)/,
         lookbehind: true
       }
@@ -10231,6 +10785,7 @@ function makefile(Prism2) {
       }
     },
     variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+    // Directives
     keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
     function: {
       pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
@@ -10371,6 +10926,7 @@ function markdown(Prism2) {
         }
       },
       blockquote: {
+        // > ...
         pattern: /^>(?:[\t ]*>)*/m,
         alias: "punctuation"
       },
@@ -10415,11 +10971,15 @@ function markdown(Prism2) {
       },
       code: [
         {
+          // Prefixed by 4 spaces or 1 tab and preceded by an empty line
           pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
           lookbehind: true,
           alias: "keyword"
         },
         {
+          // ```optional language
+          // code block
+          // ```
           pattern: /^```[\s\S]*?^```$/m,
           greedy: true,
           inside: {
@@ -10437,6 +10997,10 @@ function markdown(Prism2) {
       ],
       title: [
         {
+          // title 1
+          // =======
+          // title 2
+          // -------
           pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
           alias: "important",
           inside: {
@@ -10444,6 +11008,8 @@ function markdown(Prism2) {
           }
         },
         {
+          // # title 1
+          // ###### title 6
           pattern: /(^\s*)#.+/m,
           lookbehind: true,
           alias: "important",
@@ -10453,16 +11019,28 @@ function markdown(Prism2) {
         }
       ],
       hr: {
+        // ***
+        // ---
+        // * * *
+        // -----------
         pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
         lookbehind: true,
         alias: "punctuation"
       },
       list: {
+        // * item
+        // + item
+        // - item
+        // 1. item
         pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
         lookbehind: true,
         alias: "punctuation"
       },
       "url-reference": {
+        // [id]: http://example.com "Optional title"
+        // [id]: http://example.com 'Optional title'
+        // [id]: http://example.com (Optional title)
+        // [id]: <http://example.com> "Optional title"
         pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
         inside: {
           variable: {
@@ -10475,6 +11053,9 @@ function markdown(Prism2) {
         alias: "url"
       },
       bold: {
+        // **strong**
+        // __strong__
+        // allow one nested instance of italic text using the same delimiter
         pattern: createInline(
           /\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source
         ),
@@ -10485,11 +11066,15 @@ function markdown(Prism2) {
             pattern: /(^..)[\s\S]+(?=..$)/,
             lookbehind: true,
             inside: {}
+            // see below
           },
           punctuation: /\*\*|__/
         }
       },
       italic: {
+        // *em*
+        // _em_
+        // allow one nested instance of bold text using the same delimiter
         pattern: createInline(
           /\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source
         ),
@@ -10500,11 +11085,15 @@ function markdown(Prism2) {
             pattern: /(^.)[\s\S]+(?=.$)/,
             lookbehind: true,
             inside: {}
+            // see below
           },
           punctuation: /[*_]/
         }
       },
       strike: {
+        // ~~strike through~~
+        // ~strike~
+        // eslint-disable-next-line regexp/strict
         pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
         lookbehind: true,
         greedy: true,
@@ -10513,17 +11102,23 @@ function markdown(Prism2) {
             pattern: /(^~~?)[\s\S]+(?=\1$)/,
             lookbehind: true,
             inside: {}
+            // see below
           },
           punctuation: /~~?/
         }
       },
       "code-snippet": {
+        // `code`
+        // ``code``
         pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
         lookbehind: true,
         greedy: true,
         alias: ["code", "keyword"]
       },
       url: {
+        // [example](http://example.com "Optional title")
+        // [example][id]
+        // [example] [id]
         pattern: createInline(
           /!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source
         ),
@@ -10535,6 +11130,7 @@ function markdown(Prism2) {
             pattern: /(^\[)[^\]]+(?=\])/,
             lookbehind: true,
             inside: {}
+            // see below
           },
           variable: {
             pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
@@ -10607,7 +11203,7 @@ function markdown(Prism2) {
       var grammar = Prism3.languages[codeLang];
       if (!grammar) {
         if (codeLang && codeLang !== "none" && Prism3.plugins.autoloader) {
-          var id = "md-" + new Date().valueOf() + "-" + Math.floor(Math.random() * 1e16);
+          var id = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
           env.attributes["id"] = id;
           Prism3.plugins.autoloader.loadLanguages(codeLang, function() {
             var ele = document.getElementById(id);
@@ -10689,6 +11285,7 @@ function perl(Prism2) {
     Prism3.languages.perl = {
       comment: [
         {
+          // POD
           pattern: /(^\s*)=\w[\s\S]*?=cut.*/m,
           lookbehind: true,
           greedy: true
@@ -10699,21 +11296,32 @@ function perl(Prism2) {
           greedy: true
         }
       ],
+      // TODO Could be nice to handle Heredoc too.
       string: [
         {
           pattern: RegExp(
             /\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+              // q/.../
               /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+              // q a...a
+              // eslint-disable-next-line regexp/strict
               /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+              // q(...)
+              // q{...}
+              // q[...]
+              // q<...>
               brackets
             ].join("|") + ")"
           ),
           greedy: true
         },
+        // "...", `...`
         {
           pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
           greedy: true
         },
+        // '...'
+        // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
         {
           pattern: /'(?:[^'\\\r\n]|\\.)*'/,
           greedy: true
@@ -10723,42 +11331,73 @@ function perl(Prism2) {
         {
           pattern: RegExp(
             /\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+              // m/.../
               /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+              // m a...a
+              // eslint-disable-next-line regexp/strict
               /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+              // m(...)
+              // m{...}
+              // m[...]
+              // m<...>
               brackets
             ].join("|") + ")" + /[msixpodualngc]*/.source
           ),
           greedy: true
         },
+        // The lookbehinds prevent -s from breaking
         {
           pattern: RegExp(
             /(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+              // s/.../.../
+              // eslint-disable-next-line regexp/strict
               /([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+              // s a...a...a
+              // eslint-disable-next-line regexp/strict
               /([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source,
+              // s(...)(...)
+              // s{...}{...}
+              // s[...][...]
+              // s<...><...>
+              // s(...)[...]
               brackets + /\s*/.source + brackets
             ].join("|") + ")" + /[msixpodualngcer]*/.source
           ),
           lookbehind: true,
           greedy: true
         },
+        // /.../
+        // The look-ahead tries to prevent two divisions on
+        // the same line from being highlighted as regex.
+        // This does not support multi-line regex.
         {
           pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/,
           greedy: true
         }
       ],
+      // FIXME Not sure about the handling of ::, ', and #
       variable: [
+        // ${^POSTMATCH}
         /[&*$@%]\{\^[A-Z]+\}/,
+        // $^V
         /[&*$@%]\^[A-Z_]/,
+        // ${...}
         /[&*$@%]#?(?=\{)/,
+        // $foo
         /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/,
+        // $1
         /[&*$@%]\d+/,
+        // $_, @_, %!
+        // The negative lookahead prevents from breaking the %= operator
         /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
       ],
       filehandle: {
+        // <>, <FOO>, _
         pattern: /<(?![<=])\S*?>|\b_\b/,
         alias: "symbol"
       },
       "v-string": {
+        // v1.2, 1.2.3
         pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
         alias: "string"
       },
@@ -10785,6 +11424,17 @@ function markupTemplating(Prism2) {
     }
     Object.defineProperties(Prism3.languages["markup-templating"] = {}, {
       buildPlaceholders: {
+        /**
+         * Tokenize all inline templating expressions matching `placeholderPattern`.
+         *
+         * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+         * `true` will be replaced.
+         *
+         * @param {object} env The environment of the `before-tokenize` hook.
+         * @param {string} language The language id.
+         * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+         * @param {(match: string) => boolean} [replaceFilter]
+         */
         value: function(env, language, placeholderPattern, replaceFilter) {
           if (env.language !== language) {
             return;
@@ -10806,6 +11456,12 @@ function markupTemplating(Prism2) {
         }
       },
       tokenizePlaceholders: {
+        /**
+         * Replace placeholders with proper tokens after tokenizing.
+         *
+         * @param {object} env The environment of the `after-tokenize` hook.
+         * @param {string} language The language id.
+         */
         value: function(env, language) {
           if (env.language !== language || !env.tokenStack) {
             return;
@@ -10950,11 +11606,17 @@ function php(Prism2) {
           greedy: true
         },
         {
+          // yield from
           pattern: /(\byield\s+)from\b/i,
           lookbehind: true
         },
+        // `class` is always a keyword unlike other keywords
         /\bclass\b/i,
         {
+          // https://www.php.net/manual/en/reserved.keywords.php
+          //
+          // keywords cannot be preceded by "->"
+          // the complex lookbehind means `(?<!(?:->|::)\s*)`
           pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
           lookbehind: true
         }
@@ -11140,6 +11802,7 @@ function php(Prism2) {
           "attribute-content": {
             pattern: /^(#\[)[\s\S]+(?=\]$)/,
             lookbehind: true,
+            // inside can appear subset of php
             inside: {
               comment: comment4,
               string,
@@ -11205,6 +11868,7 @@ function python(Prism2) {
       greedy: true,
       inside: {
         interpolation: {
+          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
           pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
           lookbehind: true,
           inside: {
@@ -11269,6 +11933,8 @@ function r(Prism2) {
       greedy: true
     },
     "percent-operator": {
+      // Includes user-defined operators
+      // and %%, %*%, %/%, %in%, %o%, %x%
       pattern: /%[^%\s]*%/,
       alias: "operator"
     },
@@ -11510,8 +12176,10 @@ function rust(Prism2) {
         alias: "attr-name",
         inside: {
           string: null
+          // see below
         }
       },
+      // Closure params should not be confused with bitwise OR |
       "closure-params": {
         pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
         lookbehind: true,
@@ -11522,6 +12190,7 @@ function rust(Prism2) {
             alias: "punctuation"
           },
           rest: null
+          // see below
         }
       },
       "lifetime-annotation": {
@@ -11560,9 +12229,15 @@ function rust(Prism2) {
         }
       ],
       keyword: [
+        // https://github.com/rust-lang/reference/blob/master/src/keywords.md
         /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+        // primitives and str
+        // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
         /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
       ],
+      // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+      // and Rust's naming conventions recommend snake_case anyway.
+      // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
       function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
       macro: {
         pattern: /\b\w+!/,
@@ -11576,6 +12251,7 @@ function rust(Prism2) {
           punctuation: /::/
         }
       },
+      // Hex, oct, bin, dec numbers with visual separators and type suffix
       number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
       boolean: /\b(?:false|true)\b/,
       punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
@@ -11593,6 +12269,7 @@ function sass(Prism2) {
   Prism2.register(css);
   (function(Prism3) {
     Prism3.languages.sass = Prism3.languages.extend("css", {
+      // Sass comments don't need to be closed, only indented
       comment: {
         pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t].+)*/m,
         lookbehind: true,
@@ -11600,7 +12277,9 @@ function sass(Prism2) {
       }
     });
     Prism3.languages.insertBefore("sass", "atrule", {
+      // We want to consume the whole line
       "atrule-line": {
+        // Includes support for = and + shortcuts
         pattern: /^(?:[ \t]*)[@+=].+/m,
         greedy: true,
         inside: {
@@ -11618,6 +12297,7 @@ function sass(Prism2) {
       }
     ];
     Prism3.languages.insertBefore("sass", "property", {
+      // We want to consume the whole line
       "variable-line": {
         pattern: /^[ \t]*\$.+/m,
         greedy: true,
@@ -11627,6 +12307,7 @@ function sass(Prism2) {
           operator
         }
       },
+      // We want to consume the whole line
       "property-line": {
         pattern: /^[ \t]*(?:[^:\s]+ *:.*|:[^:\s].*)/m,
         greedy: true,
@@ -11671,10 +12352,20 @@ function scss(Prism2) {
       pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
       inside: {
         rule: /@[\w-]+/
+        // See rest below
       }
     },
+    // url, compassified
     url: /(?:[-a-z]+-)?url(?=\()/i,
+    // CSS selector regex is not appropriate for Sass
+    // since there can be lot more things (var, @ directive, nesting..)
+    // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+    // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+    // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+    // can "pass" as a selector- e.g: proper#{$erty})
+    // this one was hard to do, so please be careful if you edit this one :)
     selector: {
+      // Initial look-ahead is used to prevent matching of blank selectors
       pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
       inside: {
         parent: {
@@ -11702,6 +12393,7 @@ function scss(Prism2) {
     ]
   });
   Prism2.languages.insertBefore("scss", "important", {
+    // var and interpolated vars
     variable: /\$[-\w]+|#\{\$[-\w]+\}/
   });
   Prism2.languages.insertBefore("scss", "function", {
@@ -11760,6 +12452,7 @@ function sql(Prism2) {
       }
     },
     function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
+    // Should we highlight user defined functions too?
     keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
     boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
     number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
@@ -11774,14 +12467,18 @@ swift.aliases = [];
 function swift(Prism2) {
   Prism2.languages.swift = {
     comment: {
+      // Nested comments are supported up to 2 levels
       pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
       lookbehind: true,
       greedy: true
     },
     "string-literal": [
+      // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
       {
         pattern: RegExp(
-          /(^|[^"#])/.source + "(?:" + /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source
+          /(^|[^"#])/.source + "(?:" + // single-line string
+          /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + // multi-line string
+          /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source
         ),
         lookbehind: true,
         greedy: true,
@@ -11790,6 +12487,7 @@ function swift(Prism2) {
             pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
             lookbehind: true,
             inside: null
+            // see below
           },
           "interpolation-punctuation": {
             pattern: /^\)|\\\($/,
@@ -11801,7 +12499,9 @@ function swift(Prism2) {
       },
       {
         pattern: RegExp(
-          /(^|[^"#])(#+)/.source + "(?:" + /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"
+          /(^|[^"#])(#+)/.source + "(?:" + // single-line string
+          /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + // multi-line string
+          /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"
         ),
         lookbehind: true,
         greedy: true,
@@ -11810,6 +12510,7 @@ function swift(Prism2) {
             pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
             lookbehind: true,
             inside: null
+            // see below
           },
           "interpolation-punctuation": {
             pattern: /^\)|\\#+\($/,
@@ -11820,8 +12521,12 @@ function swift(Prism2) {
       }
     ],
     directive: {
+      // directives with conditions
       pattern: RegExp(
-        /#/.source + "(?:" + (/(?:elseif|if)\b/.source + "(?:[ 	]*" + /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+") + "|" + /(?:else|endif)\b/.source + ")"
+        /#/.source + "(?:" + (/(?:elseif|if)\b/.source + "(?:[ 	]*" + // This regex is a little complex. It's equivalent to this:
+        //   (?:![ \t]*)?(?:\b\w+\b(?:[ \t]*<round>)?|<round>)(?:[ \t]*(?:&&|\|\|))?
+        // where <round> is a general parentheses expression.
+        /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+") + "|" + /(?:else|endif)\b/.source + ")"
       ),
       alias: "property",
       inside: {
@@ -11850,6 +12555,7 @@ function swift(Prism2) {
       alias: "function"
     },
     label: {
+      // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
       pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
       lookbehind: true,
       alias: "important"
@@ -11866,9 +12572,13 @@ function swift(Prism2) {
       alias: "keyword"
     },
     number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+    // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
     "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
     function: /\b[a-z_]\w*(?=\s*\()/i,
     constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+    // Operators are generic in Swift. Developers can even create new operators (e.g. +++).
+    // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
+    // This regex only supports ASCII operators.
     operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
     punctuation: /[{}[\]();,.:\\]/
   };
@@ -11889,12 +12599,15 @@ function typescript(Prism2) {
         lookbehind: true,
         greedy: true,
         inside: null
+        // see below
       },
       builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
     });
     Prism3.languages.typescript.keyword.push(
       /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
+      // keywords that have to be followed by an identifier
       /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
+      // This is for `import type *, {}`
       /\btype\b(?=\s*(?:[\{*]|$))/
     );
     delete Prism3.languages.typescript["parameter"];
@@ -11914,12 +12627,14 @@ function typescript(Prism2) {
         }
       },
       "generic-function": {
+        // e.g. foo<T extends "bar" | "baz">( ...
         pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
         greedy: true,
         inside: {
           function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
           generic: {
             pattern: /<[\s\S]+/,
+            // everything after the first <
             alias: "class-name",
             inside: typeInside
           }
@@ -11984,79 +12699,109 @@ function vbnet(Prism2) {
 
 // ../../node_modules/hast-util-parse-selector/index.js
 var search = /[#.]/g;
-var parseSelector = function(selector, defaultTagName = "div") {
-  var value = selector || "";
-  var props = {};
-  var start = 0;
-  var subvalue;
-  var previous;
-  var match;
-  while (start < value.length) {
-    search.lastIndex = start;
-    match = search.exec(value);
-    subvalue = value.slice(start, match ? match.index : value.length);
-    if (subvalue) {
-      if (!previous) {
-        defaultTagName = subvalue;
-      } else if (previous === "#") {
-        props.id = subvalue;
-      } else if (Array.isArray(props.className)) {
-        props.className.push(subvalue);
-      } else {
-        props.className = [subvalue];
+var parseSelector = (
+  /**
+   * @type {(
+   *  <Selector extends string, DefaultTagName extends string = 'div'>(selector?: Selector, defaultTagName?: DefaultTagName) => Element & {tagName: import('./extract.js').ExtractTagName<Selector, DefaultTagName>}
+   * )}
+   */
+  /**
+   * @param {string} [selector]
+   * @param {string} [defaultTagName='div']
+   * @returns {Element}
+   */
+  function(selector, defaultTagName = "div") {
+    var value = selector || "";
+    var props = {};
+    var start = 0;
+    var subvalue;
+    var previous;
+    var match;
+    while (start < value.length) {
+      search.lastIndex = start;
+      match = search.exec(value);
+      subvalue = value.slice(start, match ? match.index : value.length);
+      if (subvalue) {
+        if (!previous) {
+          defaultTagName = subvalue;
+        } else if (previous === "#") {
+          props.id = subvalue;
+        } else if (Array.isArray(props.className)) {
+          props.className.push(subvalue);
+        } else {
+          props.className = [subvalue];
+        }
+        start += subvalue.length;
+      }
+      if (match) {
+        previous = match[0];
+        start++;
       }
-      start += subvalue.length;
-    }
-    if (match) {
-      previous = match[0];
-      start++;
     }
+    return {
+      type: "element",
+      tagName: defaultTagName,
+      properties: props,
+      children: []
+    };
   }
-  return {
-    type: "element",
-    tagName: defaultTagName,
-    properties: props,
-    children: []
-  };
-};
+);
 
 // ../../node_modules/hastscript/lib/core.js
 var buttonTypes = /* @__PURE__ */ new Set(["menu", "submit", "reset", "button"]);
 var own5 = {}.hasOwnProperty;
 function core2(schema, defaultTagName, caseSensitive) {
   const adjust = caseSensitive && createAdjustMap(caseSensitive);
-  const h2 = function(selector, properties, ...children) {
-    let index2 = -1;
-    let node;
-    if (selector === void 0 || selector === null) {
-      node = { type: "root", children: [] };
-      children.unshift(properties);
-    } else {
-      node = parseSelector(selector, defaultTagName);
-      node.tagName = node.tagName.toLowerCase();
-      if (adjust && own5.call(adjust, node.tagName)) {
-        node.tagName = adjust[node.tagName];
-      }
-      if (isProperties(properties, node.tagName)) {
-        let key2;
-        for (key2 in properties) {
-          if (own5.call(properties, key2)) {
-            addProperty(schema, node.properties, key2, properties[key2]);
+  const h2 = (
+    /**
+     * @type {{
+     *   (): Root
+     *   (selector: null|undefined, ...children: Array<HChild>): Root
+     *   (selector: string, properties?: HProperties, ...children: Array<HChild>): Element
+     *   (selector: string, ...children: Array<HChild>): Element
+     * }}
+     */
+    /**
+     * Hyperscript compatible DSL for creating virtual hast trees.
+     *
+     * @param {string|null} [selector]
+     * @param {HProperties|HChild} [properties]
+     * @param {Array<HChild>} children
+     * @returns {HResult}
+     */
+    function(selector, properties, ...children) {
+      let index2 = -1;
+      let node;
+      if (selector === void 0 || selector === null) {
+        node = { type: "root", children: [] };
+        children.unshift(properties);
+      } else {
+        node = parseSelector(selector, defaultTagName);
+        node.tagName = node.tagName.toLowerCase();
+        if (adjust && own5.call(adjust, node.tagName)) {
+          node.tagName = adjust[node.tagName];
+        }
+        if (isProperties(properties, node.tagName)) {
+          let key2;
+          for (key2 in properties) {
+            if (own5.call(properties, key2)) {
+              addProperty(schema, node.properties, key2, properties[key2]);
+            }
           }
+        } else {
+          children.unshift(properties);
         }
-      } else {
-        children.unshift(properties);
       }
+      while (++index2 < children.length) {
+        addChild(node.children, children[index2]);
+      }
+      if (node.type === "element" && node.tagName === "template") {
+        node.content = { type: "root", children: node.children };
+        node.children = [];
+      }
+      return node;
     }
-    while (++index2 < children.length) {
-      addChild(node.children, children[index2]);
-    }
-    if (node.type === "element" && node.tagName === "template") {
-      node.content = { type: "root", children: node.children };
-      node.children = [];
-    }
-    return node;
-  };
+  );
   return h2;
 }
 function isProperties(value, name) {
@@ -14405,12 +15150,19 @@ function decodeNamedCharacterReference(value) {
 var fromCharCode = String.fromCharCode;
 var messages = [
   "",
+  /* 1: Non terminated (named) */
   "Named character references must be terminated by a semicolon",
+  /* 2: Non terminated (numeric) */
   "Numeric character references must be terminated by a semicolon",
+  /* 3: Empty (named) */
   "Named character references cannot be empty",
+  /* 4: Empty (numeric) */
   "Numeric character references cannot be empty",
+  /* 5: Unknown (named) */
   "Named character references must be known",
+  /* 6: Disallowed (numeric) */
   "Numeric character references cannot be disallowed",
+  /* 7: Prohibited (numeric) */
   "Numeric character references cannot be outside the permissible Unicode range"
 ];
 function parseEntities(value, options = {}) {
@@ -14531,7 +15283,10 @@ function parseEntities(value, options = {}) {
         );
         if (prohibited(referenceCode)) {
           warning(7, diff2);
-          reference = fromCharCode(65533);
+          reference = fromCharCode(
+            65533
+            /* `�` */
+          );
         } else if (referenceCode in characterReferenceInvalid) {
           warning(6, diff2);
           reference = characterReferenceInvalid[referenceCode];
@@ -14631,16 +15386,57 @@ function disallowed(code) {
 var uniqueId = 0;
 var plainTextGrammar = {};
 var _ = {
+  /**
+   * A namespace for utility methods.
+   *
+   * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
+   * change or disappear at any time.
+   *
+   * @namespace
+   * @memberof Prism
+   */
   util: {
+    /**
+     * Returns the name of the type of the given value.
+     *
+     * @param {any} o
+     * @returns {string}
+     * @example
+     * type(null)      === 'Null'
+     * type(undefined) === 'Undefined'
+     * type(123)       === 'Number'
+     * type('foo')     === 'String'
+     * type(true)      === 'Boolean'
+     * type([1, 2])    === 'Array'
+     * type({})        === 'Object'
+     * type(String)    === 'Function'
+     * type(/abc+/)    === 'RegExp'
+     */
     type: function(o) {
       return Object.prototype.toString.call(o).slice(8, -1);
     },
+    /**
+     * Returns a unique number for the given object. Later calls will still return the same number.
+     *
+     * @param {Object} obj
+     * @returns {number}
+     */
     objId: function(obj) {
       if (!obj["__id"]) {
         Object.defineProperty(obj, "__id", { value: ++uniqueId });
       }
       return obj["__id"];
     },
+    /**
+     * Creates a deep clone of the given object.
+     *
+     * The main intended use of this function is to clone language definitions.
+     *
+     * @param {T} o
+     * @param {Record<number, any>} [visited]
+     * @returns {T}
+     * @template T
+     */
     clone: function deepClone(o, visited) {
       visited = visited || {};
       var clone;
@@ -14651,14 +15447,18 @@ var _ = {
           if (visited[id]) {
             return visited[id];
           }
-          clone = {};
+          clone = /** @type {Record<string, any>} */
+          {};
           visited[id] = clone;
           for (var key2 in o) {
             if (o.hasOwnProperty(key2)) {
               clone[key2] = deepClone(o[key2], visited);
             }
           }
-          return clone;
+          return (
+            /** @type {any} */
+            clone
+          );
         case "Array":
           id = _.util.objId(o);
           if (visited[id]) {
@@ -14669,17 +15469,58 @@ var _ = {
           o.forEach(function(v, i) {
             clone[i] = deepClone(v, visited);
           });
-          return clone;
+          return (
+            /** @type {any} */
+            clone
+          );
         default:
           return o;
       }
     }
   },
+  /**
+   * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
+   *
+   * @namespace
+   * @memberof Prism
+   * @public
+   */
   languages: {
+    /**
+     * The grammar for plain, unformatted text.
+     */
     plain: plainTextGrammar,
     plaintext: plainTextGrammar,
     text: plainTextGrammar,
     txt: plainTextGrammar,
+    /**
+     * Creates a deep copy of the language with the given id and appends the given tokens.
+     *
+     * If a token in `redef` also appears in the copied language, then the existing token in the copied language
+     * will be overwritten at its original position.
+     *
+     * ## Best practices
+     *
+     * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+     * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+     * understand the language definition because, normally, the order of tokens matters in Prism grammars.
+     *
+     * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+     * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+     *
+     * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+     * @param {Grammar} redef The new tokens to append.
+     * @returns {Grammar} The new language created.
+     * @public
+     * @example
+     * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+     *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+     *     // at its original position
+     *     'comment': { ... },
+     *     // CSS doesn't have a 'color' token, so this token will be appended
+     *     'color': /\b(?:red|green|blue)\b/
+     * });
+     */
     extend: function(id, redef) {
       var lang = _.util.clone(_.languages[id]);
       for (var key2 in redef) {
@@ -14687,8 +15528,84 @@ var _ = {
       }
       return lang;
     },
+    /**
+     * Inserts tokens _before_ another token in a language definition or any other grammar.
+     *
+     * ## Usage
+     *
+     * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+     * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+     * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+     * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+     * this:
+     *
+     * ```js
+     * Prism.languages.markup.style = {
+     *     // token
+     * };
+     * ```
+     *
+     * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+     * before existing tokens. For the CSS example above, you would use it like this:
+     *
+     * ```js
+     * Prism.languages.insertBefore('markup', 'cdata', {
+     *     'style': {
+     *         // token
+     *     }
+     * });
+     * ```
+     *
+     * ## Special cases
+     *
+     * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+     * will be ignored.
+     *
+     * This behavior can be used to insert tokens after `before`:
+     *
+     * ```js
+     * Prism.languages.insertBefore('markup', 'comment', {
+     *     'comment': Prism.languages.markup.comment,
+     *     // tokens after 'comment'
+     * });
+     * ```
+     *
+     * ## Limitations
+     *
+     * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+     * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+     * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+     * deleting properties which is necessary to insert at arbitrary positions.
+     *
+     * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+     * Instead, it will create a new object and replace all references to the target object with the new one. This
+     * can be done without temporarily deleting properties, so the iteration order is well-defined.
+     *
+     * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+     * you hold the target object in a variable, then the value of the variable will not change.
+     *
+     * ```js
+     * var oldMarkup = Prism.languages.markup;
+     * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+     *
+     * assert(oldMarkup !== Prism.languages.markup);
+     * assert(newMarkup === Prism.languages.markup);
+     * ```
+     *
+     * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+     * object to be modified.
+     * @param {string} before The key to insert before.
+     * @param {Grammar} insert An object containing the key-value pairs to be inserted.
+     * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+     * object to be modified.
+     *
+     * Defaults to `Prism.languages`.
+     * @returns {Grammar} The new grammar object.
+     * @public
+     */
     insertBefore: function(inside, before, insert, root2) {
-      root2 = root2 || _.languages;
+      root2 = root2 || /** @type {any} */
+      _.languages;
       var grammar = root2[inside];
       var ret = {};
       for (var token in grammar) {
@@ -14714,6 +15631,7 @@ var _ = {
       });
       return ret;
     },
+    // Traverse a language definition with Depth First Search
     DFS: function DFS(o, callback, type, visited) {
       visited = visited || {};
       var objId = _.util.objId;
@@ -14734,6 +15652,26 @@ var _ = {
     }
   },
   plugins: {},
+  /**
+   * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+   * and the language definitions to use, and returns a string with the HTML produced.
+   *
+   * The following hooks will be run:
+   * 1. `before-tokenize`
+   * 2. `after-tokenize`
+   * 3. `wrap`: On each {@link Token}.
+   *
+   * @param {string} text A string with the code to be highlighted.
+   * @param {Grammar} grammar An object containing the tokens to use.
+   *
+   * Usually a language definition like `Prism.languages.markup`.
+   * @param {string} language The name of the language definition passed to `grammar`.
+   * @returns {string} The highlighted HTML.
+   * @memberof Prism
+   * @public
+   * @example
+   * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+   */
   highlight: function(text3, grammar, language) {
     var env = {
       code: text3,
@@ -14748,6 +15686,30 @@ var _ = {
     _.hooks.run("after-tokenize", env);
     return Token.stringify(_.util.encode(env.tokens), env.language);
   },
+  /**
+   * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+   * and the language definitions to use, and returns an array with the tokenized code.
+   *
+   * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+   *
+   * This method could be useful in other contexts as well, as a very crude parser.
+   *
+   * @param {string} text A string with the code to be highlighted.
+   * @param {Grammar} grammar An object containing the tokens to use.
+   *
+   * Usually a language definition like `Prism.languages.markup`.
+   * @returns {TokenStream} An array of strings and tokens, a token stream.
+   * @memberof Prism
+   * @public
+   * @example
+   * let code = `var foo = 0;`;
+   * let tokens = Prism.tokenize(code, Prism.languages.javascript);
+   * tokens.forEach(token => {
+   *     if (token instanceof Prism.Token && token.type === 'number') {
+   *         console.log(`Found numeric literal: ${token.content}`);
+   *     }
+   * });
+   */
   tokenize: function(text3, grammar) {
     var rest = grammar.rest;
     if (rest) {
@@ -14761,13 +15723,39 @@ var _ = {
     matchGrammar(text3, tokenList, grammar, tokenList.head, 0);
     return toArray(tokenList);
   },
+  /**
+   * @namespace
+   * @memberof Prism
+   * @public
+   */
   hooks: {
     all: {},
+    /**
+     * Adds the given callback to the list of callbacks for the given hook.
+     *
+     * The callback will be invoked when the hook it is registered for is run.
+     * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+     *
+     * One callback function can be registered to multiple hooks and the same hook multiple times.
+     *
+     * @param {string} name The name of the hook.
+     * @param {HookCallback} callback The callback function which is given environment variables.
+     * @public
+     */
     add: function(name, callback) {
       var hooks = _.hooks.all;
       hooks[name] = hooks[name] || [];
       hooks[name].push(callback);
     },
+    /**
+     * Runs a hook invoking all registered callbacks with the given environment variables.
+     *
+     * Callbacks will be invoked synchronously and in the order in which they were registered.
+     *
+     * @param {string} name The name of the hook.
+     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+     * @public
+     */
     run: function(name, env) {
       var callbacks = _.hooks.all[name];
       if (!callbacks || !callbacks.length) {
@@ -14976,6 +15964,7 @@ function highlight(value, language) {
   }
   return {
     type: "root",
+    // @ts-expect-error: we hacked Prism to accept and return the things we want.
     children: Prism.highlight.call(refractor, value, grammar, name)
   };
 }
@@ -15159,6 +16148,7 @@ function jsx(Prism2) {
       "special-attr",
       {
         script: {
+          // Allow for two levels of nesting
           pattern: re(/=<BRACES>/.source),
           alias: "language-javascript",
           inside: {
@@ -15724,7 +16714,10 @@ var errors = {
 var base = "https://html.spec.whatwg.org/multipage/parsing.html#parse-error-";
 var fatalities = { 2: true, 1: false, 0: null };
 function rehypeParse(options) {
-  const processorSettings = this.data("settings");
+  const processorSettings = (
+    /** @type {Options} */
+    this.data("settings")
+  );
   const settings = Object.assign({}, processorSettings, options);
   Object.assign(this, { Parser: parser });
   function parser(doc, file) {
@@ -15856,7 +16849,10 @@ function wrap(middleware, callback) {
     try {
       result = middleware.apply(this, parameters);
     } catch (error) {
-      const exception = error;
+      const exception = (
+        /** @type {Error} */
+        error
+      );
       if (fnExpectsCallback && called) {
         throw exception;
       }
@@ -15914,10 +16910,25 @@ function index(value) {
 
 // ../../node_modules/vfile-message/index.js
 var VFileMessage = class extends Error {
+  /**
+   * Create a message for `reason` at `place` from `origin`.
+   *
+   * When an error is passed in as `reason`, the `stack` is copied.
+   *
+   * @param {string|Error|VFileMessage} reason
+   *   Reason for message.
+   *   Uses the stack and message of the error if given.
+   * @param {Node|NodeLike|Position|Point} [place]
+   *   Place at which the message occurred in a file.
+   * @param {string} [origin]
+   *   Place in code the message originates from (example `'my-package:my-rule-name'`)
+   */
   constructor(reason, place, origin) {
     const parts = [null, null];
     let position3 = {
+      // @ts-expect-error: we always follows the structure of `position`.
       start: { line: null, column: null },
+      // @ts-expect-error: "
       end: { line: null, column: null }
     };
     super();
@@ -15988,12 +16999,31 @@ import { fileURLToPath } from "url";
 
 // ../../node_modules/vfile/lib/minurl.shared.js
 function isUrl(fileURLOrPath) {
-  return fileURLOrPath !== null && typeof fileURLOrPath === "object" && fileURLOrPath.href && fileURLOrPath.origin;
+  return fileURLOrPath !== null && typeof fileURLOrPath === "object" && // @ts-expect-error: indexable.
+  fileURLOrPath.href && // @ts-expect-error: indexable.
+  fileURLOrPath.origin;
 }
 
 // ../../node_modules/vfile/lib/index.js
 var order = ["history", "path", "basename", "stem", "extname", "dirname"];
 var VFile = class {
+  /**
+   * Create a new virtual file.
+   *
+   * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`.
+   * If `options` is a `URL`, it’s treated as `{path: options}`.
+   * If `options` is a `VFile`, shallow copies its data over to the new file.
+   * All fields in `options` are set on the newly created `VFile`.
+   *
+   * Path related fields are set in the following order (least specific to
+   * most specific): `history`, `path`, `basename`, `stem`, `extname`,
+   * `dirname`.
+   *
+   * It’s not possible to set either `dirname` or `extname` without setting
+   * either `history`, `path`, `basename`, or `stem` as well.
+   *
+   * @param {Compatible} [value]
+   */
   constructor(value) {
     let options;
     if (!value) {
@@ -16026,9 +17056,20 @@ var VFile = class {
         this[prop] = options[prop];
     }
   }
+  /**
+   * Get the full path (example: `'~/index.min.js'`).
+   * @returns {string}
+   */
   get path() {
     return this.history[this.history.length - 1];
   }
+  /**
+   * Set the full path (example: `'~/index.min.js'`).
+   * Cannot be nullified.
+   * You can set a file URL (a `URL` object with a `file:` protocol) which will
+   * be turned into a path with `url.fileURLToPath`.
+   * @param {string|URL} path
+   */
   set path(path) {
     if (isUrl(path)) {
       path = fileURLToPath(path);
@@ -16038,24 +17079,49 @@ var VFile = class {
       this.history.push(path);
     }
   }
+  /**
+   * Get the parent path (example: `'~'`).
+   */
   get dirname() {
     return typeof this.path === "string" ? default2.dirname(this.path) : void 0;
   }
+  /**
+   * Set the parent path (example: `'~'`).
+   * Cannot be set if there’s no `path` yet.
+   */
   set dirname(dirname) {
     assertPath(this.basename, "dirname");
     this.path = default2.join(dirname || "", this.basename);
   }
+  /**
+   * Get the basename (including extname) (example: `'index.min.js'`).
+   */
   get basename() {
     return typeof this.path === "string" ? default2.basename(this.path) : void 0;
   }
+  /**
+   * Set basename (including extname) (`'index.min.js'`).
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be nullified (use `file.path = file.dirname` instead).
+   */
   set basename(basename) {
     assertNonEmpty(basename, "basename");
     assertPart(basename, "basename");
     this.path = default2.join(this.dirname || "", basename);
   }
+  /**
+   * Get the extname (including dot) (example: `'.js'`).
+   */
   get extname() {
     return typeof this.path === "string" ? default2.extname(this.path) : void 0;
   }
+  /**
+   * Set the extname (including dot) (example: `'.js'`).
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be set if there’s no `path` yet.
+   */
   set extname(extname) {
     assertPart(extname, "extname");
     assertPath(this.dirname, "extname");
@@ -16069,17 +17135,49 @@ var VFile = class {
     }
     this.path = default2.join(this.dirname, this.stem + (extname || ""));
   }
+  /**
+   * Get the stem (basename w/o extname) (example: `'index.min'`).
+   */
   get stem() {
     return typeof this.path === "string" ? default2.basename(this.path, this.extname) : void 0;
   }
+  /**
+   * Set the stem (basename w/o extname) (example: `'index.min'`).
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be nullified (use `file.path = file.dirname` instead).
+   */
   set stem(stem) {
     assertNonEmpty(stem, "stem");
     assertPart(stem, "stem");
     this.path = default2.join(this.dirname || "", stem + (this.extname || ""));
   }
+  /**
+   * Serialize the file.
+   *
+   * @param {BufferEncoding} [encoding='utf8']
+   *   When `value` is a `Buffer`, `encoding` is a character encoding to
+   *   understand it as (default: `'utf8'`).
+   * @returns {string}
+   *   Serialized file.
+   */
   toString(encoding) {
     return (this.value || "").toString(encoding);
   }
+  /**
+   * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and
+   * associates it with the file by adding it to `vfile.messages` and setting
+   * `message.file` to the current filepath.
+   *
+   * @param {string|Error|VFileMessage} reason
+   *   Human readable reason for the message, uses the stack and message of the error if given.
+   * @param {Node|NodeLike|Position|Point} [place]
+   *   Place where the message occurred in the file.
+   * @param {string} [origin]
+   *   Computer readable reason for the message
+   * @returns {VFileMessage}
+   *   Message.
+   */
   message(reason, place, origin) {
     const message = new VFileMessage(reason, place, origin);
     if (this.path) {
@@ -16090,11 +17188,39 @@ var VFile = class {
     this.messages.push(message);
     return message;
   }
+  /**
+   * Like `VFile#message()`, but associates an informational message where
+   * `fatal` is set to `null`.
+   *
+   * @param {string|Error|VFileMessage} reason
+   *   Human readable reason for the message, uses the stack and message of the error if given.
+   * @param {Node|NodeLike|Position|Point} [place]
+   *   Place where the message occurred in the file.
+   * @param {string} [origin]
+   *   Computer readable reason for the message
+   * @returns {VFileMessage}
+   *   Message.
+   */
   info(reason, place, origin) {
     const message = this.message(reason, place, origin);
     message.fatal = null;
     return message;
   }
+  /**
+   * Like `VFile#message()`, but associates a fatal message where `fatal` is
+   * set to `true`, and then immediately throws it.
+   *
+   * > 👉 **Note**: a fatal error means that a file is no longer processable.
+   *
+   * @param {string|Error|VFileMessage} reason
+   *   Human readable reason for the message, uses the stack and message of the error if given.
+   * @param {Node|NodeLike|Position|Point} [place]
+   *   Place where the message occurred in the file.
+   * @param {string} [origin]
+   *   Computer readable reason for the message
+   * @returns {never}
+   *   Message.
+   */
   fail(reason, place, origin) {
     const message = this.message(reason, place, origin);
     message.fatal = true;
@@ -16366,7 +17492,13 @@ function base2() {
   }
 }
 function newable(value, name) {
-  return typeof value === "function" && value.prototype && (keys(value.prototype) || name in value.prototype);
+  return typeof value === "function" && // Prototypes do exist.
+  // type-coverage:ignore-next-line
+  value.prototype && // A function with keys in its prototype is probably a constructor.
+  // Classes’ prototype methods are not enumerable, so we check if some value
+  // exists in the prototype.
+  // type-coverage:ignore-next-line
+  (keys(value.prototype) || name in value.prototype);
 }
 function keys(value) {
   let key2;
@@ -16536,10 +17668,22 @@ function codeToHTML(source, language, line = "0") {
 export {
   codeToHTML
 };
-/*!
- * Determine if an object is a Buffer
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
+/*! Bundled license information:
+
+is-buffer/index.js:
+  (*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+
+is-buffer/index.js:
+  (*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+*/
 //# sourceMappingURL=index.js.map