@mintlify/cli 4.0.1474 → 4.0.1475

package/bin/vendor/converter.js

@@ -1340,13 +1340,22 @@ function convertHtmlCommentsToJsx(mdx) {
   const parts = mdx.split(/(```[\s\S]*?```|~~~[\s\S]*?~~~)/);
   return parts.map((part, i) => i % 2 === 0 ? part.replace(/<!--([\s\S]*?)-->/g, (_m, c) => `{/* ${c} */}`) : part).join("");
 }
-function mdxToMdast(mdx, options = {
-  omitHtmlComments: true
-}) {
+function preprocessMdxSource(mdx, options = {}) {
   var _a;
   const sanitized = ((_a = options.omitHtmlComments) !== null && _a !== void 0 ? _a : true) ? convertHtmlCommentsToJsx(mdx) : mdx;
+  return {
+    sanitized,
+    preprocessed: preprocessCustomHeadingIds(sanitized, { preserveOriginal: true })
+  };
+}
+function parsePreprocessedMdx(preprocessed, options = {}) {
   const parser = options.singleDollarTextMath === false ? noSingleDollarTextMathRemark : coreRemark;
-  return parser().parse(preprocessCustomHeadingIds(sanitized, { preserveOriginal: true }));
+  return parser().parse(preprocessed);
+}
+function mdxToMdast(mdx, options = {
+  omitHtmlComments: true
+}) {
+  return parsePreprocessedMdx(preprocessMdxSource(mdx, options).preprocessed, options);
 }
 
 // ../editor/dist/converter/parse/handlers/prompt.js
@@ -10370,8 +10379,12 @@ var SerializerState = class {
   }
   /** Escapes special Markdown characters in the input string. */
   esc(str2, options = {}) {
+    return this.escRange(str2, 0, str2.length, options);
+  }
+  /** Escapes `str[from, to)` using the whole string as context. */
+  escRange(str2, from, to, options = {}) {
     let out = "";
-    for (let i = 0; i < str2.length; i++) {
+    for (let i = from; i < to; i++) {
       const ch = str2[i];
       if (this.needsEscape(str2, i, options))
         out += "\\";
@@ -11653,6 +11666,12 @@ function hasReferenceDefinitions(doc) {
 function pmToMdx(doc, options = {}) {
   return serializeDoc(doc, options, null).mdx;
 }
+function serializeNodeWithDelim(node, options, delim) {
+  const state = new SerializerState(options);
+  state.delim = delim;
+  renderNode(state, node, node, 0);
+  return state.out.replace(/(\n[ \t]*)+$/, "");
+}
 function serializeDoc(doc, options, sourceMap) {
   var _a;
   const { frontmatter } = options, serializerOptions = __rest2(options, ["frontmatter"]);
@@ -11880,21 +11899,9 @@ function renderNode(state, node, _parent, _index) {
   }
 }
 
-// ../editor/dist/converter/serialize/pm-to-mdast.js
-function pmJsonToMdast(_doc, _frontmatter) {
-  throw new Error("pmJsonToMdast is not yet implemented \u2014 use pmToMdx instead for direct MDX output");
-}
-
-// ../editor/dist/converter/serialize/mdast-to-mdx.js
-import remarkGfm3 from "remark-gfm";
-import remarkMath2 from "remark-math";
-import remarkMdx3 from "remark-mdx";
-import remarkStringify2 from "remark-stringify";
-import { unified as unified2 } from "unified";
-function mdastToMdx(mdast) {
-  const result = unified2().use(remarkMdx3).use(remarkGfm3).use(remarkMath2).use(remarkStringify2).stringify(mdast);
-  return typeof result === "string" ? result : String(result);
-}
+// ../editor/dist/converter/serialize/pm-to-mdx-preserving.js
+import { Fragment } from "prosemirror-model";
+import { parse as parseYaml2 } from "yaml";
 
 // ../editor/dist/converter/diff/node-utils.js
 var deepEqual = (a, b) => {
@@ -12063,6 +12070,940 @@ var isCode = (nodeType, schema2) => {
   return (_a = spec === null || spec === void 0 ? void 0 : spec.spec.code) !== null && _a !== void 0 ? _a : false;
 };
 
+// ../editor/dist/converter/serialize/pm-to-mdx-preserving.js
+var __rest3 = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+var JSX_HEADING_OPEN = /^\s*<h[1-6] id="/;
+var JSX_HEADING_CLOSE = /^\s*<\/h[1-6]>$/;
+var MAX_ALIGNMENT_CELLS = 25e6;
+var LIST_MARKER = /^([-*+]|(\d+)([.)]))[ \t]+/;
+var TITLED_TYPES = /* @__PURE__ */ new Set([BLOCK_TYPES.card, BLOCK_TYPES.accordion, BLOCK_TYPES.step]);
+var LIST_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList"]);
+var JSX_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+  BLOCK_TYPES.callout,
+  BLOCK_TYPES.card,
+  BLOCK_TYPES.accordion,
+  BLOCK_TYPES.accordionGroup,
+  BLOCK_TYPES.step,
+  BLOCK_TYPES.steps,
+  BLOCK_TYPES.tab,
+  BLOCK_TYPES.tabs,
+  BLOCK_TYPES.column,
+  BLOCK_TYPES.columns,
+  BLOCK_TYPES.update,
+  BLOCK_TYPES.frame,
+  BLOCK_TYPES.expandable,
+  BLOCK_TYPES.paramField,
+  BLOCK_TYPES.responseField,
+  BLOCK_TYPES.visibility,
+  BLOCK_TYPES.customComponent,
+  BLOCK_TYPES.codeGroup,
+  BLOCK_TYPES.requestExample,
+  BLOCK_TYPES.responseExample
+]);
+function pmToMdxPreservingSource(doc, options) {
+  const { source, parseOptions, onFallback, frontmatter } = options, serializerOptions = __rest3(options, ["source", "parseOptions", "onFallback", "frontmatter"]);
+  const canonicalOptions = Object.assign(Object.assign({}, serializerOptions), { frontmatter });
+  const fallback = (reason, candidate, error) => {
+    onFallback === null || onFallback === void 0 ? void 0 : onFallback(reason, candidate, error);
+    return pmToMdx(doc, canonicalOptions);
+  };
+  try {
+    const preserver = Preserver.create(doc, source, parseOptions !== null && parseOptions !== void 0 ? parseOptions : {}, serializerOptions);
+    if (!preserver)
+      return fallback("unmappable");
+    const out = preserver.run(frontmatter);
+    if (out === null)
+      return fallback("alignment");
+    if (!preserver.roundTrips(out))
+      return fallback("roundtrip", out);
+    return out;
+  } catch (error) {
+    return fallback("error", void 0, error);
+  }
+}
+var SourceCoords = class _SourceCoords {
+  constructor(source, preprocessed, lineMap) {
+    this.source = source;
+    this.lineMap = lineMap;
+    this.lineStarts = computeLineStarts(source);
+    this.origLines = source.split("\n");
+    this.preLines = preprocessed.split("\n");
+  }
+  static create(source, sanitized, preprocessed) {
+    const lineMap = buildLineMap(sanitized, preprocessed);
+    return lineMap ? new _SourceCoords(source, preprocessed, lineMap) : null;
+  }
+  lineStart(offset) {
+    return this.source.lastIndexOf("\n", offset - 1) + 1;
+  }
+  lineEnd(line) {
+    return line + 1 < this.lineStarts.length ? this.lineStarts[line + 1] - 1 : this.source.length;
+  }
+  exact(preLine, origLine) {
+    return this.preLines[preLine] === this.origLines[origLine];
+  }
+  span(node) {
+    const position = node.position;
+    if (!position)
+      return null;
+    const startLine = this.lineMap[position.start.line - 1];
+    const endLine = this.lineMap[position.end.line - 1];
+    if (startLine === void 0 || endLine === void 0)
+      return null;
+    const start = this.exact(position.start.line - 1, startLine) ? this.lineStarts[startLine] + position.start.column - 1 : this.lineStarts[startLine];
+    const end = this.exact(position.end.line - 1, endLine) ? this.lineStarts[endLine] + position.end.column - 1 : this.lineEnd(endLine);
+    if (start > end || end > this.source.length)
+      return null;
+    return { start, end };
+  }
+};
+var LevelWriter = class {
+  constructor(source, src, frame) {
+    this.source = source;
+    this.src = src;
+    this.frame = frame;
+    this.out = "";
+    this.first = true;
+    this.prevSrc = null;
+    this.prevType = null;
+  }
+  sep(nextSrc, nextType, multilineCanonical) {
+    const { frame } = this;
+    if (this.first) {
+      this.out += frame.open;
+      if (multilineCanonical && frame.kind === "jsx" && !/\n[ \t]*$/.test(frame.open)) {
+        this.out += `
+${frame.indent}`;
+      }
+      this.first = false;
+      return;
+    }
+    if (nextSrc !== null && this.prevSrc !== null && nextSrc === this.prevSrc + 1) {
+      this.out += this.source.slice(this.src[this.prevSrc].end, this.src[nextSrc].start);
+      return;
+    }
+    const lazy = frame.kind === "item" && frame.sepBody === "\n" && this.prevType === "paragraph" && nextType === "paragraph";
+    this.out += (lazy ? "\n\n" : frame.sepBody) + this.indentFor(nextSrc);
+  }
+  indentFor(srcIndex) {
+    if (srcIndex === null)
+      return this.frame.indent;
+    const start = this.src[srcIndex].start;
+    const prefix = this.source.slice(this.source.lastIndexOf("\n", start - 1) + 1, start);
+    return /^[ \t]*$/.test(prefix) ? prefix : this.frame.indent;
+  }
+  verbatim(index) {
+    var _a, _b, _c, _d;
+    const child = this.src[index];
+    this.sep(index, (_b = (_a = child.node) === null || _a === void 0 ? void 0 : _a.type.name) !== null && _b !== void 0 ? _b : null, false);
+    this.out += this.source.slice(child.start, child.end);
+    this.prevSrc = index;
+    this.prevType = (_d = (_c = child.node) === null || _c === void 0 ? void 0 : _c.type.name) !== null && _d !== void 0 ? _d : null;
+  }
+  recursed(index, text, type2) {
+    this.sep(index, type2, false);
+    this.out += text;
+    this.prevSrc = index;
+    this.prevType = type2;
+  }
+  canonical(text, type2) {
+    this.sep(null, type2, text.includes("\n"));
+    this.out += text;
+    this.prevSrc = null;
+    this.prevType = type2;
+  }
+  raw(text) {
+    this.out += text;
+    this.first = false;
+    this.prevSrc = null;
+    this.prevType = null;
+  }
+  finish() {
+    const { frame } = this;
+    if (this.first) {
+      return frame.kind === "top" ? "" : frame.open.replace(/[ \t]+$/, "") + frame.close;
+    }
+    if (this.src.length > 0 && this.prevSrc === this.src.length - 1) {
+      return this.out + frame.close;
+    }
+    if (frame.kind === "top") {
+      return this.source.endsWith("\n") && !this.out.endsWith("\n") ? `${this.out}
+` : this.out;
+    }
+    if (!frame.close)
+      return this.out;
+    if (frame.close.startsWith("\n") || !this.out.slice(frame.open.length).includes("\n")) {
+      return this.out + frame.close;
+    }
+    return `${this.out}
+${frame.containerIndent}${frame.close}`;
+  }
+};
+var Preserver = class _Preserver {
+  constructor(doc, coords, root, parseOptions, ser) {
+    this.doc = doc;
+    this.coords = coords;
+    this.root = root;
+    this.parseOptions = parseOptions;
+    this.ser = ser;
+    this.keyIds = /* @__PURE__ */ new Map();
+    this.source = coords.source;
+    this.schema = doc.type.schema;
+    this.emptyParagraph = this.schema.nodes.paragraph.create();
+  }
+  static create(doc, source, parseOptions, serializerOptions) {
+    const { sanitized, preprocessed } = preprocessMdxSource(source, parseOptions);
+    const coords = SourceCoords.create(source, sanitized, preprocessed);
+    if (!coords)
+      return null;
+    const root = parsePreprocessedMdx(preprocessed, parseOptions);
+    const ser = Object.assign(Object.assign({}, serializerOptions), { removeTrailingNewline: true, hasReferenceDefinitions: hasReferenceDefinitions(doc) });
+    return new _Preserver(doc, coords, root, parseOptions, ser);
+  }
+  roundTrips(out) {
+    const reparse = (mdx) => pmToMdx(mdxToPm(mdx, Object.assign(Object.assign({}, this.parseOptions), { schema: this.schema })).doc, this.ser);
+    const canonical = pmToMdx(this.doc, this.ser);
+    const candidate = reparse(out);
+    return candidate === canonical || candidate === reparse(canonical);
+  }
+  run(frontmatter) {
+    const src = this.buildSrcChildren(this.root.children);
+    if (!src)
+      return null;
+    const live = docChildren(this.doc);
+    const canonicalFrontmatter = this.frontmatterText(frontmatter);
+    const omitted = frontmatter === void 0 || canonicalFrontmatter === "";
+    const delta = omitted ? { kind: "rewrite" } : frontmatterDelta(extractFrontmatter(this.root), frontmatter);
+    const top = {
+      omitted,
+      unchanged: delta.kind === "same",
+      appended: delta.kind === "append" ? delta.lines : null,
+      record: frontmatter,
+      canonical: canonicalFrontmatter,
+      hasYaml: src.some((child) => child.mdast.type === "yaml")
+    };
+    if (src.length === 0 && live.length === 0 && top.omitted)
+      return this.source;
+    const frame = {
+      kind: "top",
+      open: src.length > 0 && !(top.omitted && top.hasYaml) ? this.source.slice(0, src[0].start) : "",
+      close: src.length > 0 ? this.source.slice(src[src.length - 1].end) : "",
+      indent: "",
+      containerIndent: "",
+      sepBody: "\n\n",
+      list: null
+    };
+    return this.emitLevel({ outerOpen: "", innerOpen: "", close: "", chain: [] }, live, src, frame, top);
+  }
+  frontmatterText(frontmatter) {
+    const emptyDoc = this.schema.topNodeType.createAndFill();
+    if (!emptyDoc)
+      return "";
+    return pmToMdx(emptyDoc, Object.assign(Object.assign({}, this.ser), { frontmatter }));
+  }
+  keyOf(node) {
+    const key = blockKey(node, this.ser);
+    let id = this.keyIds.get(key);
+    if (id === void 0) {
+      id = this.keyIds.size;
+      this.keyIds.set(key, id);
+    }
+    return id;
+  }
+  buildSrcChildren(nodes2) {
+    const children = [];
+    for (const mdast of nodes2) {
+      for (const part of promotedElements(mdast)) {
+        const span = this.coords.span(part);
+        if (!span)
+          return null;
+        children.push({
+          mdast: part,
+          start: span.start,
+          end: span.end,
+          keys: null,
+          node: null,
+          nodes: null
+        });
+      }
+    }
+    return children;
+  }
+  linePrefix(offset) {
+    return this.source.slice(this.coords.lineStart(offset), offset);
+  }
+  wrapperOpen(level, start, first) {
+    const prefix = this.linePrefix(start);
+    const combined = level.outerOpen + level.innerOpen;
+    if (!/^[ \t]*$/.test(prefix))
+      return combined;
+    if (/^[ \t]*$/.test(combined))
+      return prefix;
+    if (first)
+      return combined;
+    const newline = combined.lastIndexOf("\n");
+    const tail = combined.slice(newline + 1);
+    return /^[ \t]*$/.test(tail) ? combined.slice(0, newline + 1) + prefix : `${combined.trimEnd()}
+${prefix}`;
+  }
+  parseInContext(level, start, end, first) {
+    return this.parseText(level, this.source.slice(start, end), start, first);
+  }
+  parseText(level, text, start, first) {
+    let parsed;
+    try {
+      const wrapped = this.wrapperOpen(level, start, first) + text + level.close;
+      parsed = mdxToPm(wrapped, Object.assign(Object.assign({}, this.parseOptions), { schema: this.schema })).doc;
+    } catch (_a) {
+      return null;
+    }
+    let current = parsed;
+    for (const type2 of level.chain) {
+      const kids = contentChildren(current);
+      if (kids.length !== 1 || kids[0].type.name !== type2)
+        return null;
+      current = kids[0];
+    }
+    return contentChildren(current);
+  }
+  fillKeys(level, child, first) {
+    if (child.mdast.type === "yaml")
+      return;
+    const nodes2 = this.parseInContext(level, child.start, child.end, first);
+    child.keys = nodes2 ? nodes2.map((node) => this.keyOf(node)) : null;
+    child.node = nodes2 && nodes2.length === 1 ? nodes2[0] : null;
+    child.nodes = nodes2;
+  }
+  coalesce(level, src, matches) {
+    var _a, _b;
+    let merged = false;
+    for (let i = src.length - 2; i >= 0; i--) {
+      const a = src[i];
+      const b = src[i + 1];
+      if (!((_a = a.keys) === null || _a === void 0 ? void 0 : _a.length) || !((_b = b.keys) === null || _b === void 0 ? void 0 : _b.length))
+        continue;
+      if (matches[i] !== null || matches[i + 1] !== null)
+        continue;
+      const nodes2 = this.parseInContext(level, a.start, b.end, i === 0);
+      if (!nodes2)
+        continue;
+      const keys = nodes2.map((node) => this.keyOf(node));
+      if (sameKeys(keys, [...a.keys, ...b.keys]))
+        continue;
+      src.splice(i, 2, {
+        mdast: a.mdast,
+        start: a.start,
+        end: b.end,
+        keys,
+        node: nodes2.length === 1 ? nodes2[0] : null,
+        nodes: nodes2
+      });
+      merged = true;
+    }
+    return merged;
+  }
+  emitLevel(level, live, src, frame, top) {
+    const liveKeys = live.map((node) => this.keyOf(node));
+    src.forEach((child, index) => this.fillKeys(level, child, index === 0));
+    let matches = alignChildren(src, liveKeys);
+    if (!matches)
+      return null;
+    if (this.coalesce(level, src, matches)) {
+      matches = alignChildren(src, liveKeys);
+      if (!matches)
+        return null;
+    }
+    rejectUnequalMatches(src, live, matches);
+    const writer = new LevelWriter(this.source, src, frame);
+    const pending = [];
+    let liveIndex = 0;
+    const flushZeroKeys = (upTo) => {
+      var _a;
+      for (let p = 0; p < upTo; p++) {
+        const index = pending[p];
+        if (((_a = src[index].keys) === null || _a === void 0 ? void 0 : _a.length) === 0)
+          writer.verbatim(index);
+      }
+    };
+    const emitLive = (node) => {
+      var _a;
+      const type2 = node.type.name;
+      const pairAt = pending.findIndex((index2) => {
+        var _a2;
+        const child = src[index2];
+        return child.keys !== null && child.keys.length > 0 && ((_a2 = child.node) === null || _a2 === void 0 ? void 0 : _a2.type.name) === type2;
+      });
+      if (pairAt === -1) {
+        writer.canonical(this.renderCanonical(node, liveIndex, frame), type2);
+        return;
+      }
+      flushZeroKeys(pairAt);
+      const index = pending[pairAt];
+      pending.splice(0, pairAt + 1);
+      const localized = (_a = this.tryRecurse(level, node, src[index], frame)) !== null && _a !== void 0 ? _a : this.tryPatchParagraph(level, node, src[index], index === 0);
+      if (localized !== null)
+        writer.recursed(index, localized, type2);
+      else
+        writer.canonical(this.renderCanonical(node, liveIndex, frame), type2);
+    };
+    const flushLive = (to) => {
+      while (liveIndex < to) {
+        emitLive(live[liveIndex]);
+        liveIndex++;
+      }
+    };
+    const flushPending = () => {
+      flushZeroKeys(pending.length);
+      pending.length = 0;
+    };
+    if (top && !top.omitted && !top.hasYaml)
+      writer.raw(top.canonical);
+    for (let i = 0; i < src.length; i++) {
+      const child = src[i];
+      if (child.mdast.type === "yaml") {
+        if (!top)
+          return null;
+        const appended = top.appended === null ? null : verifiedYamlAppend(this.source.slice(child.start, child.end), top.appended, top.record);
+        if (top.unchanged)
+          writer.verbatim(i);
+        else if (appended !== null)
+          writer.recursed(i, appended, "yaml");
+        else if (!top.omitted)
+          writer.raw(top.canonical);
+        continue;
+      }
+      const match = matches[i];
+      if (match !== null && match !== void 0) {
+        flushLive(match);
+        flushPending();
+        liveIndex = match + child.keys.length;
+        writer.verbatim(i);
+        continue;
+      }
+      pending.push(i);
+    }
+    flushLive(live.length);
+    flushPending();
+    return writer.finish();
+  }
+  tryRecurse(level, live, child, frame) {
+    var _a;
+    const base = child.node;
+    if (!base || base.type.name !== live.type.name)
+      return null;
+    const type2 = live.type.name;
+    if (type2 === "table")
+      return this.emitTable(live, child);
+    if (!JSX_CONTAINER_TYPES.has(type2) && !LIST_TYPES.has(type2) && type2 !== "listItem")
+      return null;
+    if (type2 === BLOCK_TYPES.customComponent && live.attrs.name === "CodeBlock")
+      return null;
+    const kind = LIST_TYPES.has(type2) ? "list" : type2 === "listItem" ? "item" : "jsx";
+    const element = kind === "jsx" ? this.resolveElement(child) : child;
+    if (!element)
+      return null;
+    const mdastKids = element.mdast.children;
+    if (!mdastKids || mdastKids.length === 0)
+      return null;
+    const srcKids = this.buildSrcChildren(mdastKids);
+    if (!srcKids)
+      return null;
+    const first = srcKids[0];
+    const last = srcKids[srcKids.length - 1];
+    if (first.start < element.start || last.end > element.end)
+      return null;
+    let open = this.source.slice(element.start, first.start);
+    const close = this.source.slice(last.end, element.end);
+    if (this.shellKey(base) === this.shellKey(live)) {
+      if (!sameNode(this.hollow(base), this.hollow(live)))
+        return null;
+    } else {
+      if (kind !== "jsx")
+        return null;
+      const tagLine = blockKey(this.hollow(live), this.ser).split("\n")[0];
+      const firstLine = open.split("\n")[0];
+      if (!tagLine.endsWith(">") || !/>[ \t]*$/.test(firstLine) || firstLine.slice(1).includes("<")) {
+        return null;
+      }
+      open = tagLine + open.slice(firstLine.trimEnd().length);
+    }
+    const prefix = this.linePrefix(first.start);
+    const containerLine = this.linePrefix(element.start);
+    const list = kind === "list" ? this.listMarker(live, srcKids) : null;
+    if (kind === "list" && !list)
+      return null;
+    const containerIndent = /^[ \t]*$/.test(containerLine) ? containerLine : frame.indent;
+    const continuation = kind === "item" ? this.continuationIndent([element]) : null;
+    const childFrame = {
+      kind,
+      open,
+      close,
+      indent: continuation !== null && continuation !== void 0 ? continuation : kind === "jsx" && !/^[ \t]*$/.test(prefix) ? containerIndent + " ".repeat((_a = this.ser.indentSize) !== null && _a !== void 0 ? _a : 2) : prefix.replace(/\S/g, " "),
+      containerIndent,
+      sepBody: this.separatorBody(srcKids, kind),
+      list
+    };
+    const childLevel = {
+      outerOpen: level.outerOpen + level.innerOpen,
+      innerOpen: open,
+      close: close + level.close,
+      chain: [...level.chain, type2]
+    };
+    return this.emitLevel(childLevel, contentChildren(live), srcKids, childFrame, null);
+  }
+  tryPatchParagraph(level, live, child, first) {
+    const base = child.node;
+    if (!base || live.type.name !== "paragraph" || base.type.name !== "paragraph")
+      return null;
+    if (child.mdast.type !== "paragraph" || base.childCount !== live.childCount)
+      return null;
+    let changed = -1;
+    for (let i = 0; i < live.childCount; i++) {
+      const before2 = base.child(i);
+      const after2 = live.child(i);
+      if (before2.eq(after2))
+        continue;
+      if (changed !== -1 || !before2.isText || !after2.isText || !before2.sameMarkup(after2)) {
+        return null;
+      }
+      changed = i;
+    }
+    if (changed === -1)
+      return null;
+    const liveText = live.child(changed);
+    if (liveText.marks.some((mark) => mark.type.name === "code" || mark.type.name === "link")) {
+      return null;
+    }
+    const leaves = inlineLeaves(child.mdast.children);
+    const leaf = leaves[changed];
+    if (leaves.length !== base.childCount || (leaf === null || leaf === void 0 ? void 0 : leaf.type) !== "text")
+      return null;
+    const span = this.coords.span(leaf);
+    if (!span || span.start < child.start || span.end > child.end)
+      return null;
+    const before = base.child(changed).text;
+    const after = liveText.text;
+    const offsets = mapTextToSource(this.source, span.start, span.end, before);
+    if (!offsets)
+      return null;
+    let prefix = 0;
+    while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) {
+      prefix++;
+    }
+    let suffix = 0;
+    while (suffix < before.length - prefix && suffix < after.length - prefix && before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) {
+      suffix++;
+    }
+    const segment = new SerializerState(this.ser).escRange(after, prefix, after.length - suffix);
+    const patched = this.source.slice(child.start, offsets[prefix]) + segment + this.source.slice(offsets[before.length - suffix], child.end);
+    const nodes2 = this.parseText(level, patched, child.start, first);
+    if (!nodes2 || nodes2.length !== 1 || !sameNode(nodes2[0], live))
+      return null;
+    return patched;
+  }
+  resolveElement(child) {
+    if (child.mdast.type === "mdxJsxFlowElement" || child.mdast.type === "mdxJsxTextElement") {
+      return child;
+    }
+    if (child.mdast.type !== "paragraph")
+      return null;
+    const inline = child.mdast.children.filter((node) => !(node.type === "text" && node.value.trim() === ""));
+    const element = inline[0];
+    if (inline.length !== 1 || (element === null || element === void 0 ? void 0 : element.type) !== "mdxJsxTextElement")
+      return null;
+    const span = this.coords.span(element);
+    if (!span)
+      return null;
+    return Object.assign(Object.assign({ mdast: element }, span), { keys: child.keys, node: child.node, nodes: child.nodes });
+  }
+  separatorBody(srcKids, kind) {
+    var _a, _b;
+    if (srcKids.length >= 2) {
+      const between = this.source.slice(srcKids[0].end, srcKids[1].start);
+      const newlines = (_b = (_a = between.match(/\n/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+      if (newlines >= 1)
+        return newlines >= 2 ? "\n\n" : "\n";
+    }
+    return kind === "list" || kind === "item" ? "\n" : "\n\n";
+  }
+  listMarker(live, items) {
+    const ordered = live.type.name === "orderedList";
+    const numbers = [];
+    let delimiter = ordered ? "." : "-";
+    for (const item of items) {
+      const match = LIST_MARKER.exec(this.source.slice(item.start, item.start + 12));
+      if (!match)
+        continue;
+      if (ordered !== (match[2] !== void 0))
+        return null;
+      delimiter = ordered ? match[3] : match[1];
+      if (ordered)
+        numbers.push(Number(match[2]));
+    }
+    const fixedNumber = ordered && numbers.length >= 2 && numbers.every((n) => n === numbers[0]) ? numbers[0] : null;
+    return {
+      ordered,
+      start: live.attrs.start || 1,
+      delimiter,
+      fixedNumber,
+      contentIndent: this.continuationIndent(items)
+    };
+  }
+  continuationIndent(items) {
+    for (const item of items) {
+      const kids = item.mdast.children;
+      if (!kids || kids.length < 2)
+        continue;
+      const span = this.coords.span(kids[1]);
+      if (!span || this.coords.lineStart(span.start) <= item.start)
+        continue;
+      const prefix = this.linePrefix(span.start);
+      if (/^[ \t]*$/.test(prefix))
+        return prefix;
+    }
+    return null;
+  }
+  renderCanonical(node, liveIndex, frame) {
+    var _a;
+    if (!frame.list)
+      return serializeNodeWithDelim(node, this.ser, frame.indent);
+    const { list } = frame;
+    const number = (_a = list.fixedNumber) !== null && _a !== void 0 ? _a : list.start + liveIndex;
+    const checked = node.attrs.checked;
+    const task = checked == null ? "" : checked ? "[x] " : "[ ] ";
+    const prefix = (list.ordered ? `${number}${list.delimiter} ` : `${list.delimiter} `) + task;
+    const fallbackIndent = frame.indent + " ".repeat(prefix.length);
+    const delim = list.contentIndent && list.contentIndent.length >= fallbackIndent.length ? list.contentIndent : fallbackIndent;
+    const body = serializeNodeWithDelim(node, this.ser, delim);
+    return prefix + body;
+  }
+  emitTable(live, child) {
+    var _a;
+    const base = child.node;
+    const rows = child.mdast.children;
+    if (!rows || rows.length === 0 || rows.length !== base.childCount || live.childCount === 0) {
+      return null;
+    }
+    const srcRows = this.buildSrcChildren(rows);
+    if (!srcRows)
+      return null;
+    const columns = base.child(0).childCount;
+    for (let i = 0; i < live.childCount; i++) {
+      if (live.child(i).childCount !== columns)
+        return null;
+    }
+    const rowKey = (row) => this.keyOf(live.type.create(null, [row]));
+    srcRows.forEach((row, i) => {
+      row.keys = [rowKey(base.child(i))];
+    });
+    const liveRows = docChildren(live);
+    const liveKeys = liveRows.map(rowKey);
+    const matches = alignChildren(srcRows, liveKeys);
+    if (!matches || matches[0] !== 0 && matches[0] !== null)
+      return null;
+    matches.forEach((liveAt, srcAt) => {
+      if (liveAt !== null && !sameNode(base.child(srcAt), liveRows[liveAt]))
+        matches[srcAt] = null;
+    });
+    const liveToSrc = /* @__PURE__ */ new Map();
+    matches.forEach((liveAt, srcAt) => {
+      if (liveAt !== null)
+        liveToSrc.set(liveAt, srcAt);
+    });
+    if (matches[0] === null && liveToSrc.has(0))
+      return null;
+    const header = srcRows[0];
+    const indent = this.linePrefix(header.start).replace(/\S/g, " ");
+    const afterHeader = this.source.slice(header.end, srcRows.length >= 2 ? srcRows[1].start : child.end);
+    const delimiter = (_a = /^\n[^\n]*/.exec(afterHeader)) === null || _a === void 0 ? void 0 : _a[0];
+    if (!delimiter)
+      return null;
+    const afterDelimiter = header.end + delimiter.length;
+    let out = this.source.slice(child.start, header.start);
+    if (matches[0] === 0) {
+      out += this.source.slice(header.start, header.end) + delimiter;
+    } else {
+      const canonicalHeader = blockKey(live.type.create(null, [liveRows[0]]), this.ser);
+      out += canonicalHeader.split("\n").slice(0, 2).join(`
+${indent}`);
+    }
+    let prevSrc = null;
+    for (let k = 1; k < liveRows.length; k++) {
+      const srcAt = liveToSrc.get(k);
+      if (srcAt !== void 0 && k === 1 && srcAt === 1) {
+        out += this.source.slice(afterDelimiter, srcRows[1].start);
+      } else if (srcAt !== void 0 && prevSrc !== null && srcAt === prevSrc + 1) {
+        out += this.source.slice(srcRows[prevSrc].end, srcRows[srcAt].start);
+      } else {
+        out += `
+${indent}`;
+      }
+      if (srcAt !== void 0) {
+        out += this.source.slice(srcRows[srcAt].start, srcRows[srcAt].end);
+        prevSrc = srcAt;
+      } else {
+        out += blockKey(live.type.create(null, [liveRows[k]]), this.ser).split("\n")[0];
+        prevSrc = null;
+      }
+    }
+    if (srcRows.length >= 2 && prevSrc === srcRows.length - 1) {
+      out += this.source.slice(srcRows[prevSrc].end, child.end);
+    }
+    return out;
+  }
+  shellKey(node) {
+    const type2 = node.type.name;
+    const attrs2 = LIST_TYPES.has(type2) || type2 === "listItem" ? JSON.stringify(node.attrs) : "";
+    return `${type2}|${attrs2}|${blockKey(this.hollow(node), this.ser)}`;
+  }
+  hollow(node) {
+    const type2 = node.type.name;
+    if (TITLED_TYPES.has(type2) && node.childCount >= 2) {
+      return node.copy(Fragment.from([node.child(0), node.child(1).copy(Fragment.from(this.emptyParagraph))]));
+    }
+    if (LIST_TYPES.has(type2)) {
+      const item = this.schema.nodes.listItem.create(null, this.emptyParagraph);
+      return node.copy(Fragment.from(item));
+    }
+    return node.copy(Fragment.from(this.emptyParagraph));
+  }
+};
+function docChildren(node) {
+  const children = [];
+  node.forEach((child) => children.push(child));
+  return children;
+}
+function contentChildren(node) {
+  if (TITLED_TYPES.has(node.type.name)) {
+    return node.childCount >= 2 ? docChildren(node.child(1)) : [];
+  }
+  return docChildren(node);
+}
+function sameKeys(a, b) {
+  return a.length === b.length && a.every((key, i) => key === b[i]);
+}
+function frontmatterLines(record) {
+  return new Map(Object.entries(filterFrontmatterRecord(record)).map(([key, value]) => [
+    key,
+    formatFrontmatterValue(key, value)
+  ]));
+}
+function frontmatterDelta(original, next) {
+  const before = frontmatterLines(original);
+  const after = frontmatterLines(next);
+  for (const [key, line] of before) {
+    if (after.get(key) !== line)
+      return { kind: "rewrite" };
+  }
+  const added = [...after].filter(([key]) => !before.has(key)).map(([, line]) => line);
+  return added.length === 0 ? { kind: "same" } : { kind: "append", lines: added.join("\n") };
+}
+function appendYamlLines(yaml2, lines) {
+  const fence = /(\r?\n)---[ \t]*$/.exec(yaml2);
+  if (!fence)
+    return null;
+  const newline = fence[1];
+  return `${yaml2.slice(0, fence.index)}${newline}${lines.replace(/\n/g, newline)}${yaml2.slice(fence.index)}`;
+}
+function verifiedYamlAppend(yaml2, lines, record) {
+  var _a;
+  const appended = appendYamlLines(yaml2, lines);
+  if (appended === null || record === void 0)
+    return null;
+  const body = (_a = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*$/.exec(appended)) === null || _a === void 0 ? void 0 : _a[1];
+  if (body === void 0)
+    return null;
+  let parsed;
+  try {
+    parsed = parseYaml2(body);
+  } catch (_b) {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return null;
+  const before = frontmatterLines(parsed);
+  const after = frontmatterLines(record);
+  if (before.size !== after.size)
+    return null;
+  for (const [key, line] of after) {
+    if (before.get(key) !== line)
+      return null;
+  }
+  return appended;
+}
+function rejectUnequalMatches(src, live, matches) {
+  matches.forEach((at, i) => {
+    if (at === null)
+      return;
+    const nodes2 = src[i].nodes;
+    if (!nodes2 || nodes2.some((node, k) => !sameNode(node, live[at + k])))
+      matches[i] = null;
+  });
+}
+function sameNode(a, b) {
+  return a.eq(b) || deepEqual(a.toJSON(), b.toJSON());
+}
+function promotedElements(mdast) {
+  if (mdast.type !== "paragraph")
+    return [mdast];
+  const elements = mdast.children.filter((node) => !(node.type === "text" && node.value.trim() === ""));
+  const promotable = elements.length > 0 && elements.every((node) => node.type === "mdxJsxTextElement" && isBlockName(node.name));
+  return promotable ? elements : [mdast];
+}
+var MARK_CONTAINERS = /* @__PURE__ */ new Set(["emphasis", "strong", "delete", "link"]);
+var MARK_ELEMENTS = /* @__PURE__ */ new Set(["u", "sub", "sup"]);
+function inlineLeaves(nodes2) {
+  const leaves = [];
+  for (const node of nodes2) {
+    if (MARK_CONTAINERS.has(node.type) && "children" in node) {
+      leaves.push(...inlineLeaves(node.children));
+    } else if (node.type === "mdxJsxTextElement" && node.name !== null && MARK_ELEMENTS.has(node.name)) {
+      leaves.push(...inlineLeaves(node.children));
+    } else {
+      leaves.push(node);
+    }
+  }
+  return leaves;
+}
+var ASCII_PUNCTUATION = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
+function mapTextToSource(source, start, end, text) {
+  const offsets = [];
+  let i = start;
+  for (let j = 0; j < text.length; j++) {
+    offsets.push(i);
+    if (i >= end)
+      return null;
+    const run = /^[ \t]*\n[ \t\n]*/.exec(source.slice(i, end));
+    if (run) {
+      if (text[j] !== " ")
+        return null;
+      i += run[0].length;
+      continue;
+    }
+    if (source[i] === "\\" && i + 1 < end && ASCII_PUNCTUATION.test(source[i + 1]))
+      i++;
+    if (source[i] !== text[j])
+      return null;
+    i++;
+  }
+  offsets.push(i);
+  return /^[ \t]*$/.test(source.slice(i, end)) ? offsets : null;
+}
+function blockKey(node, serializerOptions) {
+  try {
+    const wrapped = node.type.schema.topNodeType.create(null, [node]);
+    return pmToMdx(wrapped, Object.assign(Object.assign({}, serializerOptions), { removeTrailingNewline: true }));
+  } catch (_a) {
+    return JSON.stringify(node.toJSON());
+  }
+}
+function computeLineStarts(source) {
+  const starts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\n")
+      starts.push(i + 1);
+  }
+  return starts;
+}
+function buildLineMap(sanitized, preprocessed) {
+  var _a, _b;
+  const from = sanitized.split("\n");
+  const to = preprocessed.split("\n");
+  const map2 = [];
+  let i = 0;
+  for (let j = 0; j < to.length; ) {
+    if (to[j] === from[i]) {
+      map2.push(i);
+      i++;
+      j++;
+      continue;
+    }
+    if (JSX_HEADING_OPEN.test((_a = to[j]) !== null && _a !== void 0 ? _a : "") && JSX_HEADING_CLOSE.test((_b = to[j + 2]) !== null && _b !== void 0 ? _b : "")) {
+      map2.push(i, i, i);
+      i++;
+      j += 3;
+      continue;
+    }
+    return null;
+  }
+  return i === from.length ? map2 : null;
+}
+function alignChildren(children, liveKeys) {
+  const candidates = [];
+  children.forEach((child, index) => {
+    if (child.keys && child.keys.length > 0)
+      candidates.push(index);
+  });
+  const n = candidates.length;
+  const m = liveKeys.length;
+  if ((n + 1) * (m + 1) > MAX_ALIGNMENT_CELLS)
+    return null;
+  const matchesAt = (keys, at) => {
+    if (at + keys.length > m)
+      return false;
+    for (let k = 0; k < keys.length; k++) {
+      if (liveKeys[at + k] !== keys[k])
+        return false;
+    }
+    return true;
+  };
+  const dp = Array.from({ length: n + 1 }, () => new Int32Array(m + 1));
+  for (let b2 = n - 1; b2 >= 0; b2--) {
+    const keys = children[candidates[b2]].keys;
+    const row = dp[b2];
+    const next = dp[b2 + 1];
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      let best = Math.max(next[j2], row[j2 + 1]);
+      if (matchesAt(keys, j2)) {
+        best = Math.max(best, keys.length + next[j2 + keys.length]);
+      }
+      row[j2] = best;
+    }
+  }
+  const result = children.map(() => null);
+  let b = 0;
+  let j = 0;
+  while (b < n && j < m) {
+    const keys = children[candidates[b]].keys;
+    if (matchesAt(keys, j) && dp[b][j] === keys.length + dp[b + 1][j + keys.length]) {
+      result[candidates[b]] = j;
+      b++;
+      j += keys.length;
+    } else if (dp[b][j] === dp[b + 1][j]) {
+      b++;
+    } else {
+      j++;
+    }
+  }
+  return result;
+}
+
+// ../editor/dist/converter/serialize/pm-to-mdast.js
+function pmJsonToMdast(_doc, _frontmatter) {
+  throw new Error("pmJsonToMdast is not yet implemented \u2014 use pmToMdx instead for direct MDX output");
+}
+
+// ../editor/dist/converter/serialize/mdast-to-mdx.js
+import remarkGfm3 from "remark-gfm";
+import remarkMath2 from "remark-math";
+import remarkMdx3 from "remark-mdx";
+import remarkStringify2 from "remark-stringify";
+import { unified as unified2 } from "unified";
+function mdastToMdx(mdast) {
+  const result = unified2().use(remarkMdx3).use(remarkGfm3).use(remarkMath2).use(remarkStringify2).stringify(mdast);
+  return typeof result === "string" ? result : String(result);
+}
+
 // ../editor/dist/converter/diff/diff-docs.js
 var diffDocs = (oldDoc, newDoc, schema2) => {
   var _a, _b;
@@ -12596,6 +13537,7 @@ export {
   parseMetaString,
   pmJsonToMdast,
   pmToMdx,
+  pmToMdxPreservingSource,
   safeJsonParse,
   sanitizeDomAttrs,
   serializePropValue,