@bgx4k3p/huly-mcp-server 2.2.3 → 2.2.5

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

@@ -205,6 +205,9 @@ function isWhiteSpace(code) {
 function isPunctChar(ch) {
   return ucmicro__namespace.P.test(ch) || ucmicro__namespace.S.test(ch);
 }
+function isPunctCharCode(code) {
+  return isPunctChar(fromCodePoint(code));
+}
 
 // Markdown ASCII punctuation characters.
 //
@@ -267,6 +270,7 @@ function normalizeReference(str) {
   // (remove this when node v10 is no longer supported).
   //
   if ('ẞ'.toLowerCase() === 'Ṿ') {
+    /* c8 ignore next 2 */
     str = str.replace(/ẞ/g, 'ß');
   }
 
@@ -304,6 +308,27 @@ function normalizeReference(str) {
   //
   return str.toLowerCase().toUpperCase();
 }
+function isAsciiTrimmable(c) {
+  return c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;
+}
+
+// "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
@@ -317,6 +342,7 @@ const lib = {
 var utils = /*#__PURE__*/Object.freeze({
   __proto__: null,
   arrayReplaceAt: arrayReplaceAt,
+  asciiTrim: asciiTrim,
   assign: assign,
   escapeHtml: escapeHtml,
   escapeRE: escapeRE,
@@ -324,6 +350,7 @@ var utils = /*#__PURE__*/Object.freeze({
   has: has,
   isMdAsciiPunct: isMdAsciiPunct,
   isPunctChar: isPunctChar,
+  isPunctCharCode: isPunctCharCode,
   isSpace: isSpace,
   isString: isString,
   isValidEntityCode: isValidEntityCode,
@@ -1617,12 +1644,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,
+    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;
@@ -1635,9 +1681,9 @@ function process_inlines(tokens, state) {
     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) {
@@ -1682,8 +1728,8 @@ function process_inlines(tokens, state) {
           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) {
@@ -1720,7 +1766,7 @@ function process_inlines(tokens, state) {
       if (!canOpen && !canClose) {
         // middle of word
         if (isSingle) {
-          token.content = replaceAt(token.content, t.index, APOSTROPHE);
+          addReplacement(replacements, i, t.index, APOSTROPHE);
         }
         continue;
       }
@@ -1742,18 +1788,8 @@ function process_inlines(tokens, state) {
               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;
           }
@@ -1767,10 +1803,13 @@ function process_inlines(tokens, state) {
           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 */
@@ -3230,12 +3269,23 @@ function html_block(state, startLine, endLine, silent) {
   }
   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];
@@ -3296,7 +3346,7 @@ function heading(state, startLine, endLine, silent) {
   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);
@@ -3365,9 +3415,10 @@ function lheading(state, startLine, endLine /*, silent */) {
   }
   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);
@@ -3415,7 +3466,7 @@ function paragraph(state, startLine, endLine) {
       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];
@@ -3619,8 +3670,30 @@ 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) : 0x20;
+  // 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 = 0x20;
+  } else if (start === 1) {
+    lastChar = this.src.charCodeAt(0);
+    if ((lastChar & 0xF800) === 0xD800) {
+      lastChar = 0xFFFD;
+    }
+  } else {
+    lastChar = this.src.charCodeAt(start - 1);
+    if ((lastChar & 0xFC00) === 0xDC00) {
+      // low surrogate => add high one, replace broken pair with U+FFFD
+      const highSurr = this.src.charCodeAt(start - 2);
+      lastChar = (highSurr & 0xFC00) === 0xD800 ? 0x10000 + (highSurr - 0xD800 << 10) + (lastChar - 0xDC00) : 0xFFFD;
+    } else if ((lastChar & 0xFC00) === 0xD800) {
+      lastChar = 0xFFFD;
+    }
+  }
   let pos = start;
   while (pos < max && this.src.charCodeAt(pos) === marker) {
     pos++;
@@ -3628,9 +3701,16 @@ StateInline.prototype.scanDelims = function (start, canSplitWord) {
   const count = pos - start;
 
   // treat end of the line as a whitespace
-  const nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;
-  const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
-  const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
+  let nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;
+  if ((nextChar & 0xFC00) === 0xD800) {
+    // high surrogate => add low one, replace broken pair with U+FFFD
+    const lowSurr = this.src.charCodeAt(pos + 1);
+    nextChar = (lowSurr & 0xFC00) === 0xDC00 ? 0x10000 + (nextChar - 0xD800 << 10) + (lowSurr - 0xDC00) : 0xFFFD;
+  } else if ((nextChar & 0xFC00) === 0xDC00) {
+    nextChar = 0xFFFD;
+  }
+  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);
@@ -4563,7 +4643,7 @@ function entity(state, silent) {
   } else {
     const match = state.src.slice(pos).match(NAMED_RE);
     if (match) {
-      const decoded = entities.decodeHTML(match[0]);
+      const decoded = entities.decodeHTMLStrict(match[0]);
       if (decoded !== match[0]) {
         if (!silent) {
           const token = state.push('text_special', '', 0);
@@ -5342,7 +5422,7 @@ function MarkdownIt(presetName, options) {
  * ```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

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