@qqbrowser/openclaw-qbot 0.10.10 → 0.10.13

package/node_modules/markdown-it/dist/markdown-it.js

@@ -1,4 +1,4 @@
-/*! markdown-it 14.1.1 https://github.com/markdown-it/markdown-it @license MIT */
+/*! markdown-it 14.2.0 https://github.com/markdown-it/markdown-it @license MIT */
 (function(global, factory) {
   typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
   global.markdownit = factory());
@@ -949,6 +949,14 @@
    */  function decodeHTML(str, mode = DecodingMode.Legacy) {
     return htmlDecoder(str, mode);
   }
+  /**
+   * Decodes an HTML string, requiring all entities to be terminated by a semicolon.
+   *
+   * @param str The string to decode.
+   * @returns The decoded string.
+   */  function decodeHTMLStrict(str) {
+    return htmlDecoder(str, DecodingMode.Strict);
+  }
   // Utilities
   
     function _class$1(obj) {
@@ -1124,6 +1132,9 @@
     function isPunctChar(ch) {
     return P.test(ch) || regex.test(ch);
   }
+  function isPunctCharCode(code) {
+    return isPunctChar(fromCodePoint(code));
+  }
   // Markdown ASCII punctuation characters.
   
   // !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
@@ -1183,6 +1194,7 @@
     // (remove this when node v10 is no longer supported).
     
         if ("\u1e9e".toLowerCase() === "\u1e7e") {
+      /* c8 ignore next 2 */
       str = str.replace(/\u1e9e/g, "\xdf");
     }
     // .toLowerCase().toUpperCase() should get rid of all differences
@@ -1219,6 +1231,26 @@
     
         return str.toLowerCase().toUpperCase();
   }
+  function isAsciiTrimmable(c) {
+    return c === 32 || c === 9 || c === 10 || c === 13;
+  }
+  // "Light" .trim() for blocks (headers, paragraphs), where unicode spaces
+  // should be preserved.
+    function asciiTrim(str) {
+    let start = 0;
+    for (;start < str.length; start++) {
+      if (!isAsciiTrimmable(str.charCodeAt(start))) {
+        break;
+      }
+    }
+    let end = str.length - 1;
+    for (;end >= start; end--) {
+      if (!isAsciiTrimmable(str.charCodeAt(end))) {
+        break;
+      }
+    }
+    return str.slice(start, end + 1);
+  }
   // Re-export libraries commonly used in both markdown-it and its plugins,
   // so plugins won't have to depend on them explicitly, which reduces their
   // bundled size (e.g. a browser build).
@@ -1230,6 +1262,7 @@
   var utils =  Object.freeze({
     __proto__: null,
     arrayReplaceAt: arrayReplaceAt,
+    asciiTrim: asciiTrim,
     assign: assign$1,
     escapeHtml: escapeHtml,
     escapeRE: escapeRE$1,
@@ -1237,6 +1270,7 @@
     has: has,
     isMdAsciiPunct: isMdAsciiPunct,
     isPunctChar: isPunctChar,
+    isPunctCharCode: isPunctCharCode,
     isSpace: isSpace,
     isString: isString$1,
     isValidEntityCode: isValidEntityCode,
@@ -2391,12 +2425,31 @@
     const QUOTE_TEST_RE = /['"]/;
   const QUOTE_RE = /['"]/g;
   const APOSTROPHE = "\u2019";
- /* ’ */  function replaceAt(str, index, ch) {
-    return str.slice(0, index) + ch + str.slice(index + 1);
+ /* ’ */  function addReplacement(replacements, tokenIdx, pos, ch) {
+    if (!replacements[tokenIdx]) {
+      replacements[tokenIdx] = [];
+    }
+    replacements[tokenIdx].push({
+      pos: pos,
+      ch: ch
+    });
+  }
+  function applyReplacements(str, replacements) {
+    let result = "";
+    let lastPos = 0;
+    replacements.sort((a, b) => a.pos - b.pos);
+    for (let i = 0; i < replacements.length; i++) {
+      const replacement = replacements[i];
+      result += str.slice(lastPos, replacement.pos) + replacement.ch;
+      lastPos = replacement.pos + 1;
+    }
+    return result + str.slice(lastPos);
   }
   function process_inlines(tokens, state) {
     let j;
     const stack = [];
+    // token index -> list of replacements in the original token content
+        const replacements = {};
     for (let i = 0; i < tokens.length; i++) {
       const token = tokens[i];
       const thisLevel = tokens[i].level;
@@ -2409,9 +2462,9 @@
       if (token.type !== "text") {
         continue;
       }
-      let text = token.content;
+      const text = token.content;
       let pos = 0;
-      let max = text.length;
+      const max = text.length;
       /* eslint no-labels:0,block-scoped-var:0 */      OUTER: while (pos < max) {
         QUOTE_RE.lastIndex = pos;
         const t = QUOTE_RE.exec(text);
@@ -2454,8 +2507,8 @@
             break;
           }
         }
-        const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
-        const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
+        const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar);
+        const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar);
         const isLastWhiteSpace = isWhiteSpace(lastChar);
         const isNextWhiteSpace = isWhiteSpace(nextChar);
         if (isNextWhiteSpace) {
@@ -2490,7 +2543,7 @@
         if (!canOpen && !canClose) {
           // middle of word
           if (isSingle) {
-            token.content = replaceAt(token.content, t.index, APOSTROPHE);
+            addReplacement(replacements, i, t.index, APOSTROPHE);
           }
           continue;
         }
@@ -2512,17 +2565,8 @@
                 openQuote = state.md.options.quotes[0];
                 closeQuote = state.md.options.quotes[1];
               }
-              // replace token.content *before* tokens[item.token].content,
-              // because, if they are pointing at the same token, replaceAt
-              // could mess up indices when quote length != 1
-                            token.content = replaceAt(token.content, t.index, closeQuote);
-              tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, openQuote);
-              pos += closeQuote.length - 1;
-              if (item.token === i) {
-                pos += openQuote.length - 1;
-              }
-              text = token.content;
-              max = text.length;
+              addReplacement(replacements, i, t.index, closeQuote);
+              addReplacement(replacements, item.token, item.pos, openQuote);
               stack.length = j;
               continue OUTER;
             }
@@ -2536,10 +2580,13 @@
             level: thisLevel
           });
         } else if (canClose && isSingle) {
-          token.content = replaceAt(token.content, t.index, APOSTROPHE);
+          addReplacement(replacements, i, t.index, APOSTROPHE);
         }
       }
     }
+    Object.keys(replacements).forEach(function(tokenIdx) {
+      tokens[tokenIdx].content = applyReplacements(tokens[tokenIdx].content, replacements[tokenIdx]);
+    });
   }
   function smartquotes(state) {
     /* eslint max-depth:0 */
@@ -3889,12 +3936,22 @@
       return HTML_SEQUENCES[i][2];
     }
     let nextLine = startLine + 1;
+    // Block types 6 and 7 (the only ones whose end condition is a blank line)
+    // have `/^$/` as their closing regexp. For all other types (1-5, e.g.
+    // `<!--` comments), a blank line is regular content and must not terminate
+    // the block - it ends only when its closing sequence is found.
+        const endsOnBlankLine = HTML_SEQUENCES[i][1].test("");
     // If we are here - we detected HTML block.
     // Let's roll down till block end.
         if (!HTML_SEQUENCES[i][1].test(lineText)) {
       for (;nextLine < endLine; nextLine++) {
         if (state.sCount[nextLine] < state.blkIndent) {
-          break;
+          // An outdented blank line shouldn't end a block that doesn't end on a
+          // blank line (e.g. a `<!--` comment inside a list item). Such blocks
+          // must continue until their closing sequence regardless of indent.
+          if (endsOnBlankLine || !state.isEmpty(nextLine)) {
+            break;
+          }
         }
         pos = state.bMarks[nextLine] + state.tShift[nextLine];
         max = state.eMarks[nextLine];
@@ -3950,7 +4007,7 @@
     token_o.markup = "########".slice(0, level);
     token_o.map = [ startLine, state.line ];
     const token_i = state.push("inline", "", 0);
-    token_i.content = state.src.slice(pos, max).trim();
+    token_i.content = asciiTrim(state.src.slice(pos, max));
     token_i.map = [ startLine, state.line ];
     token_i.children = [];
     const token_c = state.push("heading_close", "h" + String(level), -1);
@@ -4013,9 +4070,10 @@
     }
     if (!level) {
       // Didn't find valid underline
+      state.parentType = oldParentType;
       return false;
     }
-    const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
+    const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false));
     state.line = nextLine + 1;
     const token_o = state.push("heading_open", "h" + String(level), 1);
     token_o.markup = String.fromCharCode(marker);
@@ -4058,7 +4116,7 @@
         break;
       }
     }
-    const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
+    const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false));
     state.line = nextLine;
     const token_o = state.push("paragraph_open", "p", 1);
     token_o.map = [ startLine, state.line ];
@@ -4237,17 +4295,45 @@
     StateInline.prototype.scanDelims = function(start, canSplitWord) {
     const max = this.posMax;
     const marker = this.src.charCodeAt(start);
-    // treat beginning of the line as a whitespace
-        const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 32;
+    // Astral characters below are combined manually, because .codePointAt()
+    // does not guarantee numeric type output. And we don't wish JIT cache issues.
+    // The broken surrogate pairs are evaluated as U+FFFD to prevent possible
+    // crashes.
+        let lastChar;
+    if (start === 0) {
+      // treat beginning of the line as a whitespace
+      lastChar = 32;
+    } else if (start === 1) {
+      lastChar = this.src.charCodeAt(0);
+      if ((lastChar & 63488) === 55296) {
+        lastChar = 65533;
+      }
+    } else {
+      lastChar = this.src.charCodeAt(start - 1);
+      if ((lastChar & 64512) === 56320) {
+        // low surrogate => add high one, replace broken pair with U+FFFD
+        const highSurr = this.src.charCodeAt(start - 2);
+        lastChar = (highSurr & 64512) === 55296 ? 65536 + (highSurr - 55296 << 10) + (lastChar - 56320) : 65533;
+      } else if ((lastChar & 64512) === 55296) {
+        lastChar = 65533;
+      }
+    }
     let pos = start;
     while (pos < max && this.src.charCodeAt(pos) === marker) {
       pos++;
     }
     const count = pos - start;
     // treat end of the line as a whitespace
-        const nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
-    const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
-    const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
+        let nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
+    if ((nextChar & 64512) === 55296) {
+      // high surrogate => add low one, replace broken pair with U+FFFD
+      const lowSurr = this.src.charCodeAt(pos + 1);
+      nextChar = (lowSurr & 64512) === 56320 ? 65536 + (nextChar - 55296 << 10) + (lowSurr - 56320) : 65533;
+    } else if ((nextChar & 64512) === 56320) {
+      nextChar = 65533;
+    }
+    const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar);
+    const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar);
     const isLastWhiteSpace = isWhiteSpace(lastChar);
     const isNextWhiteSpace = isWhiteSpace(nextChar);
     const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
@@ -5104,7 +5190,7 @@
     } else {
       const match = state.src.slice(pos).match(NAMED_RE);
       if (match) {
-        const decoded = decodeHTML(match[0]);
+        const decoded = decodeHTMLStrict(match[0]);
         if (decoded !== match[0]) {
           if (!silent) {
             const token = state.push("text_special", "", 0);
@@ -6781,7 +6867,7 @@
    * ```javascript
    * var md = require('markdown-it')()
    *             .set({ html: true, breaks: true })
-   *             .set({ typographer, true });
+   *             .set({ typographer: true });
    * ```
    *
    * __Note:__ To achieve the best possible performance, don't modify a