@quartz-community/remark-obsidian 0.2.3 → 0.2.4

package/dist/index.js

@@ -57,12 +57,12 @@ function propertiesFactory(check) {
     /** @type {Record<string, unknown>} */
     check
   );
-  return castFactory(all);
-  function all(node) {
+  return castFactory(all2);
+  function all2(node2) {
     const nodeAsRecord = (
       /** @type {Record<string, unknown>} */
       /** @type {unknown} */
-      node
+      node2
     );
     let key;
     for (key in check) {
@@ -73,8 +73,8 @@ function propertiesFactory(check) {
 }
 function typeFactory(check) {
   return castFactory(type);
-  function type(node) {
-    return node && node.type === check;
+  function type(node2) {
+    return node2 && node2.type === check;
   }
 }
 function castFactory(testFunction) {
@@ -118,10 +118,10 @@ function visitParents(tree, test, visitor, reverse) {
   const is2 = convert(check);
   const step = reverse ? -1 : 1;
   factory(tree, void 0, [])();
-  function factory(node, index, parents) {
+  function factory(node2, index, parents) {
     const value = (
       /** @type {Record<string, unknown>} */
-      node && typeof node === "object" ? node : {}
+      node2 && typeof node2 === "object" ? node2 : {}
     );
     if (typeof value.type === "string") {
       const name = (
@@ -132,7 +132,7 @@ function visitParents(tree, test, visitor, reverse) {
         )
       );
       Object.defineProperty(visit2, "name", {
-        value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
+        value: "node (" + color(node2.type + (name ? "<" + name + ">" : "")) + ")"
       });
     }
     return visit2;
@@ -141,16 +141,16 @@ function visitParents(tree, test, visitor, reverse) {
       let subresult;
       let offset;
       let grandparents;
-      if (!test || is2(node, index, parents[parents.length - 1] || void 0)) {
-        result = toResult(visitor(node, parents));
+      if (!test || is2(node2, index, parents[parents.length - 1] || void 0)) {
+        result = toResult(visitor(node2, parents));
         if (result[0] === EXIT) {
           return result;
         }
       }
-      if ("children" in node && node.children) {
+      if ("children" in node2 && node2.children) {
         const nodeAsParent = (
           /** @type {UnistParent} */
-          node
+          node2
         );
         if (nodeAsParent.children && result[0] !== SKIP) {
           offset = (reverse ? nodeAsParent.children.length : -1) + step;
@@ -194,10 +194,10 @@ function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
     reverse = maybeReverse;
   }
   visitParents(tree, test, overload, reverse);
-  function overload(node, parents) {
+  function overload(node2, parents) {
     const parent = parents[parents.length - 1];
-    const index = parent ? parent.children.indexOf(node) : void 0;
-    return visitor(node, index, parent);
+    const index = parent ? parent.children.indexOf(node2) : void 0;
+    return visitor(node2, index, parent);
   }
 }
 
@@ -453,8 +453,8 @@ var LEFT_BRACKET = 91;
 var BACKSLASH = 92;
 var RIGHT_BRACKET = 93;
 var PIPE = 124;
-function isLineEnding(code) {
-  return code === codes.lineFeed || code === codes.carriageReturn;
+function isLineEnding(code2) {
+  return code2 === codes.lineFeed || code2 === codes.carriageReturn;
 }
 function wikilinkSyntax() {
   return {
@@ -469,151 +469,151 @@ function tokenize(effects, ok3, nok) {
   let hasHeading = false;
   let hasAlias = false;
   return start;
-  function start(code) {
-    if (code === EXCLAMATION) {
+  function start(code2) {
+    if (code2 === EXCLAMATION) {
       effects.enter("wikilink");
       effects.enter("wikilinkEmbedMarker");
-      effects.consume(code);
+      effects.consume(code2);
       effects.exit("wikilinkEmbedMarker");
       return openFirst;
     }
-    if (code === LEFT_BRACKET) {
+    if (code2 === LEFT_BRACKET) {
       effects.enter("wikilink");
-      return openFirst(code);
+      return openFirst(code2);
     }
-    return nok(code);
+    return nok(code2);
   }
-  function openFirst(code) {
-    if (code !== LEFT_BRACKET) return nok(code);
+  function openFirst(code2) {
+    if (code2 !== LEFT_BRACKET) return nok(code2);
     effects.enter("wikilinkMarker");
-    effects.consume(code);
+    effects.consume(code2);
     return openSecond;
   }
-  function openSecond(code) {
-    if (code !== LEFT_BRACKET) return nok(code);
-    effects.consume(code);
+  function openSecond(code2) {
+    if (code2 !== LEFT_BRACKET) return nok(code2);
+    effects.consume(code2);
     effects.exit("wikilinkMarker");
     return pathStart;
   }
-  function pathStart(code) {
-    if (code === HASH) return headingMarker(code);
-    if (code === PIPE) return nok(code);
-    if (code === RIGHT_BRACKET || code === null || isLineEnding(code))
-      return nok(code);
+  function pathStart(code2) {
+    if (code2 === HASH) return headingMarker(code2);
+    if (code2 === PIPE) return nok(code2);
+    if (code2 === RIGHT_BRACKET || code2 === null || isLineEnding(code2))
+      return nok(code2);
     effects.enter("wikilinkPath");
     hasPath = true;
-    return path(code);
+    return path(code2);
   }
-  function path(code) {
-    if (code === BACKSLASH) {
-      effects.consume(code);
+  function path(code2) {
+    if (code2 === BACKSLASH) {
+      effects.consume(code2);
       return pathEscape;
     }
-    if (code === HASH) {
+    if (code2 === HASH) {
       effects.exit("wikilinkPath");
-      return headingMarker(code);
+      return headingMarker(code2);
     }
-    if (code === PIPE) {
+    if (code2 === PIPE) {
       effects.exit("wikilinkPath");
-      return aliasMarker(code);
+      return aliasMarker(code2);
     }
-    if (code === RIGHT_BRACKET) {
+    if (code2 === RIGHT_BRACKET) {
       effects.exit("wikilinkPath");
-      return closeFirst(code);
+      return closeFirst(code2);
     }
-    if (code === null || isLineEnding(code)) return nok(code);
-    effects.consume(code);
+    if (code2 === null || isLineEnding(code2)) return nok(code2);
+    effects.consume(code2);
     return path;
   }
-  function pathEscape(code) {
-    if (code === PIPE) {
+  function pathEscape(code2) {
+    if (code2 === PIPE) {
       effects.exit("wikilinkPath");
-      return aliasMarker(code);
+      return aliasMarker(code2);
     }
-    if (code === null || isLineEnding(code)) return nok(code);
-    effects.consume(code);
+    if (code2 === null || isLineEnding(code2)) return nok(code2);
+    effects.consume(code2);
     return path;
   }
-  function headingMarker(code) {
-    if (code !== HASH) return nok(code);
+  function headingMarker(code2) {
+    if (code2 !== HASH) return nok(code2);
     effects.enter("wikilinkHeadingMarker");
-    effects.consume(code);
+    effects.consume(code2);
     effects.exit("wikilinkHeadingMarker");
     return headingStart;
   }
-  function headingStart(code) {
-    if (code === null || isLineEnding(code)) return nok(code);
-    if (code === RIGHT_BRACKET) {
+  function headingStart(code2) {
+    if (code2 === null || isLineEnding(code2)) return nok(code2);
+    if (code2 === RIGHT_BRACKET) {
       hasHeading = true;
-      return closeFirst(code);
+      return closeFirst(code2);
     }
-    if (code === PIPE) {
+    if (code2 === PIPE) {
       hasHeading = true;
-      return aliasMarker(code);
+      return aliasMarker(code2);
     }
     effects.enter("wikilinkHeading");
     hasHeading = true;
-    return heading(code);
+    return heading2(code2);
   }
-  function heading(code) {
-    if (code === BACKSLASH) {
-      effects.consume(code);
+  function heading2(code2) {
+    if (code2 === BACKSLASH) {
+      effects.consume(code2);
       return headingEscape;
     }
-    if (code === PIPE) {
+    if (code2 === PIPE) {
       effects.exit("wikilinkHeading");
-      return aliasMarker(code);
+      return aliasMarker(code2);
     }
-    if (code === RIGHT_BRACKET) {
+    if (code2 === RIGHT_BRACKET) {
       effects.exit("wikilinkHeading");
-      return closeFirst(code);
+      return closeFirst(code2);
     }
-    if (code === null || isLineEnding(code)) return nok(code);
-    effects.consume(code);
-    return heading;
+    if (code2 === null || isLineEnding(code2)) return nok(code2);
+    effects.consume(code2);
+    return heading2;
   }
-  function headingEscape(code) {
-    if (code === PIPE) {
+  function headingEscape(code2) {
+    if (code2 === PIPE) {
       effects.exit("wikilinkHeading");
-      return aliasMarker(code);
+      return aliasMarker(code2);
     }
-    if (code === null || isLineEnding(code)) return nok(code);
-    effects.consume(code);
-    return heading;
+    if (code2 === null || isLineEnding(code2)) return nok(code2);
+    effects.consume(code2);
+    return heading2;
   }
-  function aliasMarker(code) {
-    if (code !== PIPE) return nok(code);
+  function aliasMarker(code2) {
+    if (code2 !== PIPE) return nok(code2);
     effects.enter("wikilinkAliasMarker");
-    effects.consume(code);
+    effects.consume(code2);
     effects.exit("wikilinkAliasMarker");
     return aliasStart;
   }
-  function aliasStart(code) {
-    if (code === RIGHT_BRACKET) return closeFirst(code);
-    if (code === null || isLineEnding(code)) return nok(code);
+  function aliasStart(code2) {
+    if (code2 === RIGHT_BRACKET) return closeFirst(code2);
+    if (code2 === null || isLineEnding(code2)) return nok(code2);
     effects.enter("wikilinkAlias");
     hasAlias = true;
-    return alias(code);
+    return alias(code2);
   }
-  function alias(code) {
-    if (code === RIGHT_BRACKET) {
+  function alias(code2) {
+    if (code2 === RIGHT_BRACKET) {
       effects.exit("wikilinkAlias");
-      return closeFirst(code);
+      return closeFirst(code2);
     }
-    if (code === null || isLineEnding(code)) return nok(code);
-    effects.consume(code);
+    if (code2 === null || isLineEnding(code2)) return nok(code2);
+    effects.consume(code2);
     return alias;
   }
-  function closeFirst(code) {
-    if (code !== RIGHT_BRACKET) return nok(code);
-    if (!hasPath && !hasHeading && !hasAlias) return nok(code);
+  function closeFirst(code2) {
+    if (code2 !== RIGHT_BRACKET) return nok(code2);
+    if (!hasPath && !hasHeading && !hasAlias) return nok(code2);
     effects.enter("wikilinkMarker");
-    effects.consume(code);
+    effects.consume(code2);
     return closeSecond;
   }
-  function closeSecond(code) {
-    if (code !== RIGHT_BRACKET) return nok(code);
-    effects.consume(code);
+  function closeSecond(code2) {
+    if (code2 !== RIGHT_BRACKET) return nok(code2);
+    effects.consume(code2);
     effects.exit("wikilinkMarker");
     effects.exit("wikilink");
     return ok3;
@@ -622,8 +622,8 @@ function tokenize(effects, ok3, nok) {
 
 // src/lib/syntax/highlight.ts
 var EQUALS = 61;
-function isLineEnding2(code) {
-  return code === codes.lineFeed || code === codes.carriageReturn;
+function isLineEnding2(code2) {
+  return code2 === codes.lineFeed || code2 === codes.carriageReturn;
 }
 function highlightSyntax() {
   return {
@@ -636,32 +636,32 @@ function tokenize2(effects, ok3, nok) {
   const close = { tokenize: tokenizeClose, partial: true };
   let hasContent = false;
   return start;
-  function start(code) {
-    if (code !== EQUALS) return nok(code);
+  function start(code2) {
+    if (code2 !== EQUALS) return nok(code2);
     effects.enter("highlight");
     effects.enter("highlightMarker");
-    effects.consume(code);
+    effects.consume(code2);
     return openSecond;
   }
-  function openSecond(code) {
-    if (code !== EQUALS) return nok(code);
-    effects.consume(code);
+  function openSecond(code2) {
+    if (code2 !== EQUALS) return nok(code2);
+    effects.consume(code2);
     effects.exit("highlightMarker");
     effects.enter("highlightContent");
     return content;
   }
-  function content(code) {
-    if (code === null || isLineEnding2(code)) return nok(code);
-    if (!hasContent && code === EQUALS) return nok(code);
-    if (code === EQUALS)
-      return effects.attempt(close, closeAfter, contentConsume)(code);
-    effects.consume(code);
+  function content(code2) {
+    if (code2 === null || isLineEnding2(code2)) return nok(code2);
+    if (!hasContent && code2 === EQUALS) return nok(code2);
+    if (code2 === EQUALS)
+      return effects.attempt(close, closeAfter, contentConsume)(code2);
+    effects.consume(code2);
     hasContent = true;
     return content;
   }
-  function contentConsume(code) {
-    if (code === null || isLineEnding2(code)) return nok(code);
-    effects.consume(code);
+  function contentConsume(code2) {
+    if (code2 === null || isLineEnding2(code2)) return nok(code2);
+    effects.consume(code2);
     return content;
   }
   function tokenizeClose(closeEffects, closeOk, closeNok) {
@@ -680,9 +680,9 @@ function tokenize2(effects, ok3, nok) {
       return closeOk;
     }
   }
-  function closeAfter(code) {
+  function closeAfter(code2) {
     effects.exit("highlight");
-    return ok3(code);
+    return ok3(code2);
   }
 }
 
@@ -691,8 +691,8 @@ var PERCENT = 37;
 var LINE_FEED = -4;
 var CARRIAGE_RETURN = -3;
 var CARRIAGE_RETURN_LINE_FEED = -5;
-function isLineEnding3(code) {
-  return code === LINE_FEED || code === CARRIAGE_RETURN || code === CARRIAGE_RETURN_LINE_FEED;
+function isLineEnding3(code2) {
+  return code2 === LINE_FEED || code2 === CARRIAGE_RETURN || code2 === CARRIAGE_RETURN_LINE_FEED;
 }
 var commentFlow = {
   tokenize: tokenizeFlow,
@@ -716,30 +716,30 @@ function commentSyntax() {
 function tokenizeText(effects, ok3, nok) {
   const close = { tokenize: tokenizeClose, partial: true };
   return start;
-  function start(code) {
-    if (code !== PERCENT) return nok(code);
+  function start(code2) {
+    if (code2 !== PERCENT) return nok(code2);
     effects.enter("comment");
     effects.enter("commentMarker");
-    effects.consume(code);
+    effects.consume(code2);
     return openSecond;
   }
-  function openSecond(code) {
-    if (code !== PERCENT) return nok(code);
-    effects.consume(code);
+  function openSecond(code2) {
+    if (code2 !== PERCENT) return nok(code2);
+    effects.consume(code2);
     effects.exit("commentMarker");
     effects.enter("commentContent");
     return content;
   }
-  function content(code) {
-    if (code === null) return nok(code);
-    if (code === PERCENT)
-      return effects.attempt(close, closeAfter, contentConsume)(code);
-    effects.consume(code);
+  function content(code2) {
+    if (code2 === null) return nok(code2);
+    if (code2 === PERCENT)
+      return effects.attempt(close, closeAfter, contentConsume)(code2);
+    effects.consume(code2);
     return content;
   }
-  function contentConsume(code) {
-    if (code === null) return nok(code);
-    effects.consume(code);
+  function contentConsume(code2) {
+    if (code2 === null) return nok(code2);
+    effects.consume(code2);
     return content;
   }
   function tokenizeClose(closeEffects, closeOk, closeNok) {
@@ -758,9 +758,9 @@ function tokenizeText(effects, ok3, nok) {
       return closeOk;
     }
   }
-  function closeAfter(code) {
+  function closeAfter(code2) {
     effects.exit("comment");
-    return ok3(code);
+    return ok3(code2);
   }
 }
 function tokenizeFlow(effects, ok3, nok) {
@@ -770,93 +770,93 @@ function tokenizeFlow(effects, ok3, nok) {
     partial: true
   };
   return start;
-  function start(code) {
-    if (code !== PERCENT) return nok(code);
+  function start(code2) {
+    if (code2 !== PERCENT) return nok(code2);
     effects.enter("comment");
     effects.enter("commentMarker");
-    effects.consume(code);
+    effects.consume(code2);
     return openSecond;
   }
-  function openSecond(code) {
-    if (code !== PERCENT) return nok(code);
-    effects.consume(code);
+  function openSecond(code2) {
+    if (code2 !== PERCENT) return nok(code2);
+    effects.consume(code2);
     effects.exit("commentMarker");
     return afterOpen;
   }
-  function afterOpen(code) {
-    if (code === null) {
+  function afterOpen(code2) {
+    if (code2 === null) {
       effects.exit("comment");
-      return ok3(code);
+      return ok3(code2);
     }
-    if (isLineEnding3(code)) {
+    if (isLineEnding3(code2)) {
       return effects.attempt(
         nonLazyContinuation,
         beforeContentChunk,
         afterLazy
-      )(code);
+      )(code2);
     }
     effects.enter("commentContent");
-    return contentChunk(code);
+    return contentChunk(code2);
   }
-  function beforeContentChunk(code) {
-    if (code === null) {
+  function beforeContentChunk(code2) {
+    if (code2 === null) {
       effects.exit("comment");
-      return ok3(code);
+      return ok3(code2);
     }
-    if (isLineEnding3(code)) {
+    if (isLineEnding3(code2)) {
       return effects.attempt(
         nonLazyContinuation,
         beforeContentChunk,
         afterLazy
-      )(code);
+      )(code2);
     }
-    if (code === PERCENT) {
-      return effects.attempt(flowClose, closeAfter, startContent)(code);
+    if (code2 === PERCENT) {
+      return effects.attempt(flowClose, closeAfter, startContent)(code2);
     }
     effects.enter("commentContent");
-    return contentChunk(code);
+    return contentChunk(code2);
   }
-  function startContent(code) {
+  function startContent(code2) {
     effects.enter("commentContent");
-    effects.consume(code);
+    effects.consume(code2);
     return contentChunk;
   }
-  function contentChunk(code) {
-    if (code === null) {
+  function contentChunk(code2) {
+    if (code2 === null) {
       effects.exit("commentContent");
       effects.exit("comment");
-      return ok3(code);
+      return ok3(code2);
     }
-    if (code === PERCENT) {
-      return effects.attempt(flowClose, closeAfter, contentConsume)(code);
+    if (code2 === PERCENT) {
+      return effects.attempt(flowClose, closeAfter, contentConsume)(code2);
     }
-    if (isLineEnding3(code)) {
+    if (isLineEnding3(code2)) {
       effects.exit("commentContent");
       return effects.attempt(
         nonLazyContinuation,
         beforeContentChunk,
         afterLazy
-      )(code);
+      )(code2);
     }
-    effects.consume(code);
+    effects.consume(code2);
     return contentChunk;
   }
-  function contentConsume(code) {
-    if (code === null) {
+  function contentConsume(code2) {
+    if (code2 === null) {
       effects.exit("commentContent");
       effects.exit("comment");
-      return ok3(code);
+      return ok3(code2);
     }
-    effects.consume(code);
+    effects.consume(code2);
     return contentChunk;
   }
-  function closeAfter(code) {
+  function closeAfter(code2) {
     effects.exit("comment");
-    return ok3(code);
+    return ok3(code2);
   }
-  function afterLazy(code) {
+  function afterLazy(code2) {
     effects.exit("comment");
-    return ok3(code);
+    return ok3(code2);
   }
   function tokenizeFlowClose(closeEffects, closeOk, closeNok) {
     let inContent = false;
@@ -889,18 +889,18 @@ function tokenizeFlow(effects, ok3, nok) {
 function tokenizeNonLazyContinuation(effects, ok3, nok) {
   const self = this;
   return start;
-  function start(code) {
-    if (code === null) {
-      return ok3(code);
+  function start(code2) {
+    if (code2 === null) {
+      return ok3(code2);
     }
-    if (!isLineEnding3(code)) return nok(code);
+    if (!isLineEnding3(code2)) return nok(code2);
     effects.enter("lineEnding");
-    effects.consume(code);
+    effects.consume(code2);
     effects.exit("lineEnding");
     return lineStart;
   }
-  function lineStart(code) {
-    return self.parser.lazy[self.now().line] ? nok(code) : ok3(code);
+  function lineStart(code2) {
+    return self.parser.lazy[self.now().line] ? nok(code2) : ok3(code2);
   }
 }
 
@@ -910,18 +910,18 @@ var SLASH = 47;
 var DASH = 45;
 var UNDERSCORE = 95;
 var tagCharRegex = /[\p{L}\p{M}\p{Emoji}]/u;
-function isWhitespace(code) {
-  return code === codes.space || code === codes.horizontalTab || code === codes.lineFeed || code === codes.carriageReturn || code === codes.carriageReturnLineFeed;
+function isWhitespace(code2) {
+  return code2 === codes.space || code2 === codes.horizontalTab || code2 === codes.lineFeed || code2 === codes.carriageReturn || code2 === codes.carriageReturnLineFeed;
 }
-function isTagChar(code) {
-  if (code === null || code < 0) return false;
-  if (code >= 48 && code <= 57) return true;
-  if (code === DASH || code === UNDERSCORE) return true;
-  return tagCharRegex.test(String.fromCodePoint(code));
+function isTagChar(code2) {
+  if (code2 === null || code2 < 0) return false;
+  if (code2 >= 48 && code2 <= 57) return true;
+  if (code2 === DASH || code2 === UNDERSCORE) return true;
+  return tagCharRegex.test(String.fromCodePoint(code2));
 }
-function isNonDigit(code) {
-  if (code === null) return false;
-  return !(code >= 48 && code <= 57);
+function isNonDigit(code2) {
+  if (code2 === null) return false;
+  return !(code2 >= 48 && code2 <= 57);
 }
 function tagSyntax() {
   return {
@@ -934,47 +934,47 @@ function tokenize3(effects, ok3, nok) {
   let hasNonDigit = false;
   const context = this;
   return start;
-  function start(code) {
+  function start(code2) {
     const previous2 = context.previous;
     const allowedStart = previous2 === null || isWhitespace(previous2) || previous2 === HASH2;
-    if (!allowedStart) return nok(code);
-    if (code !== HASH2) return nok(code);
+    if (!allowedStart) return nok(code2);
+    if (code2 !== HASH2) return nok(code2);
     effects.enter("tag");
     effects.enter("tagMarker");
-    effects.consume(code);
+    effects.consume(code2);
     effects.exit("tagMarker");
     return tagStart;
   }
-  function tagStart(code) {
-    if (!isTagChar(code)) return nok(code);
+  function tagStart(code2) {
+    if (!isTagChar(code2)) return nok(code2);
     effects.enter("tagContent");
-    if (isNonDigit(code)) hasNonDigit = true;
-    effects.consume(code);
+    if (isNonDigit(code2)) hasNonDigit = true;
+    effects.consume(code2);
     return tagContent;
   }
-  function tagContent(code) {
-    if (code === SLASH) {
-      effects.consume(code);
+  function tagContent(code2) {
+    if (code2 === SLASH) {
+      effects.consume(code2);
       return afterSlash;
     }
-    if (isTagChar(code)) {
-      if (isNonDigit(code)) hasNonDigit = true;
-      effects.consume(code);
+    if (isTagChar(code2)) {
+      if (isNonDigit(code2)) hasNonDigit = true;
+      effects.consume(code2);
       return tagContent;
     }
-    return end(code);
+    return end(code2);
   }
-  function afterSlash(code) {
-    if (!isTagChar(code)) return nok(code);
-    if (isNonDigit(code)) hasNonDigit = true;
-    effects.consume(code);
+  function afterSlash(code2) {
+    if (!isTagChar(code2)) return nok(code2);
+    if (isNonDigit(code2)) hasNonDigit = true;
+    effects.consume(code2);
     return tagContent;
   }
-  function end(code) {
-    if (!hasNonDigit) return nok(code);
+  function end(code2) {
+    if (!hasNonDigit) return nok(code2);
     effects.exit("tagContent");
     effects.exit("tag");
-    return ok3(code);
+    return ok3(code2);
   }
 }
 
@@ -996,29 +996,29 @@ function wikilinkFromMarkdown() {
         );
       },
       wikilinkEmbedMarker() {
-        const node = this.stack[this.stack.length - 1];
-        node.embedded = true;
+        const node2 = this.stack[this.stack.length - 1];
+        node2.embedded = true;
       },
       wikilinkPath(token) {
-        const node = this.stack[this.stack.length - 1];
-        node.path = this.sliceSerialize(token).replace(/\\([#\[\]])/g, "$1");
+        const node2 = this.stack[this.stack.length - 1];
+        node2.path = this.sliceSerialize(token).replace(/\\([#\[\]])/g, "$1");
       },
       wikilinkHeading(token) {
-        const node = this.stack[this.stack.length - 1];
-        node.heading = this.sliceSerialize(token).replace(/\\([#\[\]])/g, "$1");
+        const node2 = this.stack[this.stack.length - 1];
+        node2.heading = this.sliceSerialize(token).replace(/\\([#\[\]])/g, "$1");
       },
       wikilinkAlias(token) {
-        const node = this.stack[this.stack.length - 1];
-        node.alias = this.sliceSerialize(token);
+        const node2 = this.stack[this.stack.length - 1];
+        node2.alias = this.sliceSerialize(token);
       }
     },
     exit: {
       wikilink(token) {
-        const node = this.stack[this.stack.length - 1];
-        if (node.alias) {
-          if (node.path.endsWith("\\")) node.path = node.path.slice(0, -1);
-          if (node.heading.endsWith("\\"))
-            node.heading = node.heading.slice(0, -1);
+        const node2 = this.stack[this.stack.length - 1];
+        if (node2.alias) {
+          if (node2.path.endsWith("\\")) node2.path = node2.path.slice(0, -1);
+          if (node2.heading.endsWith("\\"))
+            node2.heading = node2.heading.slice(0, -1);
         }
         this.exit(token);
       }
@@ -1036,8 +1036,8 @@ function highlightFromMarkdown() {
     },
     exit: {
       highlightContent(token) {
-        const node = this.stack[this.stack.length - 1];
-        node.children = [{ type: "text", value: this.sliceSerialize(token) }];
+        const node2 = this.stack[this.stack.length - 1];
+        node2.children = [{ type: "text", value: this.sliceSerialize(token) }];
       },
       highlight(token) {
         this.exit(token);
@@ -1056,8 +1056,8 @@ function commentFromMarkdown() {
     },
     exit: {
       commentContent(token) {
-        const node = this.stack[this.stack.length - 1];
-        node.value += this.sliceSerialize(token);
+        const node2 = this.stack[this.stack.length - 1];
+        node2.value += this.sliceSerialize(token);
       },
       comment(token) {
         this.exit(token);
@@ -1074,8 +1074,8 @@ function tagFromMarkdown() {
         this.enter({ type: "tag", value: "" }, token);
       },
       tagContent(token) {
-        const node = this.stack[this.stack.length - 1];
-        if (node.type === "tag") node.value = this.sliceSerialize(token);
+        const node2 = this.stack[this.stack.length - 1];
+        if (node2.type === "tag") node2.value = this.sliceSerialize(token);
       }
     },
     exit: {
@@ -1090,11 +1090,11 @@ function tagFromMarkdown() {
 function wikilinkToMarkdown() {
   return {
     handlers: {
-      wikilink(node) {
-        const prefix = node.embedded ? "!" : "";
-        const heading = node.heading ? `#${node.heading}` : "";
-        const alias = node.alias ? `|${node.alias}` : "";
-        return `${prefix}[[${node.path}${heading}${alias}]]`;
+      wikilink(node2) {
+        const prefix = node2.embedded ? "!" : "";
+        const heading2 = node2.heading ? `#${node2.heading}` : "";
+        const alias = node2.alias ? `|${node2.alias}` : "";
+        return `${prefix}[[${node2.path}${heading2}${alias}]]`;
       }
     }
   };
@@ -1104,9 +1104,9 @@ function wikilinkToMarkdown() {
 function highlightToMarkdown() {
   return {
     handlers: {
-      highlight(node, _parent, state, info) {
+      highlight(node2, _parent, state, info) {
         const exit = state.enter("highlight");
-        const content = state.containerPhrasing(node, info);
+        const content = state.containerPhrasing(node2, info);
         exit();
         return `==${content}==`;
       }
@@ -1118,8 +1118,8 @@ function highlightToMarkdown() {
 function commentToMarkdown() {
   return {
     handlers: {
-      comment(node) {
-        return `%%${node.value}%%`;
+      comment(node2) {
+        return `%%${node2.value}%%`;
       }
     }
   };
@@ -1129,8 +1129,8 @@ function commentToMarkdown() {
 function tagToMarkdown() {
   return {
     handlers: {
-      tag(node) {
-        return `#${node.value}`;
+      tag(node2) {
+        return `#${node2.value}`;
       }
     }
   };
@@ -1138,37 +1138,37 @@ function tagToMarkdown() {
 
 // src/lib/task-char.ts
 function customTaskCharTransform(tree, source) {
-  visit(tree, "listItem", (node) => {
-    if (typeof node.checked === "boolean") {
-      let char = node.checked ? "x" : " ";
-      if (source && node.position?.start?.offset != null) {
+  visit(tree, "listItem", (node2) => {
+    if (typeof node2.checked === "boolean") {
+      let char = node2.checked ? "x" : " ";
+      if (source && node2.position?.start?.offset != null) {
         const slice = source.slice(
-          node.position.start.offset,
-          node.position.start.offset + 20
+          node2.position.start.offset,
+          node2.position.start.offset + 20
         );
         const m = slice.match(/\[([^\]])\]/);
         if (m) {
           char = m[1];
         }
       }
-      node.data ??= {};
-      node.data.taskChar = char;
-      node.data.hProperties ??= {};
-      node.data.hProperties.dataTaskChar = char;
+      node2.data ??= {};
+      node2.data.taskChar = char;
+      node2.data.hProperties ??= {};
+      node2.data.hProperties.dataTaskChar = char;
       return;
     }
-    const firstChild = node.children?.[0];
+    const firstChild = node2.children?.[0];
     if (!firstChild || firstChild.type !== "paragraph") return;
     const firstText = firstChild.children?.[0];
     if (!firstText || firstText.type !== "text") return;
     const match = firstText.value.match(/^\[([^\]])\]\s/);
     if (!match) return;
     const taskChar = match[1];
-    node.checked = taskChar !== " ";
-    node.data ??= {};
-    node.data.taskChar = taskChar;
-    node.data.hProperties ??= {};
-    node.data.hProperties.dataTaskChar = taskChar;
+    node2.checked = taskChar !== " ";
+    node2.data ??= {};
+    node2.data.taskChar = taskChar;
+    node2.data.hProperties ??= {};
+    node2.data.hProperties.dataTaskChar = taskChar;
     firstText.value = firstText.value.slice(match[0].length);
     if (firstText.value.length === 0) {
       firstChild.children.shift();
@@ -1179,6 +1179,234 @@ function customTaskCharTransform(tree, source) {
   });
 }
 
+// node_modules/mdast-util-to-markdown/lib/handle/blockquote.js
+function blockquote(node2, _, state, info) {
+  const exit = state.enter("blockquote");
+  const tracker = state.createTracker(info);
+  tracker.move("> ");
+  tracker.shift(2);
+  const value = state.indentLines(
+    state.containerFlow(node2, tracker.current()),
+    map
+  );
+  exit();
+  return value;
+}
+function map(line, _, blank) {
+  return ">" + (blank ? "" : " ") + line;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
+function patternInScope(stack, pattern) {
+  return listInScope(stack, pattern.inConstruct, true) && !listInScope(stack, pattern.notInConstruct, false);
+}
+function listInScope(stack, list2, none) {
+  if (typeof list2 === "string") {
+    list2 = [list2];
+  }
+  if (!list2 || list2.length === 0) {
+    return none;
+  }
+  let index = -1;
+  while (++index < list2.length) {
+    if (stack.includes(list2[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/break.js
+function hardBreak(_, _1, state, info) {
+  let index = -1;
+  while (++index < state.unsafe.length) {
+    if (state.unsafe[index].character === "\n" && patternInScope(state.stack, state.unsafe[index])) {
+      return /[ \t]/.test(info.before) ? "" : " ";
+    }
+  }
+  return "\\\n";
+}
+
+// node_modules/longest-streak/index.js
+function longestStreak(value, substring) {
+  const source = String(value);
+  let index = source.indexOf(substring);
+  let expected = index;
+  let count = 0;
+  let max = 0;
+  if (typeof substring !== "string") {
+    throw new TypeError("Expected substring");
+  }
+  while (index !== -1) {
+    if (index === expected) {
+      if (++count > max) {
+        max = count;
+      }
+    } else {
+      count = 1;
+    }
+    expected = index + substring.length;
+    index = source.indexOf(substring, expected);
+  }
+  return max;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js
+function formatCodeAsIndented(node2, state) {
+  return Boolean(
+    state.options.fences === false && node2.value && // If there’s no info…
+    !node2.lang && // And there’s a non-whitespace character…
+    /[^ \r\n]/.test(node2.value) && // And the value doesn’t start or end in a blank…
+    !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node2.value)
+  );
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-fence.js
+function checkFence(state) {
+  const marker = state.options.fence || "`";
+  if (marker !== "`" && marker !== "~") {
+    throw new Error(
+      "Cannot serialize code with `" + marker + "` for `options.fence`, expected `` ` `` or `~`"
+    );
+  }
+  return marker;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/code.js
+function code(node2, _, state, info) {
+  const marker = checkFence(state);
+  const raw = node2.value || "";
+  const suffix = marker === "`" ? "GraveAccent" : "Tilde";
+  if (formatCodeAsIndented(node2, state)) {
+    const exit2 = state.enter("codeIndented");
+    const value2 = state.indentLines(raw, map2);
+    exit2();
+    return value2;
+  }
+  const tracker = state.createTracker(info);
+  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
+  const exit = state.enter("codeFenced");
+  let value = tracker.move(sequence);
+  if (node2.lang) {
+    const subexit = state.enter(`codeFencedLang${suffix}`);
+    value += tracker.move(
+      state.safe(node2.lang, {
+        before: value,
+        after: " ",
+        encode: ["`"],
+        ...tracker.current()
+      })
+    );
+    subexit();
+  }
+  if (node2.lang && node2.meta) {
+    const subexit = state.enter(`codeFencedMeta${suffix}`);
+    value += tracker.move(" ");
+    value += tracker.move(
+      state.safe(node2.meta, {
+        before: value,
+        after: "\n",
+        encode: ["`"],
+        ...tracker.current()
+      })
+    );
+    subexit();
+  }
+  value += tracker.move("\n");
+  if (raw) {
+    value += tracker.move(raw + "\n");
+  }
+  value += tracker.move(sequence);
+  exit();
+  return value;
+}
+function map2(line, _, blank) {
+  return (blank ? "" : "    ") + line;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-quote.js
+function checkQuote(state) {
+  const marker = state.options.quote || '"';
+  if (marker !== '"' && marker !== "'") {
+    throw new Error(
+      "Cannot serialize title with `" + marker + "` for `options.quote`, expected `\"`, or `'`"
+    );
+  }
+  return marker;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/definition.js
+function definition(node2, _, state, info) {
+  const quote = checkQuote(state);
+  const suffix = quote === '"' ? "Quote" : "Apostrophe";
+  const exit = state.enter("definition");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("[");
+  value += tracker.move(
+    state.safe(state.associationId(node2), {
+      before: value,
+      after: "]",
+      ...tracker.current()
+    })
+  );
+  value += tracker.move("]: ");
+  subexit();
+  if (
+    // If there’s no url, or…
+    !node2.url || // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node2.url)
+  ) {
+    subexit = state.enter("destinationLiteral");
+    value += tracker.move("<");
+    value += tracker.move(
+      state.safe(node2.url, { before: value, after: ">", ...tracker.current() })
+    );
+    value += tracker.move(">");
+  } else {
+    subexit = state.enter("destinationRaw");
+    value += tracker.move(
+      state.safe(node2.url, {
+        before: value,
+        after: node2.title ? " " : "\n",
+        ...tracker.current()
+      })
+    );
+  }
+  subexit();
+  if (node2.title) {
+    subexit = state.enter(`title${suffix}`);
+    value += tracker.move(" " + quote);
+    value += tracker.move(
+      state.safe(node2.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    );
+    value += tracker.move(quote);
+    subexit();
+  }
+  exit();
+  return value;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js
+function checkEmphasis(state) {
+  const marker = state.options.emphasis || "*";
+  if (marker !== "*" && marker !== "_") {
+    throw new Error(
+      "Cannot serialize emphasis with `" + marker + "` for `options.emphasis`, expected `*`, or `_`"
+    );
+  }
+  return marker;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js
+function encodeCharacterReference(code2) {
+  return "&#x" + code2.toString(16).toUpperCase() + ";";
+}
+
 // node_modules/micromark-util-character/index.js
 var asciiAlpha = regexCheck(/[A-Za-z]/);
 var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
@@ -1186,19 +1414,786 @@ var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
 var asciiDigit = regexCheck(/\d/);
 var asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
 var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
-function markdownLineEnding(code) {
-  return code !== null && code < -2;
+function markdownLineEnding(code2) {
+  return code2 !== null && code2 < -2;
 }
-function markdownSpace(code) {
-  return code === -2 || code === -1 || code === 32;
+function markdownLineEndingOrSpace(code2) {
+  return code2 !== null && (code2 < 0 || code2 === 32);
+}
+function markdownSpace(code2) {
+  return code2 === -2 || code2 === -1 || code2 === 32;
 }
 var unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
 var unicodeWhitespace = regexCheck(/\s/);
 function regexCheck(regex) {
   return check;
-  function check(code) {
-    return code !== null && code > -1 && regex.test(String.fromCharCode(code));
+  function check(code2) {
+    return code2 !== null && code2 > -1 && regex.test(String.fromCharCode(code2));
+  }
+}
+
+// node_modules/micromark-util-classify-character/index.js
+function classifyCharacter(code2) {
+  if (code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
+    return 1;
+  }
+  if (unicodePunctuation(code2)) {
+    return 2;
+  }
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/encode-info.js
+function encodeInfo(outside, inside, marker) {
+  const outsideKind = classifyCharacter(outside);
+  const insideKind = classifyCharacter(inside);
+  if (outsideKind === void 0) {
+    return insideKind === void 0 ? (
+      // Letter inside:
+      // we have to encode *both* letters for `_` as it is looser.
+      // it already forms for `*` (and GFMs `~`).
+      marker === "_" ? { inside: true, outside: true } : { inside: false, outside: false }
+    ) : insideKind === 1 ? (
+      // Whitespace inside: encode both (letter, whitespace).
+      { inside: true, outside: true }
+    ) : (
+      // Punctuation inside: encode outer (letter)
+      { inside: false, outside: true }
+    );
+  }
+  if (outsideKind === 1) {
+    return insideKind === void 0 ? (
+      // Letter inside: already forms.
+      { inside: false, outside: false }
+    ) : insideKind === 1 ? (
+      // Whitespace inside: encode both (whitespace).
+      { inside: true, outside: true }
+    ) : (
+      // Punctuation inside: already forms.
+      { inside: false, outside: false }
+    );
+  }
+  return insideKind === void 0 ? (
+    // Letter inside: already forms.
+    { inside: false, outside: false }
+  ) : insideKind === 1 ? (
+    // Whitespace inside: encode inner (whitespace).
+    { inside: true, outside: false }
+  ) : (
+    // Punctuation inside: already forms.
+    { inside: false, outside: false }
+  );
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
+emphasis.peek = emphasisPeek;
+function emphasis(node2, _, state, info) {
+  const marker = checkEmphasis(state);
+  const exit = state.enter("emphasis");
+  const tracker = state.createTracker(info);
+  const before = tracker.move(marker);
+  let between = tracker.move(
+    state.containerPhrasing(node2, {
+      after: marker,
+      before,
+      ...tracker.current()
+    })
+  );
+  const betweenHead = between.charCodeAt(0);
+  const open = encodeInfo(
+    info.before.charCodeAt(info.before.length - 1),
+    betweenHead,
+    marker
+  );
+  if (open.inside) {
+    between = encodeCharacterReference(betweenHead) + between.slice(1);
+  }
+  const betweenTail = between.charCodeAt(between.length - 1);
+  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
+  if (close.inside) {
+    between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+  }
+  const after = tracker.move(marker);
+  exit();
+  state.attentionEncodeSurroundingInfo = {
+    after: close.outside,
+    before: open.outside
+  };
+  return before + between + after;
+}
+function emphasisPeek(_, _1, state) {
+  return state.options.emphasis || "*";
+}
+
+// node_modules/mdast-util-to-string/lib/index.js
+var emptyOptions = {};
+function toString(value, options) {
+  const settings = options || emptyOptions;
+  const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true;
+  const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true;
+  return one(value, includeImageAlt, includeHtml);
+}
+function one(value, includeImageAlt, includeHtml) {
+  if (node(value)) {
+    if ("value" in value) {
+      return value.type === "html" && !includeHtml ? "" : value.value;
+    }
+    if (includeImageAlt && "alt" in value && value.alt) {
+      return value.alt;
+    }
+    if ("children" in value) {
+      return all(value.children, includeImageAlt, includeHtml);
+    }
+  }
+  if (Array.isArray(value)) {
+    return all(value, includeImageAlt, includeHtml);
   }
+  return "";
+}
+function all(values, includeImageAlt, includeHtml) {
+  const result = [];
+  let index = -1;
+  while (++index < values.length) {
+    result[index] = one(values[index], includeImageAlt, includeHtml);
+  }
+  return result.join("");
+}
+function node(value) {
+  return Boolean(value && typeof value === "object");
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
+function formatHeadingAsSetext(node2, state) {
+  let literalWithBreak = false;
+  visit(node2, function(node3) {
+    if ("value" in node3 && /\r?\n|\r/.test(node3.value) || node3.type === "break") {
+      literalWithBreak = true;
+      return EXIT;
+    }
+  });
+  return Boolean(
+    (!node2.depth || node2.depth < 3) && toString(node2) && (state.options.setext || literalWithBreak)
+  );
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/heading.js
+function heading(node2, _, state, info) {
+  const rank = Math.max(Math.min(6, node2.depth || 1), 1);
+  const tracker = state.createTracker(info);
+  if (formatHeadingAsSetext(node2, state)) {
+    const exit2 = state.enter("headingSetext");
+    const subexit2 = state.enter("phrasing");
+    const value2 = state.containerPhrasing(node2, {
+      ...tracker.current(),
+      before: "\n",
+      after: "\n"
+    });
+    subexit2();
+    exit2();
+    return value2 + "\n" + (rank === 1 ? "=" : "-").repeat(
+      // The whole size…
+      value2.length - // Minus the position of the character after the last EOL (or
+      // 0 if there is none)…
+      (Math.max(value2.lastIndexOf("\r"), value2.lastIndexOf("\n")) + 1)
+    );
+  }
+  const sequence = "#".repeat(rank);
+  const exit = state.enter("headingAtx");
+  const subexit = state.enter("phrasing");
+  tracker.move(sequence + " ");
+  let value = state.containerPhrasing(node2, {
+    before: "# ",
+    after: "\n",
+    ...tracker.current()
+  });
+  if (/^[\t ]/.test(value)) {
+    value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1);
+  }
+  value = value ? sequence + " " + value : sequence;
+  if (state.options.closeAtx) {
+    value += " " + sequence;
+  }
+  subexit();
+  exit();
+  return value;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/html.js
+html.peek = htmlPeek;
+function html(node2) {
+  return node2.value || "";
+}
+function htmlPeek() {
+  return "<";
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/image.js
+image.peek = imagePeek;
+function image(node2, _, state, info) {
+  const quote = checkQuote(state);
+  const suffix = quote === '"' ? "Quote" : "Apostrophe";
+  const exit = state.enter("image");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("![");
+  value += tracker.move(
+    state.safe(node2.alt, { before: value, after: "]", ...tracker.current() })
+  );
+  value += tracker.move("](");
+  subexit();
+  if (
+    // If there’s no url but there is a title…
+    !node2.url && node2.title || // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node2.url)
+  ) {
+    subexit = state.enter("destinationLiteral");
+    value += tracker.move("<");
+    value += tracker.move(
+      state.safe(node2.url, { before: value, after: ">", ...tracker.current() })
+    );
+    value += tracker.move(">");
+  } else {
+    subexit = state.enter("destinationRaw");
+    value += tracker.move(
+      state.safe(node2.url, {
+        before: value,
+        after: node2.title ? " " : ")",
+        ...tracker.current()
+      })
+    );
+  }
+  subexit();
+  if (node2.title) {
+    subexit = state.enter(`title${suffix}`);
+    value += tracker.move(" " + quote);
+    value += tracker.move(
+      state.safe(node2.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    );
+    value += tracker.move(quote);
+    subexit();
+  }
+  value += tracker.move(")");
+  exit();
+  return value;
+}
+function imagePeek() {
+  return "!";
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/image-reference.js
+imageReference.peek = imageReferencePeek;
+function imageReference(node2, _, state, info) {
+  const type = node2.referenceType;
+  const exit = state.enter("imageReference");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("![");
+  const alt = state.safe(node2.alt, {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  value += tracker.move(alt + "][");
+  subexit();
+  const stack = state.stack;
+  state.stack = [];
+  subexit = state.enter("reference");
+  const reference = state.safe(state.associationId(node2), {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  subexit();
+  state.stack = stack;
+  exit();
+  if (type === "full" || !alt || alt !== reference) {
+    value += tracker.move(reference + "]");
+  } else if (type === "shortcut") {
+    value = value.slice(0, -1);
+  } else {
+    value += tracker.move("]");
+  }
+  return value;
+}
+function imageReferencePeek() {
+  return "!";
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
+inlineCode.peek = inlineCodePeek;
+function inlineCode(node2, _, state) {
+  let value = node2.value || "";
+  let sequence = "`";
+  let index = -1;
+  while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) {
+    sequence += "`";
+  }
+  if (/[^ \r\n]/.test(value) && (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || /^`|`$/.test(value))) {
+    value = " " + value + " ";
+  }
+  while (++index < state.unsafe.length) {
+    const pattern = state.unsafe[index];
+    const expression = state.compilePattern(pattern);
+    let match;
+    if (!pattern.atBreak) continue;
+    while (match = expression.exec(value)) {
+      let position = match.index;
+      if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) {
+        position--;
+      }
+      value = value.slice(0, position) + " " + value.slice(match.index + 1);
+    }
+  }
+  return sequence + value + sequence;
+}
+function inlineCodePeek() {
+  return "`";
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js
+function formatLinkAsAutolink(node2, state) {
+  const raw = toString(node2);
+  return Boolean(
+    !state.options.resourceLink && // If there’s a url…
+    node2.url && // And there’s a no title…
+    !node2.title && // And the content of `node` is a single text node…
+    node2.children && node2.children.length === 1 && node2.children[0].type === "text" && // And if the url is the same as the content…
+    (raw === node2.url || "mailto:" + raw === node2.url) && // And that starts w/ a protocol…
+    /^[a-z][a-z+.-]+:/i.test(node2.url) && // And that doesn’t contain ASCII control codes (character escapes and
+    // references don’t work), space, or angle brackets…
+    !/[\0- <>\u007F]/.test(node2.url)
+  );
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/link.js
+link.peek = linkPeek;
+function link(node2, _, state, info) {
+  const quote = checkQuote(state);
+  const suffix = quote === '"' ? "Quote" : "Apostrophe";
+  const tracker = state.createTracker(info);
+  let exit;
+  let subexit;
+  if (formatLinkAsAutolink(node2, state)) {
+    const stack = state.stack;
+    state.stack = [];
+    exit = state.enter("autolink");
+    let value2 = tracker.move("<");
+    value2 += tracker.move(
+      state.containerPhrasing(node2, {
+        before: value2,
+        after: ">",
+        ...tracker.current()
+      })
+    );
+    value2 += tracker.move(">");
+    exit();
+    state.stack = stack;
+    return value2;
+  }
+  exit = state.enter("link");
+  subexit = state.enter("label");
+  let value = tracker.move("[");
+  value += tracker.move(
+    state.containerPhrasing(node2, {
+      before: value,
+      after: "](",
+      ...tracker.current()
+    })
+  );
+  value += tracker.move("](");
+  subexit();
+  if (
+    // If there’s no url but there is a title…
+    !node2.url && node2.title || // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node2.url)
+  ) {
+    subexit = state.enter("destinationLiteral");
+    value += tracker.move("<");
+    value += tracker.move(
+      state.safe(node2.url, { before: value, after: ">", ...tracker.current() })
+    );
+    value += tracker.move(">");
+  } else {
+    subexit = state.enter("destinationRaw");
+    value += tracker.move(
+      state.safe(node2.url, {
+        before: value,
+        after: node2.title ? " " : ")",
+        ...tracker.current()
+      })
+    );
+  }
+  subexit();
+  if (node2.title) {
+    subexit = state.enter(`title${suffix}`);
+    value += tracker.move(" " + quote);
+    value += tracker.move(
+      state.safe(node2.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    );
+    value += tracker.move(quote);
+    subexit();
+  }
+  value += tracker.move(")");
+  exit();
+  return value;
+}
+function linkPeek(node2, _, state) {
+  return formatLinkAsAutolink(node2, state) ? "<" : "[";
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/link-reference.js
+linkReference.peek = linkReferencePeek;
+function linkReference(node2, _, state, info) {
+  const type = node2.referenceType;
+  const exit = state.enter("linkReference");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("[");
+  const text2 = state.containerPhrasing(node2, {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  value += tracker.move(text2 + "][");
+  subexit();
+  const stack = state.stack;
+  state.stack = [];
+  subexit = state.enter("reference");
+  const reference = state.safe(state.associationId(node2), {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  subexit();
+  state.stack = stack;
+  exit();
+  if (type === "full" || !text2 || text2 !== reference) {
+    value += tracker.move(reference + "]");
+  } else if (type === "shortcut") {
+    value = value.slice(0, -1);
+  } else {
+    value += tracker.move("]");
+  }
+  return value;
+}
+function linkReferencePeek() {
+  return "[";
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-bullet.js
+function checkBullet(state) {
+  const marker = state.options.bullet || "*";
+  if (marker !== "*" && marker !== "+" && marker !== "-") {
+    throw new Error(
+      "Cannot serialize items with `" + marker + "` for `options.bullet`, expected `*`, `+`, or `-`"
+    );
+  }
+  return marker;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js
+function checkBulletOther(state) {
+  const bullet = checkBullet(state);
+  const bulletOther = state.options.bulletOther;
+  if (!bulletOther) {
+    return bullet === "*" ? "-" : "*";
+  }
+  if (bulletOther !== "*" && bulletOther !== "+" && bulletOther !== "-") {
+    throw new Error(
+      "Cannot serialize items with `" + bulletOther + "` for `options.bulletOther`, expected `*`, `+`, or `-`"
+    );
+  }
+  if (bulletOther === bullet) {
+    throw new Error(
+      "Expected `bullet` (`" + bullet + "`) and `bulletOther` (`" + bulletOther + "`) to be different"
+    );
+  }
+  return bulletOther;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js
+function checkBulletOrdered(state) {
+  const marker = state.options.bulletOrdered || ".";
+  if (marker !== "." && marker !== ")") {
+    throw new Error(
+      "Cannot serialize items with `" + marker + "` for `options.bulletOrdered`, expected `.` or `)`"
+    );
+  }
+  return marker;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-rule.js
+function checkRule(state) {
+  const marker = state.options.rule || "*";
+  if (marker !== "*" && marker !== "-" && marker !== "_") {
+    throw new Error(
+      "Cannot serialize rules with `" + marker + "` for `options.rule`, expected `*`, `-`, or `_`"
+    );
+  }
+  return marker;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/list.js
+function list(node2, parent, state, info) {
+  const exit = state.enter("list");
+  const bulletCurrent = state.bulletCurrent;
+  let bullet = node2.ordered ? checkBulletOrdered(state) : checkBullet(state);
+  const bulletOther = node2.ordered ? bullet === "." ? ")" : "." : checkBulletOther(state);
+  let useDifferentMarker = parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false;
+  if (!node2.ordered) {
+    const firstListItem = node2.children ? node2.children[0] : void 0;
+    if (
+      // Bullet could be used as a thematic break marker:
+      (bullet === "*" || bullet === "-") && // Empty first list item:
+      firstListItem && (!firstListItem.children || !firstListItem.children[0]) && // Directly in two other list items:
+      state.stack[state.stack.length - 1] === "list" && state.stack[state.stack.length - 2] === "listItem" && state.stack[state.stack.length - 3] === "list" && state.stack[state.stack.length - 4] === "listItem" && // That are each the first child.
+      state.indexStack[state.indexStack.length - 1] === 0 && state.indexStack[state.indexStack.length - 2] === 0 && state.indexStack[state.indexStack.length - 3] === 0
+    ) {
+      useDifferentMarker = true;
+    }
+    if (checkRule(state) === bullet && firstListItem) {
+      let index = -1;
+      while (++index < node2.children.length) {
+        const item = node2.children[index];
+        if (item && item.type === "listItem" && item.children && item.children[0] && item.children[0].type === "thematicBreak") {
+          useDifferentMarker = true;
+          break;
+        }
+      }
+    }
+  }
+  if (useDifferentMarker) {
+    bullet = bulletOther;
+  }
+  state.bulletCurrent = bullet;
+  const value = state.containerFlow(node2, info);
+  state.bulletLastUsed = bullet;
+  state.bulletCurrent = bulletCurrent;
+  exit();
+  return value;
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
+function checkListItemIndent(state) {
+  const style = state.options.listItemIndent || "one";
+  if (style !== "tab" && style !== "one" && style !== "mixed") {
+    throw new Error(
+      "Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`"
+    );
+  }
+  return style;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/list-item.js
+function listItem(node2, parent, state, info) {
+  const listItemIndent = checkListItemIndent(state);
+  let bullet = state.bulletCurrent || checkBullet(state);
+  if (parent && parent.type === "list" && parent.ordered) {
+    bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === false ? 0 : parent.children.indexOf(node2)) + bullet;
+  }
+  let size = bullet.length + 1;
+  if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node2.spread)) {
+    size = Math.ceil(size / 4) * 4;
+  }
+  const tracker = state.createTracker(info);
+  tracker.move(bullet + " ".repeat(size - bullet.length));
+  tracker.shift(size);
+  const exit = state.enter("listItem");
+  const value = state.indentLines(
+    state.containerFlow(node2, tracker.current()),
+    map3
+  );
+  exit();
+  return value;
+  function map3(line, index, blank) {
+    if (index) {
+      return (blank ? "" : " ".repeat(size)) + line;
+    }
+    return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
+  }
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/paragraph.js
+function paragraph(node2, _, state, info) {
+  const exit = state.enter("paragraph");
+  const subexit = state.enter("phrasing");
+  const value = state.containerPhrasing(node2, info);
+  subexit();
+  exit();
+  return value;
+}
+
+// node_modules/mdast-util-phrasing/lib/index.js
+var phrasing = (
+  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */
+  convert([
+    "break",
+    "delete",
+    "emphasis",
+    // To do: next major: removed since footnotes were added to GFM.
+    "footnote",
+    "footnoteReference",
+    "image",
+    "imageReference",
+    "inlineCode",
+    // Enabled by `mdast-util-math`:
+    "inlineMath",
+    "link",
+    "linkReference",
+    // Enabled by `mdast-util-mdx`:
+    "mdxJsxTextElement",
+    // Enabled by `mdast-util-mdx`:
+    "mdxTextExpression",
+    "strong",
+    "text",
+    // Enabled by `mdast-util-directive`:
+    "textDirective"
+  ])
+);
+
+// node_modules/mdast-util-to-markdown/lib/handle/root.js
+function root(node2, _, state, info) {
+  const hasPhrasing = node2.children.some(function(d) {
+    return phrasing(d);
+  });
+  const container = hasPhrasing ? state.containerPhrasing : state.containerFlow;
+  return container.call(state, node2, info);
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-strong.js
+function checkStrong(state) {
+  const marker = state.options.strong || "*";
+  if (marker !== "*" && marker !== "_") {
+    throw new Error(
+      "Cannot serialize strong with `" + marker + "` for `options.strong`, expected `*`, or `_`"
+    );
+  }
+  return marker;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/strong.js
+strong.peek = strongPeek;
+function strong(node2, _, state, info) {
+  const marker = checkStrong(state);
+  const exit = state.enter("strong");
+  const tracker = state.createTracker(info);
+  const before = tracker.move(marker + marker);
+  let between = tracker.move(
+    state.containerPhrasing(node2, {
+      after: marker,
+      before,
+      ...tracker.current()
+    })
+  );
+  const betweenHead = between.charCodeAt(0);
+  const open = encodeInfo(
+    info.before.charCodeAt(info.before.length - 1),
+    betweenHead,
+    marker
+  );
+  if (open.inside) {
+    between = encodeCharacterReference(betweenHead) + between.slice(1);
+  }
+  const betweenTail = between.charCodeAt(between.length - 1);
+  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
+  if (close.inside) {
+    between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+  }
+  const after = tracker.move(marker + marker);
+  exit();
+  state.attentionEncodeSurroundingInfo = {
+    after: close.outside,
+    before: open.outside
+  };
+  return before + between + after;
+}
+function strongPeek(_, _1, state) {
+  return state.options.strong || "*";
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/text.js
+function text(node2, _, state, info) {
+  return state.safe(node2.value, info);
+}
+
+// node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js
+function checkRuleRepetition(state) {
+  const repetition = state.options.ruleRepetition || 3;
+  if (repetition < 3) {
+    throw new Error(
+      "Cannot serialize rules with repetition `" + repetition + "` for `options.ruleRepetition`, expected `3` or more"
+    );
+  }
+  return repetition;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
+function thematicBreak(_, _1, state) {
+  const value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
+  return state.options.ruleSpaces ? value.slice(0, -1) : value;
+}
+
+// node_modules/mdast-util-to-markdown/lib/handle/index.js
+var handle = {
+  blockquote,
+  break: hardBreak,
+  code,
+  definition,
+  emphasis,
+  hardBreak,
+  heading,
+  html,
+  image,
+  imageReference,
+  inlineCode,
+  link,
+  linkReference,
+  list,
+  listItem,
+  paragraph,
+  root,
+  strong,
+  text,
+  thematicBreak
+};
+
+// src/lib/mdast/task-char-to-markdown.ts
+function taskCharToMarkdown() {
+  return {
+    unsafe: [{ atBreak: true, character: "-", after: "[:|-]" }],
+    handlers: {
+      listItem(node2, parent, state, info) {
+        const taskChar = node2.data?.taskChar ?? (typeof node2.checked === "boolean" ? node2.checked ? "x" : " " : null);
+        const head = node2.children[0];
+        const isTask = taskChar !== null && head?.type === "paragraph";
+        if (!isTask) {
+          return handle.listItem(node2, parent, state, info);
+        }
+        const checkbox = `[${taskChar}] `;
+        const tracker = state.createTracker(info);
+        tracker.move(checkbox);
+        const savedChecked = node2.checked;
+        delete node2.checked;
+        let value = handle.listItem(node2, parent, state, {
+          ...info,
+          ...tracker.current()
+        });
+        node2.checked = savedChecked;
+        value = value.replace(
+          /^([*+-]|\d+\.)([\r\n]| {1,3})/,
+          (match) => match + checkbox
+        );
+        return value;
+      }
+    }
+  };
 }
 
 // node_modules/micromark-factory-space/index.js
@@ -1206,20 +2201,20 @@ function factorySpace(effects, ok3, type, max) {
   const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
   let size = 0;
   return start;
-  function start(code) {
-    if (markdownSpace(code)) {
+  function start(code2) {
+    if (markdownSpace(code2)) {
       effects.enter(type);
-      return prefix(code);
+      return prefix(code2);
     }
-    return ok3(code);
+    return ok3(code2);
   }
-  function prefix(code) {
-    if (markdownSpace(code) && size++ < limit) {
-      effects.consume(code);
+  function prefix(code2) {
+    if (markdownSpace(code2) && size++ < limit) {
+      effects.consume(code2);
       return prefix;
     }
     effects.exit(type);
-    return ok3(code);
+    return ok3(code2);
   }
 }
 
@@ -1239,127 +2234,127 @@ function tokenizeMathFenced(effects, ok3, nok) {
   const initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
   let sizeOpen = 0;
   return start;
-  function start(code) {
+  function start(code2) {
     effects.enter("mathFlow");
     effects.enter("mathFlowFence");
     effects.enter("mathFlowFenceSequence");
-    return sequenceOpen(code);
+    return sequenceOpen(code2);
   }
-  function sequenceOpen(code) {
-    if (code === 36) {
-      effects.consume(code);
+  function sequenceOpen(code2) {
+    if (code2 === 36) {
+      effects.consume(code2);
       sizeOpen++;
       return sequenceOpen;
     }
     if (sizeOpen < 2) {
-      return nok(code);
+      return nok(code2);
     }
     effects.exit("mathFlowFenceSequence");
-    return factorySpace(effects, metaBefore, "whitespace")(code);
+    return factorySpace(effects, metaBefore, "whitespace")(code2);
   }
-  function metaBefore(code) {
-    if (code === null || markdownLineEnding(code)) {
-      return metaAfter(code);
+  function metaBefore(code2) {
+    if (code2 === null || markdownLineEnding(code2)) {
+      return metaAfter(code2);
     }
     effects.enter("mathFlowFenceMeta");
     effects.enter("chunkString", {
       contentType: "string"
     });
-    return meta(code);
+    return meta(code2);
   }
-  function meta(code) {
-    if (code === null || markdownLineEnding(code)) {
+  function meta(code2) {
+    if (code2 === null || markdownLineEnding(code2)) {
       effects.exit("chunkString");
       effects.exit("mathFlowFenceMeta");
-      return metaAfter(code);
+      return metaAfter(code2);
     }
-    if (code === 36) {
-      return nok(code);
+    if (code2 === 36) {
+      return nok(code2);
     }
-    effects.consume(code);
+    effects.consume(code2);
     return meta;
   }
-  function metaAfter(code) {
+  function metaAfter(code2) {
     effects.exit("mathFlowFence");
     if (self.interrupt) {
-      return ok3(code);
+      return ok3(code2);
     }
-    return effects.attempt(nonLazyContinuation2, beforeNonLazyContinuation, after)(code);
+    return effects.attempt(nonLazyContinuation2, beforeNonLazyContinuation, after)(code2);
   }
-  function beforeNonLazyContinuation(code) {
+  function beforeNonLazyContinuation(code2) {
     return effects.attempt({
       tokenize: tokenizeClosingFence,
       partial: true
-    }, after, contentStart)(code);
+    }, after, contentStart)(code2);
   }
-  function contentStart(code) {
-    return (initialSize ? factorySpace(effects, beforeContentChunk, "linePrefix", initialSize + 1) : beforeContentChunk)(code);
+  function contentStart(code2) {
+    return (initialSize ? factorySpace(effects, beforeContentChunk, "linePrefix", initialSize + 1) : beforeContentChunk)(code2);
   }
-  function beforeContentChunk(code) {
-    if (code === null) {
-      return after(code);
+  function beforeContentChunk(code2) {
+    if (code2 === null) {
+      return after(code2);
     }
-    if (markdownLineEnding(code)) {
-      return effects.attempt(nonLazyContinuation2, beforeNonLazyContinuation, after)(code);
+    if (markdownLineEnding(code2)) {
+      return effects.attempt(nonLazyContinuation2, beforeNonLazyContinuation, after)(code2);
     }
     effects.enter("mathFlowValue");
-    return contentChunk(code);
+    return contentChunk(code2);
   }
-  function contentChunk(code) {
-    if (code === null || markdownLineEnding(code)) {
+  function contentChunk(code2) {
+    if (code2 === null || markdownLineEnding(code2)) {
       effects.exit("mathFlowValue");
-      return beforeContentChunk(code);
+      return beforeContentChunk(code2);
     }
-    effects.consume(code);
+    effects.consume(code2);
     return contentChunk;
   }
-  function after(code) {
+  function after(code2) {
     effects.exit("mathFlow");
-    return ok3(code);
+    return ok3(code2);
   }
   function tokenizeClosingFence(effects2, ok4, nok2) {
     let size = 0;
     return factorySpace(effects2, beforeSequenceClose, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
-    function beforeSequenceClose(code) {
+    function beforeSequenceClose(code2) {
       effects2.enter("mathFlowFence");
       effects2.enter("mathFlowFenceSequence");
-      return sequenceClose(code);
+      return sequenceClose(code2);
     }
-    function sequenceClose(code) {
-      if (code === 36) {
+    function sequenceClose(code2) {
+      if (code2 === 36) {
         size++;
-        effects2.consume(code);
+        effects2.consume(code2);
         return sequenceClose;
       }
       if (size < sizeOpen) {
-        return nok2(code);
+        return nok2(code2);
       }
       effects2.exit("mathFlowFenceSequence");
-      return factorySpace(effects2, afterSequenceClose, "whitespace")(code);
+      return factorySpace(effects2, afterSequenceClose, "whitespace")(code2);
     }
-    function afterSequenceClose(code) {
-      if (code === null || markdownLineEnding(code)) {
+    function afterSequenceClose(code2) {
+      if (code2 === null || markdownLineEnding(code2)) {
         effects2.exit("mathFlowFence");
-        return ok4(code);
+        return ok4(code2);
       }
-      return nok2(code);
+      return nok2(code2);
     }
   }
 }
 function tokenizeNonLazyContinuation2(effects, ok3, nok) {
   const self = this;
   return start;
-  function start(code) {
-    if (code === null) {
-      return ok3(code);
+  function start(code2) {
+    if (code2 === null) {
+      return ok3(code2);
     }
     effects.enter("lineEnding");
-    effects.consume(code);
+    effects.consume(code2);
     effects.exit("lineEnding");
     return lineStart;
   }
-  function lineStart(code) {
-    return self.parser.lazy[self.now().line] ? nok(code) : ok3(code);
+  function lineStart(code2) {
+    return self.parser.lazy[self.now().line] ? nok(code2) : ok3(code2);
   }
 }
 
@@ -1382,68 +2377,68 @@ function mathText(options) {
     let size;
     let token;
     return start;
-    function start(code) {
+    function start(code2) {
       effects.enter("mathText");
       effects.enter("mathTextSequence");
-      return sequenceOpen(code);
+      return sequenceOpen(code2);
     }
-    function sequenceOpen(code) {
-      if (code === 36) {
-        effects.consume(code);
+    function sequenceOpen(code2) {
+      if (code2 === 36) {
+        effects.consume(code2);
         sizeOpen++;
         return sequenceOpen;
       }
       if (sizeOpen < 2 && !single) {
-        return nok(code);
+        return nok(code2);
       }
       effects.exit("mathTextSequence");
-      return between(code);
+      return between(code2);
     }
-    function between(code) {
-      if (code === null) {
-        return nok(code);
+    function between(code2) {
+      if (code2 === null) {
+        return nok(code2);
       }
-      if (code === 36) {
+      if (code2 === 36) {
         token = effects.enter("mathTextSequence");
         size = 0;
-        return sequenceClose(code);
+        return sequenceClose(code2);
       }
-      if (code === 32) {
+      if (code2 === 32) {
         effects.enter("space");
-        effects.consume(code);
+        effects.consume(code2);
         effects.exit("space");
         return between;
       }
-      if (markdownLineEnding(code)) {
+      if (markdownLineEnding(code2)) {
         effects.enter("lineEnding");
-        effects.consume(code);
+        effects.consume(code2);
         effects.exit("lineEnding");
         return between;
       }
       effects.enter("mathTextData");
-      return data(code);
+      return data(code2);
     }
-    function data(code) {
-      if (code === null || code === 32 || code === 36 || markdownLineEnding(code)) {
+    function data(code2) {
+      if (code2 === null || code2 === 32 || code2 === 36 || markdownLineEnding(code2)) {
         effects.exit("mathTextData");
-        return between(code);
+        return between(code2);
       }
-      effects.consume(code);
+      effects.consume(code2);
       return data;
     }
-    function sequenceClose(code) {
-      if (code === 36) {
-        effects.consume(code);
+    function sequenceClose(code2) {
+      if (code2 === 36) {
+        effects.consume(code2);
         size++;
         return sequenceClose;
       }
       if (size === sizeOpen) {
         effects.exit("mathTextSequence");
         effects.exit("mathText");
-        return ok3(code);
+        return ok3(code2);
       }
       token.type = "mathTextData";
-      return data(code);
+      return data(code2);
     }
   }
 }
@@ -1484,8 +2479,8 @@ function resolveMathText(events) {
   }
   return events;
 }
-function previous(code) {
-  return code !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
+function previous(code2) {
+  return code2 !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
 }
 
 // node_modules/micromark-extension-math/lib/syntax.js
@@ -1504,30 +2499,6 @@ function math(options) {
 function ok2() {
 }
 
-// node_modules/longest-streak/index.js
-function longestStreak(value, substring) {
-  const source = String(value);
-  let index = source.indexOf(substring);
-  let expected = index;
-  let count = 0;
-  let max = 0;
-  if (typeof substring !== "string") {
-    throw new TypeError("Expected substring");
-  }
-  while (index !== -1) {
-    if (index === expected) {
-      if (++count > max) {
-        max = count;
-      }
-    } else {
-      count = 1;
-    }
-    expected = index + substring.length;
-    index = source.indexOf(substring, expected);
-  }
-  return max;
-}
-
 // node_modules/mdast-util-math/lib/index.js
 function mathFromMarkdown() {
   return {
@@ -1546,7 +2517,7 @@ function mathFromMarkdown() {
     }
   };
   function enterMathFlow(token) {
-    const code = {
+    const code2 = {
       type: "element",
       tagName: "code",
       properties: { className: ["language-math", "math-display"] },
@@ -1557,7 +2528,7 @@ function mathFromMarkdown() {
         type: "math",
         meta: null,
         value: "",
-        data: { hName: "pre", hChildren: [code] }
+        data: { hName: "pre", hChildren: [code2] }
       },
       token
     );
@@ -1567,9 +2538,9 @@ function mathFromMarkdown() {
   }
   function exitMathFlowMeta() {
     const data = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    ok2(node.type === "math");
-    node.meta = data;
+    const node2 = this.stack[this.stack.length - 1];
+    ok2(node2.type === "math");
+    node2.meta = data;
   }
   function exitMathFlowFence() {
     if (this.data.mathFlowInside) return;
@@ -1578,17 +2549,17 @@ function mathFromMarkdown() {
   }
   function exitMathFlow(token) {
     const data = this.resume().replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, "");
-    const node = this.stack[this.stack.length - 1];
-    ok2(node.type === "math");
+    const node2 = this.stack[this.stack.length - 1];
+    ok2(node2.type === "math");
     this.exit(token);
-    node.value = data;
-    const code = (
+    node2.value = data;
+    const code2 = (
       /** @type {HastElement} */
-      node.data.hChildren[0]
+      node2.data.hChildren[0]
     );
-    ok2(code.type === "element");
-    ok2(code.tagName === "code");
-    code.children.push({ type: "text", value: data });
+    ok2(code2.type === "element");
+    ok2(code2.tagName === "code");
+    code2.children.push({ type: "text", value: data });
     this.data.mathFlowInside = void 0;
   }
   function enterMathText(token) {
@@ -1608,14 +2579,14 @@ function mathFromMarkdown() {
   }
   function exitMathText(token) {
     const data = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    ok2(node.type === "inlineMath");
+    const node2 = this.stack[this.stack.length - 1];
+    ok2(node2.type === "inlineMath");
     this.exit(token);
-    node.value = data;
+    node2.value = data;
     const children = (
       /** @type {Array<HastElementContent>} */
       // @ts-expect-error: we defined it in `enterMathFlow`.
-      node.data.hChildren
+      node2.data.hChildren
     );
     children.push({ type: "text", value: data });
   }
@@ -1644,16 +2615,16 @@ function mathToMarkdown(options) {
     ],
     handlers: { math: math2, inlineMath }
   };
-  function math2(node, _, state, info) {
-    const raw = node.value || "";
+  function math2(node2, _, state, info) {
+    const raw = node2.value || "";
     const tracker = state.createTracker(info);
     const sequence = "$".repeat(Math.max(longestStreak(raw, "$") + 1, 2));
     const exit = state.enter("mathFlow");
     let value = tracker.move(sequence);
-    if (node.meta) {
+    if (node2.meta) {
       const subexit = state.enter("mathFlowMeta");
       value += tracker.move(
-        state.safe(node.meta, {
+        state.safe(node2.meta, {
           after: "\n",
           before: value,
           encode: ["$"],
@@ -1670,8 +2641,8 @@ function mathToMarkdown(options) {
     exit();
     return value;
   }
-  function inlineMath(node, _, state) {
-    let value = node.value || "";
+  function inlineMath(node2, _, state) {
+    let value = node2.value || "";
     let size = 1;
     if (!single) size++;
     while (new RegExp("(^|[^$])" + "\\$".repeat(size) + "([^$]|$)").test(value)) {
@@ -1747,6 +2718,9 @@ function remarkObsidian(userOpts) {
     data.fromMarkdownExtensions.push(mathFromMarkdown());
     data.toMarkdownExtensions.push(mathToMarkdown());
   }
+  if (opts.customTaskChars) {
+    data.toMarkdownExtensions.push(taskCharToMarkdown());
+  }
   const needsTransform = opts.comments || opts.customTaskChars;
   if (!needsTransform) return void 0;
   return (tree, file) => {
@@ -1780,6 +2754,7 @@ export {
   tagFromMarkdown,
   tagSyntax,
   tagToMarkdown,
+  taskCharToMarkdown,
   wikilinkFromMarkdown,
   wikilinkSyntax,
   wikilinkToMarkdown