@mintlify/cli 4.0.1462 → 4.0.1464

package/bin/vendor/converter.js

@@ -1520,6 +1520,33 @@ function partitionForBlockType(parsed, blockType) {
   var _a;
   return partitionAttrs(parsed, (_a = BLOCK_TYPE_KNOWN_ATTRS[blockType]) !== null && _a !== void 0 ? _a : []);
 }
+var STRUCTURED_FLOW_COMPONENTS = /* @__PURE__ */ new Map([
+  [BLOCK_TYPES.callout, true],
+  [BLOCK_TYPES.column, true],
+  [BLOCK_TYPES.expandable, true],
+  [BLOCK_TYPES.frame, true],
+  [BLOCK_TYPES.paramField, true],
+  ["Prompt", false],
+  [BLOCK_TYPES.responseField, true],
+  [BLOCK_TYPES.tab, true],
+  [BLOCK_TYPES.update, true],
+  [BLOCK_TYPES.visibility, false],
+  [BLOCK_TYPES.accordion, false],
+  [BLOCK_TYPES.accordionGroup, false],
+  [BLOCK_TYPES.card, false],
+  [BLOCK_TYPES.codeGroup, false],
+  [BLOCK_TYPES.columns, false],
+  [BLOCK_TYPES.requestExample, false],
+  [BLOCK_TYPES.responseExample, false],
+  [BLOCK_TYPES.steps, false],
+  [BLOCK_TYPES.tabs, false]
+]);
+function isContainerOnlyComponent(name, schema2) {
+  var _a;
+  const type2 = schema2.nodes[name];
+  return !!type2 && !type2.isInline && !((_a = type2.spec.group) !== null && _a !== void 0 ? _a : "").split(" ").includes("block");
+}
+var withRequiredContent = (nodeType, content) => STRUCTURED_FLOW_COMPONENTS.get(nodeType) && content.length === 0 ? [{ type: "paragraph" }] : content;
 function handleFlowJsx(node, ctx, transformNode2, mapJsxChildren2) {
   if (!node.name)
     return [];
@@ -1530,7 +1557,7 @@ function handleFlowJsx(node, ctx, transformNode2, mapJsxChildren2) {
   }
 }
 function handleFlowJsxInner(node, ctx, transformNode2, mapJsxChildren2) {
-  var _a;
+  var _a, _b;
   if (!node.name)
     return [];
   if (/^h[1-6]$/.test(node.name)) {
@@ -1558,7 +1585,7 @@ function handleFlowJsxInner(node, ctx, transformNode2, mapJsxChildren2) {
     return {
       type: BLOCK_TYPES.frame,
       attrs: partitionAttrs(frameAttrs, FRAME_ATTRS),
-      content: mapJsxChildren2(node, ctx)
+      content: withRequiredContent(BLOCK_TYPES.frame, mapJsxChildren2(node, ctx))
     };
   }
   const isCallout = CALLOUT_TYPES.includes(node.name);
@@ -1596,13 +1623,13 @@ function handleFlowJsxInner(node, ctx, transformNode2, mapJsxChildren2) {
   if (node.name === BLOCK_TYPES.tree) {
     return handleTree(node);
   }
-  if (isCallout || node.name !== BLOCK_TYPES.step && Object.values(BLOCK_TYPES).includes(node.name)) {
-    const targetType = isCallout ? BLOCK_TYPES.callout : node.name;
+  const targetType = isCallout ? BLOCK_TYPES.callout : node.name;
+  if ((isCallout || node.name !== BLOCK_TYPES.step && Object.values(BLOCK_TYPES).includes(node.name)) && (ctx.hasGroupParent || !isContainerOnlyComponent(targetType, (_b = ctx.schema) !== null && _b !== void 0 ? _b : mintlifySchema))) {
     const parsedAttrs = parseMdxAttributes(node.attributes);
     return {
       type: targetType,
       attrs: Object.assign(Object.assign({}, isCallout ? parseCalloutAttrs(node.name, parsedAttrs) : partitionForBlockType(parsedAttrs, targetType)), ctx.hasGroupParent && { __hasGroupParent: true }),
-      content: mapJsxChildren2(node, ctx)
+      content: withRequiredContent(targetType, mapJsxChildren2(node, ctx))
     };
   }
   if (node.name === "table" && !hasSpannedCell(node) && !hasTableClass(node)) {
@@ -1659,28 +1686,42 @@ function createTitleNode(type2, title, ctx, transformNode2) {
   return Object.assign({ type: type2 }, content.length > 0 ? { content } : {});
 }
 function handleSteps(node, ctx, transformNode2, mapJsxChildren2) {
-  const stepChildren = componentChildren(node, BLOCK_TYPES.step);
-  const pmStepChildren = stepChildren.map((stepChild, index) => {
-    const stepAttrs = parseMdxAttributes(stepChild.attributes);
-    const titleText = stepAttrs.title;
-    const titleNode = createTitleNode(BLOCK_TYPES.stepTitle, titleText, ctx, transformNode2);
-    const bodyContent = mapJsxChildren2(stepChild, ctx);
-    const bodyNode = {
-      type: BLOCK_TYPES.stepBody,
-      content: bodyContent.length > 0 ? bodyContent : [{ type: "paragraph" }]
-    };
-    return {
-      type: BLOCK_TYPES.step,
-      attrs: Object.assign(Object.assign(Object.assign({}, partitionAttrs(stepAttrs, STEP_ATTRS, ["title"])), ctx.hasGroupParent && { __hasGroupParent: true }), { __childIndex: index, __isLastInGroup: index === stepChildren.length - 1 }),
-      content: [titleNode, bodyNode]
-    };
-  });
+  const children = flattenJsxParagraphs(node).children;
+  const stepChildren = [];
+  for (const child of children) {
+    if (child.type === "text" && child.value.trim() === "")
+      continue;
+    if (child.type !== "mdxJsxFlowElement" || child.name !== BLOCK_TYPES.step) {
+      return { type: BLOCK_TYPES.unknownTag, attrs: { mdxJsxNode: node } };
+    }
+    stepChildren.push(child);
+  }
+  const pmStepChildren = stepChildren.map((stepChild, index) => handleStep(stepChild, ctx, transformNode2, mapJsxChildren2, {
+    index,
+    isLast: index === stepChildren.length - 1
+  }));
   return {
     type: BLOCK_TYPES.steps,
     attrs: Object.assign(Object.assign({}, partitionAttrs(parseMdxAttributes(node.attributes), [])), ctx.hasGroupParent && { __hasGroupParent: true }),
     content: pmStepChildren
   };
 }
+function handleStep(node, ctx, transformNode2, mapJsxChildren2, groupPosition) {
+  const stepAttrs = parseMdxAttributes(node.attributes);
+  const titleText = stepAttrs.title;
+  const bodyContent = mapJsxChildren2(node, ctx);
+  return {
+    type: BLOCK_TYPES.step,
+    attrs: Object.assign(Object.assign(Object.assign({}, partitionAttrs(stepAttrs, STEP_ATTRS, ["title"])), ctx.hasGroupParent && { __hasGroupParent: true }), { __childIndex: groupPosition.index, __isLastInGroup: groupPosition.isLast }),
+    content: [
+      createTitleNode(BLOCK_TYPES.stepTitle, titleText, ctx, transformNode2),
+      {
+        type: BLOCK_TYPES.stepBody,
+        content: bodyContent.length > 0 ? bodyContent : [{ type: "paragraph" }]
+      }
+    ]
+  };
+}
 function handleAccordion(node, ctx, transformNode2, mapJsxChildren2) {
   const attrs2 = parseMdxAttributes(node.attributes);
   const titleText = attrs2.title;
@@ -1740,7 +1781,7 @@ function handleToggleContent(node, ctx, transformNode2, mapJsxChildren2) {
       type: childType,
       attrs: Object.assign(Object.assign({}, partitionChild(parseMdxAttributes(child.attributes))), { __isHidden: index !== 0, __hasGroupParent: true }),
       // We should only set isHidden to false for <Tab />, not the children inside the tab
-      content: mapJsxChildren2(child, Object.assign(Object.assign({}, ctx), { hasGroupParent: node.name !== BLOCK_TYPES.tabs, isHidden: node.name === BLOCK_TYPES.tabs ? false : index !== 0 }))
+      content: withRequiredContent(childType, mapJsxChildren2(child, Object.assign(Object.assign({}, ctx), { hasGroupParent: node.name !== BLOCK_TYPES.tabs, isHidden: node.name === BLOCK_TYPES.tabs ? false : index !== 0 })))
     }));
     return {
       type: (_d = node.name) !== null && _d !== void 0 ? _d : BLOCK_TYPES.tabs,
@@ -1748,6 +1789,12 @@ function handleToggleContent(node, ctx, transformNode2, mapJsxChildren2) {
       content: pmChildren
     };
   }
+  if (mapJsxChildren2(node, ctx).length > 0) {
+    return {
+      type: BLOCK_TYPES.unknownTag,
+      attrs: { mdxJsxNode: node }
+    };
+  }
   return {
     type: (_e = node.name) !== null && _e !== void 0 ? _e : BLOCK_TYPES.tabs,
     attrs: partitionWrapper(parseMdxAttributes(node.attributes)),
@@ -1756,25 +1803,14 @@ function handleToggleContent(node, ctx, transformNode2, mapJsxChildren2) {
 }
 function handleColumns(node, ctx, mapJsxChildren2) {
   const attrs2 = partitionAttrs(parseMdxAttributes(node.attributes), COLUMNS_ATTRS);
-  const columnChildren = componentChildren(node, BLOCK_TYPES.column);
-  if (columnChildren.length > 0) {
-    const pmChildren = columnChildren.map((child) => {
-      const content = mapJsxChildren2(child, Object.assign(Object.assign({}, ctx), { hasGroupParent: true }));
-      return {
-        type: BLOCK_TYPES.column,
-        content: content.length > 0 ? content : [{ type: "paragraph" }]
-      };
-    });
-    return {
-      type: BLOCK_TYPES.columns,
-      attrs: Object.assign(Object.assign({}, attrs2), ctx.hasGroupParent && { __hasGroupParent: true }),
-      content: pmChildren
-    };
-  }
+  const content = mapJsxChildren2(node, Object.assign(Object.assign({}, ctx), { hasGroupParent: true })).map((child) => {
+    var _a;
+    return child.type === BLOCK_TYPES.column ? Object.assign(Object.assign({}, child), { content: withRequiredContent(BLOCK_TYPES.column, (_a = child.content) !== null && _a !== void 0 ? _a : []) }) : child;
+  });
   return {
     type: BLOCK_TYPES.columns,
-    attrs: attrs2,
-    content: mapJsxChildren2(node, ctx)
+    attrs: Object.assign(Object.assign({}, attrs2), ctx.hasGroupParent && { __hasGroupParent: true }),
+    content
   };
 }
 function parseColorItemNode(node) {
@@ -2382,20 +2418,8 @@ function buildMarkdownTableCellContent(children, ctx, transformNode2) {
   return children.flatMap((child) => flattenNodeContent(transformNode2(child, ctx)));
 }
 function handleParagraph(node, ctx, transformNode2, mapChildren2) {
-  var _a, _b, _c, _d;
-  if (node.children.length === 1 && ((_a = node.children[0]) === null || _a === void 0 ? void 0 : _a.type) === "mdxJsxTextElement" && ((_b = node.children[0]) === null || _b === void 0 ? void 0 : _b.name)) {
-    const result = transformNode2(node.children[0], ctx);
-    const nodes2 = flattenNodeContent(result);
-    const schema3 = (_c = ctx.schema) !== null && _c !== void 0 ? _c : mintlifySchema;
-    const allInline = nodes2.length > 0 && nodes2.every((child) => {
-      var _a2;
-      return ((_a2 = schema3.nodes[child.type]) === null || _a2 === void 0 ? void 0 : _a2.isInline) === true;
-    });
-    if (allInline) {
-      return { type: "paragraph", content: nodes2 };
-    }
-    return result;
-  }
+  var _a;
+  const schema2 = (_a = ctx.schema) !== null && _a !== void 0 ? _a : mintlifySchema;
   const hasImages = node.children.some((child) => child.type === "image" || child.type === "mdxJsxTextElement" && child.name === "img");
   if (hasImages) {
     const hasTextContent = node.children.some((child) => child.type === "text" || child.type === "emphasis" || child.type === "strong" || child.type === "link" || child.type === "inlineCode" || child.type === "delete" || child.type === "mdxJsxTextElement" && child.name !== "img");
@@ -2415,7 +2439,7 @@ function handleParagraph(node, ctx, transformNode2, mapChildren2) {
           }
         }
       }
-      return { type: "paragraph", content: content2.filter(Boolean) };
+      return splitParagraphAroundBlocks(content2, schema2);
     }
     const blocks = [];
     for (const child of node.children) {
@@ -2430,7 +2454,6 @@ function handleParagraph(node, ctx, transformNode2, mapChildren2) {
     return blocks.length > 0 ? blocks : [];
   }
   const content = mapChildren2(node, ctx);
-  const schema2 = (_d = ctx.schema) !== null && _d !== void 0 ? _d : mintlifySchema;
   if (content.every((child) => isInlineNode(child, schema2))) {
     return { type: "paragraph", content };
   }
@@ -2443,15 +2466,15 @@ function splitParagraphAroundBlocks(content, schema2) {
   });
 }
 function trimParagraph(paragraph) {
-  var _a;
+  var _a, _b, _c;
   const content = [...(_a = paragraph.content) !== null && _a !== void 0 ? _a : []];
   const first = content[0];
-  if ((first === null || first === void 0 ? void 0 : first.type) === "text" && first.text) {
+  if ((first === null || first === void 0 ? void 0 : first.type) === "text" && first.text && !((_b = first.marks) === null || _b === void 0 ? void 0 : _b.some((mark) => mark.type === "code"))) {
     content[0] = Object.assign(Object.assign({}, first), { text: first.text.replace(/^\s+/, "") });
   }
   const lastIndex = content.length - 1;
   const last = content[lastIndex];
-  if ((last === null || last === void 0 ? void 0 : last.type) === "text" && last.text) {
+  if ((last === null || last === void 0 ? void 0 : last.type) === "text" && last.text && !((_c = last.marks) === null || _c === void 0 ? void 0 : _c.some((mark) => mark.type === "code"))) {
     content[lastIndex] = Object.assign(Object.assign({}, last), { text: last.text.replace(/\s+$/, "") });
   }
   return Object.assign(Object.assign({}, paragraph), { content: content.filter((n) => n.type !== "text" || n.text !== "") });
@@ -2520,7 +2543,8 @@ function mdastToPm(mdast, source = "", options) {
   const frontmatter = extractFrontmatter(mdast);
   const context = { source, frontmatter, schema: schema2 };
   visit2(mdast, (node) => {
-    if (node.type !== "list" && node.type !== "mdxJsxFlowElement") {
+    const promptNeedsSourcePosition = node.type === "mdxJsxTextElement" && node.name === "Prompt";
+    if (node.type !== "list" && node.type !== "mdxJsxFlowElement" && !promptNeedsSourcePosition) {
       delete node.position;
     }
   });
@@ -2535,7 +2559,7 @@ function mdastToPm(mdast, source = "", options) {
   return { doc, frontmatter };
 }
 function transformNode(node, ctx) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   if (!node)
     return [];
   switch (node.type) {
@@ -2632,8 +2656,14 @@ function transformNode(node, ctx) {
       };
     case "yaml":
       return [];
-    case "mdxJsxTextElement":
-      return handleInlineJsx(node, ctx, mapChildren);
+    case "mdxJsxTextElement": {
+      if (!node.name || !STRUCTURED_FLOW_COMPONENTS.has(node.name) || isContainerOnlyComponent(node.name, (_d = ctx.schema) !== null && _d !== void 0 ? _d : mintlifySchema)) {
+        return handleInlineJsx(node, ctx, mapChildren);
+      }
+      const flowResult = handleFlowJsx(Object.assign(Object.assign({}, node), { type: "mdxJsxFlowElement", children: node.children.length > 0 ? [{ type: "paragraph", children: node.children }] : [] }), ctx, transformNode, mapJsxChildren);
+      const flowNodes = Array.isArray(flowResult) ? flowResult : [flowResult];
+      return flowNodes.length > 0 ? flowResult : handleInlineJsx(node, ctx, mapChildren);
+    }
     case "mdxJsxFlowElement":
       return handleFlowJsx(node, ctx, transformNode, mapJsxChildren);
     case "mdxjsEsm":
@@ -9992,13 +10022,20 @@ function isWordChar(ch) {
 var SerializerState = class {
   constructor(options = {}) {
     var _a, _b, _c, _d;
-    this.out = "";
+    this.chunks = [];
+    this.chunkStarts = [];
+    this.outLength = 0;
+    this.tail = "";
+    this.trailingSpaces = 0;
+    this.topLevelLead = null;
     this.delim = "";
     this.closed = false;
     this.inTable = false;
     this.inCodeSection = false;
     this.hasReferenceDefinitions = false;
     this.indentSize = 2;
+    this.sourceMap = null;
+    this.nodePath = [];
     this.options = {
       tightLists: (_a = options.tightLists) !== null && _a !== void 0 ? _a : false,
       indentSize: (_b = options.indentSize) !== null && _b !== void 0 ? _b : 2,
@@ -10008,29 +10045,209 @@ var SerializerState = class {
     this.indentSize = this.options.indentSize;
     this.hasReferenceDefinitions = this.options.hasReferenceDefinitions;
   }
+  /** The serialized output */
+  get out() {
+    var _a;
+    if (this.chunks.length > 1) {
+      const joined = this.chunks.join("");
+      this.chunks = [joined];
+      this.chunkStarts = [0];
+    }
+    return (_a = this.chunks[0]) !== null && _a !== void 0 ? _a : "";
+  }
+  set out(value) {
+    this.chunks = [];
+    this.chunkStarts = [];
+    this.outLength = 0;
+    this.tail = "";
+    this.trailingSpaces = 0;
+    this.append(value);
+  }
+  get length() {
+    return this.outLength;
+  }
+  get trailingSpaceCount() {
+    return this.trailingSpaces;
+  }
+  /** Output written at or after `offset`. */
+  sliceFrom(offset) {
+    var _a, _b;
+    let lo = 0;
+    let hi = this.chunkStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (((_a = this.chunkStarts[mid]) !== null && _a !== void 0 ? _a : 0) <= offset)
+        lo = mid;
+      else
+        hi = mid - 1;
+    }
+    const first = this.chunks[lo];
+    if (first === void 0)
+      return "";
+    return first.slice(offset - ((_b = this.chunkStarts[lo]) !== null && _b !== void 0 ? _b : 0)) + this.chunks.slice(lo + 1).join("");
+  }
+  /** Drop the last `count` characters of the output. */
+  truncate(count) {
+    var _a, _b, _c;
+    let remaining = count;
+    while (remaining > 0 && this.chunks.length > 0) {
+      const last = (_a = this.chunks[this.chunks.length - 1]) !== null && _a !== void 0 ? _a : "";
+      if (last.length <= remaining) {
+        remaining -= last.length;
+        this.chunks.pop();
+        this.chunkStarts.pop();
+      } else {
+        this.chunks[this.chunks.length - 1] = last.slice(0, last.length - remaining);
+        remaining = 0;
+      }
+    }
+    this.outLength -= count - remaining;
+    this.tail = "";
+    this.trailingSpaces = 0;
+    for (let i = this.chunks.length - 1; i >= 0 && this.tail.length < 2; i--) {
+      this.tail = (((_b = this.chunks[i]) !== null && _b !== void 0 ? _b : "") + this.tail).slice(-2);
+    }
+    for (let i = this.chunks.length - 1; i >= 0; i--) {
+      const chunk = (_c = this.chunks[i]) !== null && _c !== void 0 ? _c : "";
+      let j = chunk.length;
+      while (j > 0 && chunk.charCodeAt(j - 1) === 32)
+        j--;
+      this.trailingSpaces += chunk.length - j;
+      if (j > 0)
+        break;
+    }
+  }
+  append(content) {
+    if (content.length === 0)
+      return;
+    this.chunkStarts.push(this.outLength);
+    this.chunks.push(content);
+    this.outLength += content.length;
+    this.tail = (this.tail + content).slice(-2);
+    let i = content.length;
+    while (i > 0 && content.charCodeAt(i - 1) === 32)
+      i--;
+    this.trailingSpaces = i === 0 ? this.trailingSpaces + content.length : content.length - i;
+    const lead = this.topLevelLead;
+    if (lead && !lead.content) {
+      let j = 0;
+      while (j < content.length && content.charCodeAt(j) === 10)
+        j++;
+      lead.lead += j;
+      if (j < content.length)
+        lead.content = true;
+    }
+  }
+  beginBlock(index) {
+    if (!this.sourceMap)
+      return 0;
+    this.nodePath.push(index);
+    if (this.nodePath.length === 1)
+      this.topLevelLead = { lead: 0, content: false };
+    return this.outLength;
+  }
+  endBlock(start) {
+    var _a, _b;
+    if (!this.sourceMap)
+      return;
+    if (this.nodePath.length === 1) {
+      const lead = (_b = (_a = this.topLevelLead) === null || _a === void 0 ? void 0 : _a.lead) !== null && _b !== void 0 ? _b : 0;
+      this.topLevelLead = null;
+      this.sourceMap.push({
+        path: [...this.nodePath],
+        start: start + lead,
+        end: this.outLength,
+        kind: "block"
+      });
+    }
+    this.nodePath.pop();
+  }
+  recordTextSuffix(index, length, pmStart, pmEnd) {
+    if (!this.sourceMap || this.inTable)
+      return;
+    this.sourceMap.push({
+      path: [...this.nodePath, index],
+      start: this.outLength - length,
+      end: this.outLength,
+      kind: "text",
+      pmStart,
+      pmEnd
+    });
+  }
+  takeTextSuffix(length) {
+    if (!this.sourceMap || length === 0)
+      return null;
+    const entry = this.sourceMap.at(-1);
+    if ((entry === null || entry === void 0 ? void 0 : entry.kind) !== "text" || entry.end !== this.outLength || entry.end - entry.start < length || entry.pmEnd - entry.pmStart < length) {
+      return null;
+    }
+    const mapping = Object.assign({ path: [...entry.path], kind: "text", pmStart: entry.pmEnd - length, pmEnd: entry.pmEnd }, entry.offsetEncoding && { offsetEncoding: entry.offsetEncoding });
+    entry.end -= length;
+    entry.pmEnd -= length;
+    if (entry.start === entry.end)
+      this.sourceMap.pop();
+    return mapping;
+  }
+  recordTextRange(mapping, start, end) {
+    if (!this.sourceMap || this.inTable)
+      return;
+    this.sourceMap.push(Object.assign(Object.assign({}, mapping), { start, end }));
+  }
+  withNodePath(index, render) {
+    if (!this.sourceMap)
+      return render();
+    this.nodePath.push(index);
+    try {
+      return render();
+    } finally {
+      this.nodePath.pop();
+    }
+  }
+  recordLiteralTextRange(path, start, end) {
+    if (!this.sourceMap || this.inTable)
+      return;
+    this.sourceMap.push({
+      path: [...this.nodePath, ...path],
+      start,
+      end,
+      kind: "text",
+      pmStart: 0,
+      pmEnd: end - start,
+      offsetEncoding: "identity"
+    });
+  }
+  importTextEntries(entries, pathPrefix, mapOffset) {
+    if (!this.sourceMap)
+      return;
+    for (const entry of entries) {
+      if (entry.kind !== "text")
+        continue;
+      this.sourceMap.push(Object.assign({ path: [...this.nodePath, ...pathPrefix, ...entry.path], start: mapOffset(entry.start), end: mapOffset(entry.end), kind: "text", pmStart: entry.pmStart, pmEnd: entry.pmEnd }, entry.offsetEncoding && { offsetEncoding: entry.offsetEncoding }));
+    }
+  }
   /**
    * Writes content to the output, handling closed blocks and current delimiters.
    */
   write(content) {
     if (this.closed) {
-      this.out += "\n";
+      this.append("\n");
       this.closed = false;
     }
-    if (this.delim && this.out.endsWith("\n") && content.length > 0 && content[0] !== "\n") {
-      this.out += this.delim;
+    if (this.delim && this.tail.endsWith("\n") && content.length > 0 && content[0] !== "\n") {
+      this.append(this.delim);
     }
-    this.out += content;
+    this.append(content);
   }
   ensureNewLine() {
-    if (!this.out.endsWith("\n")) {
-      this.out += "\n";
+    if (!this.tail.endsWith("\n")) {
+      this.append("\n");
     }
   }
   ensureBlankLine() {
-    if (this.out.endsWith("\n\n")) {
+    if (this.tail.endsWith("\n\n")) {
       return;
     }
-    this.out += this.out.endsWith("\n") ? "\n" : "\n\n";
+    this.append(this.tail.endsWith("\n") ? "\n" : "\n\n");
   }
   /**
    * Marks the current block as closed. Appropriate spacing will be added on the next write().
@@ -10245,18 +10462,41 @@ function writeJsxAttributesInline(state, attrs2) {
 }
 
 // ../editor/dist/converter/serialize/handlers/markdown.js
+var offsetMapperForLines = (source, parentContentStarts) => {
+  const sourceLineStarts = [0];
+  for (let index = 0; index < source.length; index++) {
+    if (source[index] === "\n")
+      sourceLineStarts.push(index + 1);
+  }
+  return (offset) => {
+    var _a, _b, _c, _d;
+    const clamped = Math.min(Math.max(offset, 0), source.length);
+    let lineIndex = sourceLineStarts.length - 1;
+    while (lineIndex > 0 && ((_a = sourceLineStarts[lineIndex]) !== null && _a !== void 0 ? _a : 0) > clamped)
+      lineIndex--;
+    const sourceLineStart = (_b = sourceLineStarts[lineIndex]) !== null && _b !== void 0 ? _b : 0;
+    const parentLineStart = (_d = (_c = parentContentStarts[lineIndex]) !== null && _c !== void 0 ? _c : parentContentStarts.at(-1)) !== null && _d !== void 0 ? _d : 0;
+    return parentLineStart + clamped - sourceLineStart;
+  };
+};
 function renderBlockquote(state, node, renderNode2) {
-  var _a;
+  var _a, _b;
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     const childState = new SerializerState(state.options);
+    childState.sourceMap = state.sourceMap ? [] : null;
     renderNode2(childState, child, node, i);
-    const lines = childState.out.replace(/\n+$/, "").split("\n");
+    const childOutput = childState.out.replace(/\n+$/, "");
+    const lines = childOutput.split("\n");
+    const parentContentStarts = [];
     for (let j = 0; j < lines.length; j++) {
       const line = (_a = lines[j]) !== null && _a !== void 0 ? _a : "";
-      state.write(line.length > 0 ? `> ${line}` : ">");
+      state.write(line.length > 0 ? "> " : ">");
+      parentContentStarts.push(state.length);
+      state.write(line);
       state.ensureNewLine();
     }
+    state.importTextEntries((_b = childState.sourceMap) !== null && _b !== void 0 ? _b : [], [i], offsetMapperForLines(childOutput, parentContentStarts));
     if (i < node.childCount - 1) {
       state.write(">");
       state.ensureNewLine();
@@ -10265,7 +10505,7 @@ function renderBlockquote(state, node, renderNode2) {
   state.closeBlock();
 }
 function renderList(state, node, ordered, renderContent2) {
-  var _a;
+  var _a, _b;
   const start = node.attrs.start || 1;
   const isTight = typeof node.attrs.tight === "boolean" ? node.attrs.tight : state.options.tightLists;
   for (let i = 0; i < node.childCount; i++) {
@@ -10275,19 +10515,30 @@ function renderList(state, node, ordered, renderContent2) {
     const prefix = (ordered ? `${start + i}. ` : "- ") + taskMarker;
     const indent = " ".repeat(prefix.length);
     const itemState = new SerializerState(state.options);
+    itemState.sourceMap = state.sourceMap ? [] : null;
     renderContent2(itemState, child);
-    const lines = itemState.out.split("\n");
+    const itemOutput = itemState.out;
+    const lines = itemOutput.split("\n");
+    const parentContentStarts = [];
     for (let j = 0; j < lines.length; j++) {
       const line = (_a = lines[j]) !== null && _a !== void 0 ? _a : "";
       if (j === 0) {
-        state.write(prefix + line);
+        state.write(prefix);
+        parentContentStarts.push(state.length);
+        state.write(line);
       } else if (line.length > 0) {
         state.ensureNewLine();
-        state.write(indent + line);
+        state.write(indent);
+        parentContentStarts.push(state.length);
+        state.write(line);
       } else if (!isTight && j < lines.length - 1) {
         state.ensureBlankLine();
+        parentContentStarts.push(state.length);
+      } else {
+        parentContentStarts.push(state.length);
       }
     }
+    state.importTextEntries((_b = itemState.sourceMap) !== null && _b !== void 0 ? _b : [], [i], offsetMapperForLines(itemOutput, parentContentStarts));
     state.ensureNewLine();
   }
   state.closeBlock();
@@ -10546,7 +10797,21 @@ function renderTitledComponent(state, node, name, renderContent2, renderInline2,
   }
   const titleAttribute = isJSXContent(title) ? title.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;") : title;
   const extractedAttrs = titleAttribute ? Object.assign({ title: titleAttribute }, node.attrs) : Object.assign({}, node.attrs);
+  const outputStart = state.length;
   renderComponentWithAttrs(state, node, name, extractedAttrs, renderContent2, excludeAttrs);
+  const titleText = titleChild === null || titleChild === void 0 ? void 0 : titleChild.firstChild;
+  if (!(titleText === null || titleText === void 0 ? void 0 : titleText.isText) || titleText.text !== title)
+    return;
+  const rendered = state.sliceFrom(outputStart);
+  const openingStart = rendered.indexOf(`<${name}`);
+  const openingEnd = rendered.indexOf("\n", openingStart);
+  const attributeStart = rendered.indexOf("title=", openingStart);
+  const valueStart = rendered.indexOf(title, attributeStart + "title=".length);
+  if (openingStart < 0 || openingEnd < 0 || attributeStart < 0 || valueStart < 0)
+    return;
+  if (attributeStart >= openingEnd || valueStart + title.length > openingEnd)
+    return;
+  state.recordLiteralTextRange([0, 0], outputStart + valueStart, outputStart + valueStart + title.length);
 }
 function renderGenericComponent(state, node, name, renderContent2, excludeAttrs = []) {
   renderComponentWithAttrs(state, node, name, node.attrs, renderContent2, excludeAttrs);
@@ -10943,6 +11208,10 @@ var MARK_PRESERVING_INLINE = /* @__PURE__ */ new Set([
   BLOCK_TYPES.inlineImage,
   BLOCK_TYPES.inlineUnknownTag
 ]);
+var serializableMarks = (marks2) => marks2.filter((mark) => {
+  const { open, close } = getMarkStrings(mark);
+  return open.length > 0 || close.length > 0;
+});
 function reorderMarksForLink(marks2, parent, childIndex) {
   if (marks2.length < 2)
     return marks2;
@@ -10994,15 +11263,17 @@ function renderInline(state, node, renderNode2, inlineRenderers2) {
         earliestClose = Math.min(earliestClose, codeIndex);
       }
       let trailingSpace = "";
+      let trailingTextMapping = null;
       const closingFlanking = [...closingIndices].some((idx) => {
         const m = active[idx];
         return m !== void 0 && usesFlanking(m);
       });
       if (closingFlanking) {
-        const match = state.out.match(/ +$/);
-        if (match) {
-          trailingSpace = match[0];
-          state.out = state.out.slice(0, -trailingSpace.length);
+        const spaces = state.trailingSpaceCount;
+        if (spaces > 0) {
+          trailingSpace = " ".repeat(spaces);
+          trailingTextMapping = state.takeTextSuffix(spaces);
+          state.truncate(spaces);
         }
       }
       for (let i = active.length - 1; i >= earliestClose; i--) {
@@ -11021,7 +11292,11 @@ function renderInline(state, node, renderNode2, inlineRenderers2) {
       }
       active = active.slice(0, earliestClose);
       if (trailingSpace) {
+        const trailingStart = state.length;
         state.write(trailingSpace);
+        if (trailingTextMapping) {
+          state.recordTextRange(trailingTextMapping, trailingStart, state.length);
+        }
       }
       for (const mark of continuing) {
         if (mark.type.name === "code") {
@@ -11052,32 +11327,35 @@ function renderInline(state, node, renderNode2, inlineRenderers2) {
       let text = child.text || "";
       if (!text)
         continue;
-      const openingFlanking = child.marks.some((m) => usesFlanking(m) && !active.some((a) => a.eq(m)));
+      const textLength = text.length;
+      let pmOffset = 0;
+      const childMarks = serializableMarks(child.marks);
+      const openingFlanking = childMarks.some((m) => usesFlanking(m) && !active.some((a) => a.eq(m)));
       if (openingFlanking) {
         const leadingMatch = text.match(/^( +)/);
         if (leadingMatch) {
           state.write(leadingMatch[0]);
+          state.recordTextSuffix(i, leadingMatch[0].length, 0, leadingMatch[0].length);
+          pmOffset = leadingMatch[0].length;
           text = text.slice(leadingMatch[0].length);
           if (!text)
             continue;
         }
       }
-      const marks2 = reorderMarksForLink(child.marks, node, i);
+      const marks2 = reorderMarksForLink(childMarks, node, i);
       transitionMarks(marks2);
-      if (active.some((m) => m.type.name === "code")) {
-        state.write(state.escCodeText(text));
-      } else {
-        state.write(state.esc(text, { inLinkText: active.some((m) => m.type.name === "link") }));
-      }
+      const written = active.some((m) => m.type.name === "code") ? state.escCodeText(text) : state.esc(text, { inLinkText: active.some((m) => m.type.name === "link") });
+      state.write(written);
+      state.recordTextSuffix(i, written.length, pmOffset, textLength);
     } else {
       if (typeName === BLOCK_TYPES.inlineImage) {
-        transitionMarks(reorderMarksForLink(child.marks, node, i));
+        transitionMarks(reorderMarksForLink(serializableMarks(child.marks), node, i));
         inlineRenderers2.renderInlineImage(state, child);
         continue;
       }
       if (typeName === BLOCK_TYPES.inlineUnknownTag) {
-        transitionMarks(reorderMarksForLink(child.marks, node, i));
-        inlineRenderers2.renderUnknownTag(state, child);
+        transitionMarks(reorderMarksForLink(serializableMarks(child.marks), node, i));
+        state.withNodePath(i, () => inlineRenderers2.renderUnknownTag(state, child));
         continue;
       }
       transitionMarks([]);
@@ -11088,7 +11366,7 @@ function renderInline(state, node, renderNode2, inlineRenderers2) {
       } else if (typeName === BLOCK_TYPES.badge) {
         inlineRenderers2.renderBadge(state, child);
       } else if (typeName === BLOCK_TYPES.tooltip) {
-        inlineRenderers2.renderTooltip(state, child);
+        state.withNodePath(i, () => inlineRenderers2.renderTooltip(state, child));
       } else if (typeName === BLOCK_TYPES.inlineMath) {
         if (child.attrs.expression) {
           state.write(`$$${child.attrs.expression}$$`);
@@ -11104,7 +11382,7 @@ function renderTextNode(state, node) {
   const text = node.text || "";
   if (!text)
     return;
-  const marks2 = node.marks;
+  const marks2 = serializableMarks(node.marks);
   let openMarks = "";
   let closeMarks = "";
   for (const mark of marks2) {
@@ -11242,8 +11520,12 @@ function hasReferenceDefinitions(doc) {
   return found;
 }
 function pmToMdx(doc, options = {}) {
+  return serializeDoc(doc, options, null).mdx;
+}
+function serializeDoc(doc, options, sourceMap) {
   const { frontmatter } = options, serializerOptions = __rest2(options, ["frontmatter"]);
   const state = new SerializerState(Object.assign(Object.assign({}, serializerOptions), { hasReferenceDefinitions: hasReferenceDefinitions(doc) }));
+  state.sourceMap = sourceMap;
   if (frontmatter && Object.keys(frontmatter).length > 0) {
     const entries = Object.entries(filterFrontmatterRecord(frontmatter));
     if (entries.length > 0) {
@@ -11260,19 +11542,20 @@ function pmToMdx(doc, options = {}) {
   if (options.removeTrailingNewline !== false && result.endsWith("\n")) {
     result = result.replace(/\n+$/, "");
   }
-  return result;
+  return { mdx: result, sourceMap: sourceMap !== null && sourceMap !== void 0 ? sourceMap : [] };
 }
 function renderContent(state, node) {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (i > 0) {
       state.ensureNewLine();
-      const prev = node.child(i - 1);
-      if (needsBlankLine(prev, child)) {
+      if (needsBlankLine(node.child(i - 1), child)) {
         state.ensureNewLine();
       }
     }
+    const start = state.beginBlock(i);
     renderNode(state, child, node, i);
+    state.endBlock(start);
   }
 }
 function needsBlankLine(prev, current) {