@simon_he/vue-tui 1.1.13 → 1.1.14

package/dist/markdown.cjs

@@ -1292,7 +1292,7 @@ function loadBuiltinMathRasterizer() {
   })()), builtinRasterizerLoad;
 }
 
-// node_modules/.pnpm/stream-markdown-parser@1.2.19/node_modules/stream-markdown-parser/dist/index.js
+// node_modules/.pnpm/stream-markdown-parser@1.2.20/node_modules/stream-markdown-parser/dist/index.js
 var __create2 = Object.create, __defProp$1 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __getProtoOf2 = Object.getPrototypeOf, __hasOwnProp2 = Object.prototype.hasOwnProperty, __commonJS = (cb, mod) => function() {
   return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 }, __export$1 = (all) => {
@@ -1675,7 +1675,756 @@ var require_markdown_it_task_checkbox = /* @__PURE__ */ __commonJS({ "../../node
   function startsWithTodoMarkdown(token) {
     return /^\[[xX \u00A0]\][ \u00A0]/.test(token.content);
   }
-} }), decodeMap = /* @__PURE__ */ new Map([
+} }), import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM2(require_markdown_it_task_checkbox(), 1), ambiguousMinimalCodePoint = 161, ambiguousMaximumCodePoint = 1114109, ambiguousRanges = [
+  161,
+  161,
+  164,
+  164,
+  167,
+  168,
+  170,
+  170,
+  173,
+  174,
+  176,
+  180,
+  182,
+  186,
+  188,
+  191,
+  198,
+  198,
+  208,
+  208,
+  215,
+  216,
+  222,
+  225,
+  230,
+  230,
+  232,
+  234,
+  236,
+  237,
+  240,
+  240,
+  242,
+  243,
+  247,
+  250,
+  252,
+  252,
+  254,
+  254,
+  257,
+  257,
+  273,
+  273,
+  275,
+  275,
+  283,
+  283,
+  294,
+  295,
+  299,
+  299,
+  305,
+  307,
+  312,
+  312,
+  319,
+  322,
+  324,
+  324,
+  328,
+  331,
+  333,
+  333,
+  338,
+  339,
+  358,
+  359,
+  363,
+  363,
+  462,
+  462,
+  464,
+  464,
+  466,
+  466,
+  468,
+  468,
+  470,
+  470,
+  472,
+  472,
+  474,
+  474,
+  476,
+  476,
+  593,
+  593,
+  609,
+  609,
+  708,
+  708,
+  711,
+  711,
+  713,
+  715,
+  717,
+  717,
+  720,
+  720,
+  728,
+  731,
+  733,
+  733,
+  735,
+  735,
+  768,
+  879,
+  913,
+  929,
+  931,
+  937,
+  945,
+  961,
+  963,
+  969,
+  1025,
+  1025,
+  1040,
+  1103,
+  1105,
+  1105,
+  8208,
+  8208,
+  8211,
+  8214,
+  8216,
+  8217,
+  8220,
+  8221,
+  8224,
+  8226,
+  8228,
+  8231,
+  8240,
+  8240,
+  8242,
+  8243,
+  8245,
+  8245,
+  8251,
+  8251,
+  8254,
+  8254,
+  8308,
+  8308,
+  8319,
+  8319,
+  8321,
+  8324,
+  8364,
+  8364,
+  8451,
+  8451,
+  8453,
+  8453,
+  8457,
+  8457,
+  8467,
+  8467,
+  8470,
+  8470,
+  8481,
+  8482,
+  8486,
+  8486,
+  8491,
+  8491,
+  8531,
+  8532,
+  8539,
+  8542,
+  8544,
+  8555,
+  8560,
+  8569,
+  8585,
+  8585,
+  8592,
+  8601,
+  8632,
+  8633,
+  8658,
+  8658,
+  8660,
+  8660,
+  8679,
+  8679,
+  8704,
+  8704,
+  8706,
+  8707,
+  8711,
+  8712,
+  8715,
+  8715,
+  8719,
+  8719,
+  8721,
+  8721,
+  8725,
+  8725,
+  8730,
+  8730,
+  8733,
+  8736,
+  8739,
+  8739,
+  8741,
+  8741,
+  8743,
+  8748,
+  8750,
+  8750,
+  8756,
+  8759,
+  8764,
+  8765,
+  8776,
+  8776,
+  8780,
+  8780,
+  8786,
+  8786,
+  8800,
+  8801,
+  8804,
+  8807,
+  8810,
+  8811,
+  8814,
+  8815,
+  8834,
+  8835,
+  8838,
+  8839,
+  8853,
+  8853,
+  8857,
+  8857,
+  8869,
+  8869,
+  8895,
+  8895,
+  8978,
+  8978,
+  9312,
+  9449,
+  9451,
+  9547,
+  9552,
+  9587,
+  9600,
+  9615,
+  9618,
+  9621,
+  9632,
+  9633,
+  9635,
+  9641,
+  9650,
+  9651,
+  9654,
+  9655,
+  9660,
+  9661,
+  9664,
+  9665,
+  9670,
+  9672,
+  9675,
+  9675,
+  9678,
+  9681,
+  9698,
+  9701,
+  9711,
+  9711,
+  9733,
+  9734,
+  9737,
+  9737,
+  9742,
+  9743,
+  9756,
+  9756,
+  9758,
+  9758,
+  9792,
+  9792,
+  9794,
+  9794,
+  9824,
+  9825,
+  9827,
+  9829,
+  9831,
+  9834,
+  9836,
+  9837,
+  9839,
+  9839,
+  9886,
+  9887,
+  9919,
+  9919,
+  9926,
+  9933,
+  9935,
+  9939,
+  9941,
+  9953,
+  9955,
+  9955,
+  9960,
+  9961,
+  9963,
+  9969,
+  9972,
+  9972,
+  9974,
+  9977,
+  9979,
+  9980,
+  9982,
+  9983,
+  10045,
+  10045,
+  10102,
+  10111,
+  11094,
+  11097,
+  12872,
+  12879,
+  57344,
+  63743,
+  65024,
+  65039,
+  65533,
+  65533,
+  127232,
+  127242,
+  127248,
+  127277,
+  127280,
+  127337,
+  127344,
+  127373,
+  127375,
+  127376,
+  127387,
+  127404,
+  917760,
+  917999,
+  983040,
+  1048573,
+  1048576,
+  1114109
+], fullwidthMinimalCodePoint = 12288, fullwidthMaximumCodePoint = 65510, fullwidthRanges = [
+  12288,
+  12288,
+  65281,
+  65376,
+  65504,
+  65510
+], halfwidthMinimalCodePoint = 8361, halfwidthMaximumCodePoint = 65518, halfwidthRanges = [
+  8361,
+  8361,
+  65377,
+  65470,
+  65474,
+  65479,
+  65482,
+  65487,
+  65490,
+  65495,
+  65498,
+  65500,
+  65512,
+  65518
+], narrowMinimalCodePoint = 32, narrowMaximumCodePoint = 10630, narrowRanges = [
+  32,
+  126,
+  162,
+  163,
+  165,
+  166,
+  172,
+  172,
+  175,
+  175,
+  10214,
+  10221,
+  10629,
+  10630
+], wideMinimalCodePoint = 4352, wideMaximumCodePoint = 262141, wideRanges = [
+  4352,
+  4447,
+  8986,
+  8987,
+  9001,
+  9002,
+  9193,
+  9196,
+  9200,
+  9200,
+  9203,
+  9203,
+  9725,
+  9726,
+  9748,
+  9749,
+  9776,
+  9783,
+  9800,
+  9811,
+  9855,
+  9855,
+  9866,
+  9871,
+  9875,
+  9875,
+  9889,
+  9889,
+  9898,
+  9899,
+  9917,
+  9918,
+  9924,
+  9925,
+  9934,
+  9934,
+  9940,
+  9940,
+  9962,
+  9962,
+  9970,
+  9971,
+  9973,
+  9973,
+  9978,
+  9978,
+  9981,
+  9981,
+  9989,
+  9989,
+  9994,
+  9995,
+  10024,
+  10024,
+  10060,
+  10060,
+  10062,
+  10062,
+  10067,
+  10069,
+  10071,
+  10071,
+  10133,
+  10135,
+  10160,
+  10160,
+  10175,
+  10175,
+  11035,
+  11036,
+  11088,
+  11088,
+  11093,
+  11093,
+  11904,
+  11929,
+  11931,
+  12019,
+  12032,
+  12245,
+  12272,
+  12287,
+  12289,
+  12350,
+  12353,
+  12438,
+  12441,
+  12543,
+  12549,
+  12591,
+  12593,
+  12686,
+  12688,
+  12773,
+  12783,
+  12830,
+  12832,
+  12871,
+  12880,
+  42124,
+  42128,
+  42182,
+  43360,
+  43388,
+  44032,
+  55203,
+  63744,
+  64255,
+  65040,
+  65049,
+  65072,
+  65106,
+  65108,
+  65126,
+  65128,
+  65131,
+  94176,
+  94180,
+  94192,
+  94198,
+  94208,
+  101589,
+  101631,
+  101662,
+  101760,
+  101874,
+  110576,
+  110579,
+  110581,
+  110587,
+  110589,
+  110590,
+  110592,
+  110882,
+  110898,
+  110898,
+  110928,
+  110930,
+  110933,
+  110933,
+  110948,
+  110951,
+  110960,
+  111355,
+  119552,
+  119638,
+  119648,
+  119670,
+  126980,
+  126980,
+  127183,
+  127183,
+  127374,
+  127374,
+  127377,
+  127386,
+  127488,
+  127490,
+  127504,
+  127547,
+  127552,
+  127560,
+  127568,
+  127569,
+  127584,
+  127589,
+  127744,
+  127776,
+  127789,
+  127797,
+  127799,
+  127868,
+  127870,
+  127891,
+  127904,
+  127946,
+  127951,
+  127955,
+  127968,
+  127984,
+  127988,
+  127988,
+  127992,
+  128062,
+  128064,
+  128064,
+  128066,
+  128252,
+  128255,
+  128317,
+  128331,
+  128334,
+  128336,
+  128359,
+  128378,
+  128378,
+  128405,
+  128406,
+  128420,
+  128420,
+  128507,
+  128591,
+  128640,
+  128709,
+  128716,
+  128716,
+  128720,
+  128722,
+  128725,
+  128728,
+  128732,
+  128735,
+  128747,
+  128748,
+  128756,
+  128764,
+  128992,
+  129003,
+  129008,
+  129008,
+  129292,
+  129338,
+  129340,
+  129349,
+  129351,
+  129535,
+  129648,
+  129660,
+  129664,
+  129674,
+  129678,
+  129734,
+  129736,
+  129736,
+  129741,
+  129756,
+  129759,
+  129770,
+  129775,
+  129784,
+  131072,
+  196605,
+  196608,
+  262141
+], isInRange = (ranges, codePoint) => {
+  let low = 0, high = Math.floor(ranges.length / 2) - 1;
+  for (; low <= high; ) {
+    let mid = Math.floor((low + high) / 2), i = mid * 2;
+    if (codePoint < ranges[i])
+      high = mid - 1;
+    else if (codePoint > ranges[i + 1])
+      low = mid + 1;
+    else
+      return !0;
+  }
+  return !1;
+}, commonCjkCodePoint = 19968, [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0], fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    let start = ranges[index], end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end)
+      return [start, end];
+    end - start > fastPathEnd - fastPathStart && (fastPathStart = start, fastPathEnd = end);
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var isAmbiguous = (codePoint) => codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint ? !1 : isInRange(ambiguousRanges, codePoint), isFullWidth = (codePoint) => codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint ? !1 : isInRange(fullwidthRanges, codePoint), isHalfWidth = (codePoint) => codePoint < halfwidthMinimalCodePoint || codePoint > halfwidthMaximumCodePoint ? !1 : isInRange(halfwidthRanges, codePoint), isNarrow = (codePoint) => codePoint < narrowMinimalCodePoint || codePoint > narrowMaximumCodePoint ? !1 : isInRange(narrowRanges, codePoint), isWide = (codePoint) => codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd ? !0 : codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint ? !1 : isInRange(wideRanges, codePoint);
+function getCategory(codePoint) {
+  return isAmbiguous(codePoint) ? "ambiguous" : isFullWidth(codePoint) ? "fullwidth" : isHalfWidth(codePoint) ? "halfwidth" : isNarrow(codePoint) ? "narrow" : isWide(codePoint) ? "wide" : "neutral";
+}
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint))
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+}
+function eastAsianWidthType(codePoint) {
+  return validate(codePoint), getCategory(codePoint);
+}
+function isEmoji(uc) {
+  return /^\p{Emoji_Presentation}/u.test(String.fromCodePoint(uc));
+}
+function isCjkBase(uc) {
+  if (uc < 4352)
+    return !1;
+  switch (eastAsianWidthType(uc)) {
+    case "fullwidth":
+    case "halfwidth":
+      return !0;
+    case "wide":
+      return !isEmoji(uc);
+    case "narrow":
+      return !1;
+    case "ambiguous":
+      return null;
+    case "neutral":
+      return /^\p{sc=Hangul}/u.test(String.fromCodePoint(uc));
+  }
+}
+function is2PreviousCjk(uc, prev) {
+  return isCjkBase(uc) ?? (prev === 65025 && isQuotationMark(uc));
+  function isQuotationMark(uc$1) {
+    return uc$1 === 8216 || uc$1 === 8217 || uc$1 === 8220 || uc$1 === 8221;
+  }
+}
+function isPreviousCjk(uc) {
+  return isCjkBase(uc) ?? (917760 <= uc && uc <= 917999);
+}
+function isNextCjk(uc) {
+  return isCjkBase(uc) ?? !1;
+}
+function nonEmojiGeneralUseVS(uc) {
+  return uc >= 65024 && uc <= 65038;
+}
+function markdownItCjkFriendlyPlugin(md) {
+  let PreviousState = md.inline.State;
+  class CjkFriendlyState extends PreviousState {
+    scanDelims(start, canSplitWord) {
+      let max = this.posMax, marker = this.src.charCodeAt(start), [lastChar, lastCharPos] = getLastCharCode(this.src, start), lastMainChar = lastChar, twoPrevChar = null;
+      nonEmojiGeneralUseVS(lastChar) && (twoPrevChar = getLastCharCode(this.src, lastCharPos)[0], /^\p{Zs}/u.test(String.fromCodePoint(twoPrevChar)) || (lastMainChar = twoPrevChar));
+      let pos = start;
+      for (; pos < max && this.src.charCodeAt(pos) === marker; )
+        pos++;
+      let count = pos - start, nextChar = pos < max ? this.src.codePointAt(pos) : 32, isLastWhiteSpace = md.utils.isWhiteSpace(lastMainChar), isNextWhiteSpace = md.utils.isWhiteSpace(nextChar);
+      if (isLastWhiteSpace || isNextWhiteSpace)
+        return {
+          can_open: !isNextWhiteSpace,
+          can_close: !isLastWhiteSpace,
+          length: count
+        };
+      let isLastPunctChar = md.utils.isMdAsciiPunct(lastMainChar) || md.utils.isPunctChar(String.fromCodePoint(lastMainChar)), isNextPunctChar = md.utils.isMdAsciiPunct(nextChar) || md.utils.isPunctChar(String.fromCodePoint(nextChar)), left_flanking = isLastPunctChar, right_flanking = isNextPunctChar;
+      if (canSplitWord) {
+        let isEitherCJKChar = isNextCjk(nextChar) || (twoPrevChar !== null ? is2PreviousCjk(twoPrevChar, lastChar) : isPreviousCjk(lastChar));
+        left_flanking || (left_flanking = isEitherCJKChar || !isNextPunctChar), right_flanking || (right_flanking = isEitherCJKChar || !isLastPunctChar);
+      }
+      return {
+        can_open: left_flanking,
+        can_close: right_flanking,
+        length: count
+      };
+      function getLastCharCode(str, pos$1) {
+        if (pos$1 <= 0)
+          return [32, -1];
+        let charCode = str.charCodeAt(pos$1 - 1);
+        if ((charCode & 64512) !== 56320)
+          return [charCode, pos$1 - 1];
+        let codePoint = str.codePointAt(pos$1 - 2);
+        return codePoint > 65535 ? [codePoint, pos$1 - 2] : [charCode, pos$1 - 1];
+      }
+    }
+  }
+  md.inline.State = CjkFriendlyState;
+}
+var decodeMap = /* @__PURE__ */ new Map([
   [0, 65533],
   [128, 8364],
   [130, 8218],
@@ -1997,7 +2746,7 @@ var htmlDecoder = /* @__PURE__ */ getDecoder(htmlDecodeTree);
 function decodeHTML(htmlString, mode = DecodingMode.Legacy) {
   return htmlDecoder(htmlString, mode);
 }
-var import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM2(require_markdown_it_task_checkbox(), 1), decodeCache = {};
+var decodeCache = {};
 function getDecodeCache(exclude) {
   let cache = decodeCache[exclude];
   if (cache)
@@ -4466,6 +5215,13 @@ var ParserInline = class {
   constructor() {
     __publicField(this, "ruler");
     __publicField(this, "ruler2");
+    /**
+    * State class used for inline parsing, mirroring `ParserInline.prototype.State` in
+    * markdown-it. Plugins subclass it (`scanDelims`, `push`, `pushPending`, ...) and assign
+    * the subclass back to `md.inline.State`; the parser then constructs it with
+    * `new this.State(...)`.
+    */
+    __publicField(this, "State", StateInline);
     __publicField(this, "cachedRulesVersion", -1);
     __publicField(this, "cachedRules", []);
     __publicField(this, "cachedRules2Version", -1);
@@ -4572,13 +5328,20 @@ var ParserInline = class {
   isDefaultRuleset() {
     return this.ruler.version === this.defaultRulerVersion && this.ruler2.version === this.defaultRuler2Version;
   }
+  /**
+  * Whether inline parsing still uses the stock `StateInline`. The plain-text fast paths
+  * construct no state at all, so they must stand down once a plugin replaces `State`.
+  */
+  usesDefaultState() {
+    return this.State === StateInline;
+  }
   parseSource(src, md, env, outTokens) {
-    if (typeof src == "string" && src.length > 0 && this.isDefaultRuleset() && isPlainInlineText$1(src)) {
+    if (typeof src == "string" && src.length > 0 && this.isDefaultRuleset() && this.usesDefaultState() && isPlainInlineText$1(src)) {
       let token = new Token("text", "", 0);
       token.content = src, outTokens.push(token);
       return;
     }
-    let state = new StateInline(src, md, env, outTokens);
+    let state = new this.State(src, md, env, outTokens);
     this.tokenize(state);
     let rules2 = this.getRules2(), len = rules2.length;
     if (!(state.env && (Object.prototype.hasOwnProperty.call(state.env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(state.env, "__mdtsProfileRules")))) {
@@ -4605,7 +5368,7 @@ var ParserInline = class {
   }
 };
 function inline(state) {
-  let tokens = state.tokens, canUsePlainTextFastPath = !!state.md?.inline?.isDefaultRuleset?.();
+  let tokens = state.tokens, inlineParser = state.md?.inline, canUsePlainTextFastPath = !!inlineParser?.isDefaultRuleset?.() && inlineParser?.usesDefaultState?.() !== !1;
   for (let i = 0, l = tokens.length; i < l; i++) {
     let tok = tokens[i];
     if (tok.type === "inline" && state.md) {
@@ -9541,11 +10304,12 @@ function getParserRuleVersions(md) {
     core: md.core.ruler.version,
     block: md.block.ruler.version,
     inline: md.inline.ruler.version,
-    inline2: md.inline.ruler2.version
+    inline2: md.inline.ruler2.version,
+    inlineState: md.inline.State
   };
 }
 function hasParserRuleChanges(md, initial) {
-  return md.core.ruler.version !== initial.core || md.block.ruler.version !== initial.block || md.inline.ruler.version !== initial.inline || md.inline.ruler2.version !== initial.inline2;
+  return md.core.ruler.version !== initial.core || md.block.ruler.version !== initial.block || md.inline.ruler.version !== initial.inline || md.inline.ruler2.version !== initial.inline2 || md.inline.State !== initial.inlineState;
 }
 function applyExperimentalOptions(options) {
   return options.experimental ? {
@@ -10234,7 +10998,7 @@ function container_plugin(md, name, options) {
     return tokens[idx].nesting === 1 && tokens[idx].attrJoin("class", name), slf.renderToken(tokens, idx, _options, env, slf);
   }
   options = options || {};
-  let min_markers = 3, marker_str = options.marker || ":", marker_char = marker_str.charCodeAt(0), marker_len = marker_str.length, validate = options.validate || validateDefault, render = options.render || renderDefault;
+  let min_markers = 3, marker_str = options.marker || ":", marker_char = marker_str.charCodeAt(0), marker_len = marker_str.length, validate$1 = options.validate || validateDefault, render = options.render || renderDefault;
   function container(state, startLine, endLine, silent) {
     let pos, auto_closed = !1, start = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
     if (marker_char !== state.src.charCodeAt(start))
@@ -10246,7 +11010,7 @@ function container_plugin(md, name, options) {
       return !1;
     pos -= (pos - start) % marker_len;
     let markup = state.src.slice(start, pos), params = state.src.slice(pos, max);
-    if (!validate(params, markup))
+    if (!validate$1(params, markup))
       return !1;
     if (silent)
       return !0;
@@ -11611,6 +12375,21 @@ function setSyntheticLinkOrigin(token, origin) {
 function readSyntheticLinkOrigin(token) {
   return syntheticLinkOrigins.get(token);
 }
+function resolveLinkMarkup(token) {
+  if (!token)
+    return "";
+  let origin = readSyntheticLinkOrigin(token);
+  if (origin === "linkify" || origin === "autolink")
+    return origin;
+  let markup = typeof token.markup == "string" ? token.markup : "";
+  return markup === "linkify" || markup === "autolink" ? markup : "";
+}
+function copySyntheticLinkOrigin(from, to) {
+  if (!from || !to)
+    return;
+  let origin = readSyntheticLinkOrigin(from);
+  origin && syntheticLinkOrigins.set(to, origin);
+}
 function registerCacheStableLinkValidator(validateLink$1) {
   cacheStableLinkValidators.add(validateLink$1);
 }
@@ -11848,7 +12627,7 @@ function fixLinkToken(tokens, raw) {
       } else if (curToken?.type === "text" && curToken.content?.endsWith("(") && tokens[i + 1]?.type === "link_open") {
         let match = curToken.content.match(/\[([^\]]+)\]/);
         if (match) {
-          let beforeText = curToken.content.slice(0, match.index), emphasisMatch = beforeText.match(/(\*+)$/), origin = getSyntheticLinkOrigin(tokens[i + 1]?.markup), replacerTokens = [];
+          let beforeText = curToken.content.slice(0, match.index), emphasisMatch = beforeText.match(/(\*+)$/), linkOpenMarkup = tokens[i + 1]?.markup, origin = (linkOpenMarkup === "linkify" || linkOpenMarkup === "autolink") && (match.index ?? 0) + match[0].length === curToken.content.length - 1 ? "explicit" : getSyntheticLinkOrigin(linkOpenMarkup), replacerTokens = [];
           if (emphasisMatch) {
             beforeText = beforeText.slice(0, emphasisMatch.index), beforeText && replacerTokens.push(textToken(beforeText));
             let text$1 = match[1], type = emphasisMatch[1].length;
@@ -13562,7 +14341,7 @@ function factory(opts = {}) {
     });
     registerCacheStableLinkValidator(validateLink$1), md.set({ validateLink: validateLink$1 });
   }
-  return applyInlineUrlValidation(md), applyLinkifyCandidateFilter(md), (opts.enableMath ?? !0) && applyMath(md, {
+  return applyInlineUrlValidation(md), applyLinkifyCandidateFilter(md), (opts.cjkFriendly ?? !0) && md.use(markdownItCjkFriendlyPlugin), (opts.enableMath ?? !0) && applyMath(md, {
     ...getDefaultMathOptions() ?? {},
     ...opts.mathOptions ?? {}
   }), (opts.enableContainers ?? !0) && applyContainers(md), opts.enableFixIndentedCodeBlock !== !1 && applyFixIndentedCodeBlock(md), applyFixLinkTokens(md), applyFixStrongTokens(md), applyFixListItem(md), applyFixTableTokens(md), applyRenderRules(md), applyFixHtmlInlineTokens(md, { customHtmlTags: opts.customHtmlTags }), md;
@@ -13923,7 +14702,7 @@ function applyNodeSourceMapRange(node, token, endLine, options) {
 }
 function cloneTokenWithMutableChildren(token) {
   let copy = Object.assign(Object.create(Object.getPrototypeOf(token)), token);
-  return Array.isArray(token.attrs) && (copy.attrs = token.attrs.map((attr) => [...attr])), Array.isArray(token.map) && (copy.map = [...token.map]), Array.isArray(token.children) && (copy.children = token.children.map((child) => cloneTokenWithMutableChildren(child))), copy;
+  return Array.isArray(token.attrs) && (copy.attrs = token.attrs.map((attr) => [...attr])), Array.isArray(token.map) && (copy.map = [...token.map]), Array.isArray(token.children) && (copy.children = token.children.map((child) => cloneTokenWithMutableChildren(child))), copySyntheticLinkOrigin(token, copy), copy;
 }
 function isPlainObject(value) {
   if (!value || typeof value != "object")
@@ -14014,6 +14793,10 @@ function canCloneMarkdownTokenFast(token, enumerableKeys) {
   return !0;
 }
 function cloneMarkdownToken(token, cloneObjectFields = !0) {
+  let cloned = cloneMarkdownTokenValue(token, cloneObjectFields);
+  return copySyntheticLinkOrigin(token, cloned), cloned;
+}
+function cloneMarkdownTokenValue(token, cloneObjectFields = !0) {
   if (!cloneObjectFields)
     return cloneTokenWithMutableChildren(token);
   let allKeys = Reflect.ownKeys(token), enumerableKeys = Object.keys(token);
@@ -15491,7 +16274,8 @@ function parseHtmlInlineCodeToken(token, tokens, i, parseInlineTokens$1, raw, pP
       attrs: normalizedAttrs,
       children: normalizedChildren$1,
       loading: !fragment$1.closed,
-      raw: fragment$1.html || code$1
+      raw: fragment$1.html || code$1,
+      markup: "html"
     }, fragment$1.nextIndex];
   }
   if (selfClosing)
@@ -15642,7 +16426,8 @@ function parseLinkToken(tokens, startIndex, parseInlineTokens$1, options) {
       children,
       raw: `[${linkText}](${href}${title ? ` "${title}"` : ""})`,
       loading,
-      attrs: normalizedAttrs
+      attrs: normalizedAttrs,
+      markup: resolveLinkMarkup(openToken)
     },
     nextIndex: i < tokens.length ? i + 1 : tokens.length
   };
@@ -15872,7 +16657,8 @@ function recoverMarkdownLinkFromTrailingText(state, token) {
       content: label,
       raw: label
     }],
-    raw: `[${label}](${href}${linkToken.title ? ` "${linkToken.title}"` : ""})`
+    raw: `[${label}](${href}${linkToken.title ? ` "${linkToken.title}"` : ""})`,
+    markup: resolveLinkMarkup(token)
   }), !0;
 }
 function recoverMarkdownImageFromLoadingImageTail(state, token) {
@@ -15935,7 +16721,8 @@ function buildLoadingOuterImageLinkNode(imageNode, href = "", title = null) {
     text: text$1,
     children: [imageNode],
     raw: `[${text$1}](${href}${title ? ` "${title}"` : ""})`,
-    loading: !0
+    loading: !0,
+    markup: ""
   };
 }
 function buildLoadingImageNodeFromRaw(raw) {
@@ -16059,7 +16846,8 @@ function handleInlineLinkContent(state, content, _token) {
           content: text$1,
           raw: text$1
         }],
-        loading: loading$1
+        loading: loading$1,
+        markup: ""
       }), state.index += index, !0;
     }
     let linkContentEnd = content.indexOf(")", linkEnd), href = linkContentEnd !== -1 ? content.slice(linkEnd + 2, linkContentEnd) : "", loading = linkContentEnd === -1, emphasisMatch = textNodeContent.match(/\*+$/);
@@ -16093,7 +16881,8 @@ function handleInlineLinkContent(state, content, _token) {
           content: text$1,
           raw: text$1
         }],
-        loading
+        loading,
+        markup: ""
       }), type === 1) {
         newTokens.push({
           type: "em_close",
@@ -16137,7 +16926,8 @@ function handleInlineLinkContent(state, content, _token) {
           content: text$1,
           raw: text$1
         }],
-        loading
+        loading,
+        markup: ""
       });
     let afterText = linkContentEnd !== -1 ? content.slice(linkContentEnd + 1) : "";
     return afterText && (state.dispatchToken({
@@ -17000,7 +17790,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
   function pushToken(token) {
     resetCurrentTextNode();
     let node = cloneTokenWithMutableChildren(token);
-    state.result.push(node);
+    node.type === "link" && (node.markup = resolveLinkMarkup(token)), state.result.push(node);
   }
   function pushText(content, raw$1) {
     state.currentTextNode ? (state.currentTextNode.content += content, state.currentTextNode.raw += raw$1 ?? content) : (state.currentTextNode = {