@mintlify/common 1.0.1115 → 1.0.1117

package/dist/mdx/getMDXOptions.js

@@ -3,6 +3,7 @@ import { remarkMdxExpandExpressions, } from './plugins/remark/remarkMdxExpandExp
 import { remarkMdxRemoveUnknownJsx } from './plugins/remark/remarkMdxRemoveUnknownJsx/index.js';
 import { remarkMermaid } from './plugins/remark/remarkMermaid.js';
 import { remarkNoCopyLanguage } from './plugins/remark/remarkNoCopyLanguage.js';
+import { remarkParseTitleMarkdown, remarkRenderTitleMarkdown, } from './plugins/remark/remarkTitleMarkdown.js';
 // avoid running extractors unnecessarily
 const rehypeExtractors = (mdxExtracts, data) => {
     if (!mdxExtracts)
@@ -30,6 +31,7 @@ export const getMDXOptions = ({ data, remarkPlugins = [], rehypePlugins = [], md
             ],
             remarkMdxStyleStringToObject,
             [remarkResolveRelativeLinks, { path: data.path }],
+            remarkParseTitleMarkdown,
             remarkPrompt,
             [remarkComponentIds, data.pageMetadata],
             remarkUnwrapJsxHeadings,
@@ -46,6 +48,7 @@ export const getMDXOptions = ({ data, remarkPlugins = [], rehypePlugins = [], md
             remarkNoCopyLanguage,
             remarkVideo,
             ...remarkPlugins,
+            remarkRenderTitleMarkdown,
             remarkMapExplicitAnchors,
             [remarkMdxRemoveUnknownJsx, { allowlist: [...allowedComponents, ...knownComponents] }],
             [remarkMdxClientComponentBoundaries, { allowlist: knownComponents }],

package/dist/mdx/lib/remark-utils.d.ts

@@ -1,8 +1,12 @@
 import type { RootContent as HastRootContent } from 'hast';
 import type { RootContent as MdastRootContent } from 'mdast';
 import type { MdxJsxAttribute, MdxJsxAttributeValueExpression } from 'mdast-util-mdx-jsx';
+import type { Data } from 'unist';
 type RootContent = MdastRootContent | HastRootContent;
 export declare const createMdxJsxAttribute: (key: string, value: MdxJsxAttributeValueExpression | string | null | undefined | number | boolean) => MdxJsxAttribute;
+export declare function getTitleMarkdownText(node: {
+    data?: Data;
+}, fallback: string): string;
 export declare function getUnicodeId(title: string): string;
 export declare const getTableOfContentsTitle: (node: RootContent, index?: number, children?: RootContent[]) => string;
 export {};

package/dist/mdx/lib/remark-utils.js

@@ -7,6 +7,13 @@ export const createMdxJsxAttribute = (key, value) => {
         value: value,
     };
 };
+export function getTitleMarkdownText(node, fallback) {
+    const nodeData = node.data;
+    const data = nodeData && 'mintlifyTitleMarkdown' in nodeData ? nodeData.mintlifyTitleMarkdown : undefined;
+    return data && typeof data === 'object' && 'text' in data && typeof data.text === 'string'
+        ? data.text
+        : fallback;
+}
 export function getUnicodeId(title) {
     return encodeURIComponent(title.toLowerCase().trim().replace(/\s+/g, '-'));
 }

package/dist/mdx/plugins/remark/remarkComponentIds.js

@@ -1,8 +1,7 @@
 import defaultSlugify, { slugifyWithCounter } from '@sindresorhus/slugify';
 import { visit } from 'unist-util-visit';
 import { slugify } from '../../../slugify.js';
-import { createMdxJsxAttribute } from '../../lib/remark-utils.js';
-import { getTableOfContentsTitle } from '../../lib/remark-utils.js';
+import { createMdxJsxAttribute, getTableOfContentsTitle, getTitleMarkdownText, } from '../../lib/remark-utils.js';
 export function generateComponentId(title, count) {
     const base = defaultSlugify(title.replace(':', '-'), { decamelize: false });
     return count != null && count > 0 ? `${base}-${count}` : base;
@@ -65,14 +64,15 @@ export const remarkComponentIds = (pageMetadata) => (tree) => {
             else {
                 const title = (_b = node.attributes.find((attr) => 'name' in attr && attr.name === 'title')) === null || _b === void 0 ? void 0 : _b.value;
                 if (title && typeof title === 'string') {
+                    const visibleTitle = getTitleMarkdownText(node, title);
                     // Re-slug (bumping the counter) past any id an explicit prop claimed.
                     // usedTabIds only guards against explicit ids; uniqueness among
                     // title-derived slugs is owned by tabSlugifyFn, which monotonically
                     // advances and never repeats a value, so the slots burned by this
                     // loop don't need to be tracked here.
-                    let slug = slugify(title, tabSlugifyFn);
+                    let slug = slugify(visibleTitle, tabSlugifyFn);
                     while (usedTabIds.has(slug))
-                        slug = slugify(title, tabSlugifyFn);
+                        slug = slugify(visibleTitle, tabSlugifyFn);
                     usedTabIds.add(slug);
                     tabSlugs.set(node, slug);
                 }
@@ -164,7 +164,7 @@ export const remarkComponentIds = (pageMetadata) => (tree) => {
         const hasId = node.attributes.some((attr) => 'name' in attr && attr.name === 'id');
         if (hasId)
             return;
-        const title = titleAttr.value;
+        const title = getTitleMarkdownText(node, titleAttr.value);
         const baseSlug = generateComponentId(title);
         const count = (_a = accordionCounts.get(baseSlug)) !== null && _a !== void 0 ? _a : 0;
         accordionCounts.set(baseSlug, count + 1);

package/dist/mdx/plugins/remark/remarkExtractTableOfContents.js

@@ -1,6 +1,6 @@
 import { visit } from 'unist-util-visit';
 import { safeCleanHeadingId, slugify } from '../../../slugify.js';
-import { createMdxJsxAttribute, getTableOfContentsTitle } from '../../lib/remark-utils.js';
+import { createMdxJsxAttribute, getTableOfContentsTitle, getTitleMarkdownText, } from '../../lib/remark-utils.js';
 import { isMdxJsxFragment } from '../../utils.js';
 import { AVOIDED_PAGE_MODES, HEADING_LEVELS } from './remarkComponentIds.js';
 import { isHiddenFromHumans, isVisibilityElement, resolveVisibilityFor, } from './remarkVisibilityForMarkdown.js';
@@ -95,7 +95,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
             if (node.type === 'mdxJsxFlowElement' && node.name === 'Tab') {
                 const idValue = getStringAttribute(node.attributes, 'id');
                 const titleValue = getStringAttribute(node.attributes, 'title');
-                const tabId = idValue !== null && idValue !== void 0 ? idValue : (titleValue ? slugify(titleValue) : undefined);
+                const tabId = idValue !== null && idValue !== void 0 ? idValue : (titleValue ? slugify(getTitleMarkdownText(node, titleValue)) : undefined);
                 if (tabId) {
                     visit(node, (childNode) => {
                         tabContentMap.set(childNode, tabId);
@@ -123,7 +123,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
             }
         });
         visit(tree, (node) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e, _f;
             if (excludedNodes.has(node))
                 return;
             const currentTabId = tabContentMap.get(node);
@@ -144,14 +144,17 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                     (attr.value == null ||
                         attr.value === 'true' ||
                         (typeof attr.value === 'object' && attr.value.value === 'true')));
+            const stepTitle = node.type === 'mdxJsxFlowElement' && node.name === 'Step'
+                ? getTitleMarkdownText(node, (_c = getStringAttribute(node.attributes, 'title')) !== null && _c !== void 0 ? _c : '')
+                : undefined;
             const isValidStep = node.type === 'mdxJsxFlowElement' &&
                 node.name === 'Step' &&
                 !hasNoAnchor &&
                 ['h2', 'h3'].includes(stepTitleSize !== null && stepTitleSize !== void 0 ? stepTitleSize : '') &&
-                ((_d = (_c = getStringAttribute(node.attributes, 'title')) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : '') !== '';
+                (stepTitle === null || stepTitle === void 0 ? void 0 : stepTitle.trim()) !== '';
             const hasIdAttribute = node.type === 'mdxJsxFlowElement' &&
                 node.attributes.some((attr) => 'name' in attr && attr.name === 'id');
-            const isAvoidedPageMode = AVOIDED_PAGE_MODES.includes((_e = pageMetadata === null || pageMetadata === void 0 ? void 0 : pageMetadata.mode) !== null && _e !== void 0 ? _e : '');
+            const isAvoidedPageMode = AVOIDED_PAGE_MODES.includes((_d = pageMetadata === null || pageMetadata === void 0 ? void 0 : pageMetadata.mode) !== null && _d !== void 0 ? _d : '');
             if (!isValidHeading &&
                 !isValidMdxHeading &&
                 !isTransformedHeading &&
@@ -169,7 +172,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
             }
             else if ('name' in node && node.name === 'Step') {
                 const titleSizeToLevel = { h2: 2, h3: 3, h4: 4 };
-                level = (_f = titleSizeToLevel[stepTitleSize !== null && stepTitleSize !== void 0 ? stepTitleSize : '']) !== null && _f !== void 0 ? _f : 3;
+                level = (_e = titleSizeToLevel[stepTitleSize !== null && stepTitleSize !== void 0 ? stepTitleSize : '']) !== null && _e !== void 0 ? _e : 3;
                 // @ts-expect-error we're assigning to depth despite the node not containing depth in the type
                 node.depth = level;
             }
@@ -182,7 +185,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                     level = levelAttr.value;
                 }
             }
-            else if ('name' in node && ((_g = node.name) === null || _g === void 0 ? void 0 : _g[1])) {
+            else if ('name' in node && ((_f = node.name) === null || _f === void 0 ? void 0 : _f[1])) {
                 const num = Number(node.name[1]);
                 level = !isNaN(num) ? num : undefined;
                 if (level !== undefined) {
@@ -190,13 +193,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                     node.depth = level;
                 }
             }
-            let title;
-            if ('name' in node && node.name === 'Step') {
-                title = (_h = getStringAttribute(node.attributes, 'title')) !== null && _h !== void 0 ? _h : getTableOfContentsTitle(node);
-            }
-            else {
-                title = getTableOfContentsTitle(node);
-            }
+            const title = stepTitle !== null && stepTitle !== void 0 ? stepTitle : getTableOfContentsTitle(node);
             let slug;
             const explicitId = ('name' in node &&
                 (node.name === 'Heading' || node.name === 'Step' || node.name === 'Update')) ||

package/dist/mdx/plugins/remark/remarkTitleMarkdown.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from 'mdast';
+export declare const remarkParseTitleMarkdown: () => (tree: Root) => void;
+export declare const remarkRenderTitleMarkdown: () => (tree: Root) => void;

package/dist/mdx/plugins/remark/remarkTitleMarkdown.js

@@ -0,0 +1,83 @@
+import { Parser } from 'acorn';
+import jsx from 'acorn-jsx';
+import { visit } from 'unist-util-visit';
+import { parseTitleMarkdown, titleMarkdownToText } from '../../titleMarkdown.js';
+const JSXParser = Parser.extend(jsx());
+const TITLE_COMPONENTS = new Set(['Accordion', 'Card', 'Color.Row', 'Step', 'Tab', 'Tile']);
+const TITLE_DATA_KEY = 'mintlifyTitleMarkdown';
+function nodeJsx(node) {
+    if (node.type === 'text')
+        return `{${JSON.stringify(node.value)}}`;
+    if (node.type === 'inlineCode')
+        return `<code>{${JSON.stringify(node.value)}}</code>`;
+    if (!('children' in node))
+        return '';
+    const children = node.children.map(nodeJsx).join('');
+    if (node.type === 'link')
+        return children;
+    const tag = node.type === 'emphasis' ? 'em' : node.type === 'delete' ? 'del' : 'strong';
+    return `<${tag}${tag === 'strong' ? ' className="font-extrabold"' : ''}>${children}</${tag}>`;
+}
+function titleExpression(value) {
+    var _a;
+    const nodes = parseTitleMarkdown(value);
+    if (!nodes.length || (((_a = nodes[0]) === null || _a === void 0 ? void 0 : _a.type) === 'text' && nodes[0].value === value))
+        return;
+    const jsxValue = `<>${nodes.map(nodeJsx).join('')}</>`;
+    const estree = JSXParser.parse(jsxValue, {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+    });
+    return {
+        type: 'mdxJsxAttributeValueExpression',
+        value: jsxValue,
+        data: { estree },
+    };
+}
+function getTitleAttribute(node) {
+    return node.attributes.find((attribute) => attribute.type === 'mdxJsxAttribute' && attribute.name === 'title');
+}
+function getTitleValue(attribute) {
+    var _a, _b, _c;
+    if (typeof attribute.value === 'string')
+        return attribute.value;
+    const statement = (_c = (_b = (_a = attribute.value) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.estree) === null || _c === void 0 ? void 0 : _c.body[0];
+    return (statement === null || statement === void 0 ? void 0 : statement.type) === 'ExpressionStatement' &&
+        statement.expression.type === 'Literal' &&
+        typeof statement.expression.value === 'string'
+        ? statement.expression.value
+        : undefined;
+}
+export const remarkParseTitleMarkdown = () => (tree) => {
+    visit(tree, (node) => {
+        if (node.type !== 'mdxJsxFlowElement' && node.type !== 'mdxJsxTextElement')
+            return;
+        if (!node.name || !TITLE_COMPONENTS.has(node.name))
+            return;
+        const title = getTitleAttribute(node);
+        if (!title)
+            return;
+        const titleValue = getTitleValue(title);
+        if (titleValue === undefined)
+            return;
+        node.data = Object.assign(Object.assign({}, node.data), { [TITLE_DATA_KEY]: {
+                text: titleMarkdownToText(titleValue),
+            } });
+    });
+};
+export const remarkRenderTitleMarkdown = () => (tree) => {
+    visit(tree, (node) => {
+        var _a;
+        if (node.type !== 'mdxJsxFlowElement' && node.type !== 'mdxJsxTextElement')
+            return;
+        if (!node.name || !TITLE_COMPONENTS.has(node.name))
+            return;
+        const title = getTitleAttribute(node);
+        if (!title)
+            return;
+        const titleValue = getTitleValue(title);
+        if (titleValue === undefined)
+            return;
+        title.value = (_a = titleExpression(titleValue)) !== null && _a !== void 0 ? _a : title.value;
+    });
+};

package/dist/mdx/snippets/resolveImport/resolveComponentWithContent.js

@@ -7,6 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { Parser } from 'acorn';
+import acornJsx from 'acorn-jsx';
 import { jsx, toJs } from 'estree-util-to-js';
 import { walk } from 'estree-walker';
 import { visit } from 'unist-util-visit';
@@ -81,13 +83,23 @@ const replaceVariablesWithProps = (node, treeToInject, exportMap, snippetExportM
         return uniqueName;
     };
     /**
-     * Rename every free identifier in an expression's estree to its unique name and
-     * regenerate the expression source from the estree so the two never disagree.
-     * (Replacing the first textual occurrence only — the previous behaviour — corrupted any
-     * expression that referenced the same prop twice, e.g. `a === "x" ? 1 : a === "y" ? 2 : 3`.)
+     * Rename every free identifier in an expression to its unique name.
+     *
+     * The renames are spliced into the expression's own source text by position, so everything
+     * else — parentheses, indentation, an inline `style={{ … }}` object, the markdown inside an
+     * `<MDX>` fragment — stays byte-for-byte as the author wrote it. Regenerating the text from the
+     * estree instead pretty-prints nested objects across several lines at column 0, which turns into
+     * lazy lines inside a list once an `<MDX>` fragment is re-parsed as markdown. The source is
+     * re-parsed with acorn because the mdast estree carries document offsets while `value` has its
+     * per-line indent stripped, so the two no longer line up.
+     *
+     * The estree is renamed in place as well so it never disagrees with the text. Only when the text
+     * cannot be parsed on its own is it regenerated from the estree (the previous behaviour).
+     * Replacing the first textual occurrence only — the behaviour before that — corrupted any
+     * expression that referenced the same prop twice, e.g. `a === "x" ? 1 : a === "y" ? 2 : 3`.
      */
     const renamed = new WeakSet();
-    const scopeIdentifiers = (estree) => {
+    const renameIdentifiers = (estree, edits) => {
         walk(estree, {
             enter(jsNode, parent) {
                 if (jsNode.type !== 'Identifier')
@@ -102,20 +114,29 @@ const replaceVariablesWithProps = (node, treeToInject, exportMap, snippetExportM
                 // `obj.prop` and `{ key: value }` — the property name is not a variable reference
                 if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'MemberExpression' && parent.property === jsNode && !parent.computed)
                     return;
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Property' && parent.shorthand && parent.value === jsNode)
+                    return;
                 if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Property' && parent.key === jsNode && !parent.computed) {
                     if (!parent.shorthand)
                         return;
                     // `{ prop }` → `{ prop: prop_0 }`
+                    const uniqueName = getUniqueName(jsNode.name);
+                    edits === null || edits === void 0 ? void 0 : edits.push(Object.assign(Object.assign({}, positionOf(jsNode)), { text: `${jsNode.name}: ${uniqueName}` }));
                     parent.shorthand = false;
-                    const value = Object.assign(Object.assign({}, jsNode), { name: getUniqueName(jsNode.name) });
+                    const value = Object.assign(Object.assign({}, jsNode), { name: uniqueName });
                     renamed.add(value);
                     parent.value = value;
                     return;
                 }
-                jsNode.name = getUniqueName(jsNode.name);
+                const uniqueName = getUniqueName(jsNode.name);
+                edits === null || edits === void 0 ? void 0 : edits.push(Object.assign(Object.assign({}, positionOf(jsNode)), { text: uniqueName }));
+                jsNode.name = uniqueName;
                 renamed.add(jsNode);
             },
         });
+    };
+    const scopeIdentifiers = (estree) => {
+        renameIdentifiers(estree);
         return generate(estree);
     };
     const scopeSpreadAttribute = (estree) => {
@@ -123,24 +144,39 @@ const replaceVariablesWithProps = (node, treeToInject, exportMap, snippetExportM
         const spread = getSpreadElement(estree);
         return spread ? `...${generate(toProgram(spread.argument))}` : generate(estree);
     };
+    /** `{value}` of an expression or attribute; `...rest` of a spread attribute when `spread`. */
+    const scopeSource = (source, estree, spread = false) => {
+        const text = spread ? `{${source}}` : source;
+        const parsed = parseExpression(text);
+        if (!parsed)
+            return spread ? scopeSpreadAttribute(estree) : scopeIdentifiers(estree);
+        const edits = [];
+        renameIdentifiers(parsed, edits);
+        renameIdentifiers(estree);
+        let result = text;
+        for (const edit of edits.sort((a, b) => b.start - a.start)) {
+            result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+        }
+        return spread ? result.slice(1, -1) : result;
+    };
     visit(treeToInject, (node) => {
         var _a, _b, _c;
         if ((node.type === 'mdxTextExpression' || node.type === 'mdxFlowExpression') &&
             ((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree)) {
-            node.value = scopeIdentifiers(node.data.estree);
+            node.value = scopeSource(node.value, node.data.estree);
             return;
         }
         // props referenced inside JSX attributes of the snippet, e.g. `<Card title={variant === "x" ? "a" : "b"}>`
         if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
             for (const attribute of node.attributes) {
                 if (attribute.type === 'mdxJsxExpressionAttribute' && ((_b = attribute.data) === null || _b === void 0 ? void 0 : _b.estree)) {
-                    attribute.value = scopeSpreadAttribute(attribute.data.estree);
+                    attribute.value = scopeSource(attribute.value, attribute.data.estree, true);
                 }
                 else if (attribute.type === 'mdxJsxAttribute' &&
                     attribute.value &&
                     typeof attribute.value === 'object' &&
                     ((_c = attribute.value.data) === null || _c === void 0 ? void 0 : _c.estree)) {
-                    attribute.value.value = scopeIdentifiers(attribute.value.data.estree);
+                    attribute.value.value = scopeSource(attribute.value.value, attribute.value.data.estree);
                 }
             }
         }
@@ -170,6 +206,30 @@ const replaceVariablesWithProps = (node, treeToInject, exportMap, snippetExportM
     };
 };
 const generate = (estree) => toJs(estree, { handlers: jsx }).value.replace(/;\s*$/, '');
+const JSXParser = Parser.extend(acornJsx());
+/**
+ * Parse `text` as a single expression; undefined when it is not one on its own. `preserveParens`
+ * so `( … )` around the whole expression — common when a snippet wraps a ternary in `{( … )}` —
+ * yields a node spanning the entire text; without it acorn returns the inner expression, whose
+ * `end` stops before the closing `)`, and the text would wrongly be treated as unparseable.
+ */
+const parseExpression = (text) => {
+    try {
+        const expression = JSXParser.parseExpressionAt(text, 0, {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+            preserveParens: true,
+        });
+        return text.slice(expression.end).trim() === '' ? expression : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+const positionOf = (node) => {
+    const { start, end } = node;
+    return { start, end };
+};
 const toProgram = (expression) => ({
     type: 'Program',
     sourceType: 'module',

package/dist/mdx/titleMarkdown.d.ts

@@ -0,0 +1,3 @@
+import type { PhrasingContent } from 'mdast';
+export declare function parseTitleMarkdown(value: string): PhrasingContent[];
+export declare function titleMarkdownToText(value: string): string;

package/dist/mdx/titleMarkdown.js

@@ -0,0 +1,90 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { gfmFromMarkdown } from 'mdast-util-gfm';
+import { gfm } from 'micromark-extension-gfm';
+import { getTableOfContentsTitle } from './lib/remark-utils.js';
+function sourceText(node, source) {
+    var _a, _b;
+    const start = (_a = node.position) === null || _a === void 0 ? void 0 : _a.start.offset;
+    const end = (_b = node.position) === null || _b === void 0 ? void 0 : _b.end.offset;
+    return typeof start === 'number' && typeof end === 'number' ? source.slice(start, end) : '';
+}
+function appendText(nodes, value) {
+    if (!value)
+        return;
+    const previous = nodes.at(-1);
+    if ((previous === null || previous === void 0 ? void 0 : previous.type) === 'text')
+        previous.value += value;
+    else
+        nodes.push({ type: 'text', value });
+}
+function isSupportedLink(node, source) {
+    const raw = sourceText(node, source);
+    const destination = node.url.trim();
+    return (raw.startsWith('[') &&
+        destination.length > 0 &&
+        (/^(?:https?:\/\/|mailto:|tel:|\/|#|\.\.?\/)/i.test(destination) ||
+            destination.includes('/') ||
+            /^[^\s@]+\.[^\s]+$/u.test(destination)));
+}
+function sanitizeNodes(nodes, source) {
+    const sanitized = [];
+    for (const node of nodes) {
+        switch (node.type) {
+            case 'text':
+                appendText(sanitized, node.value.replace(/\n/g, ' '));
+                break;
+            case 'inlineCode':
+                sanitized.push({ type: 'inlineCode', value: node.value });
+                break;
+            case 'strong':
+            case 'emphasis':
+            case 'delete':
+                sanitized.push(Object.assign(Object.assign({}, node), { children: sanitizeNodes(node.children, source) }));
+                break;
+            case 'link':
+                if (isSupportedLink(node, source)) {
+                    sanitized.push(Object.assign(Object.assign({}, node), { children: sanitizeNodes(node.children, source) }));
+                }
+                else {
+                    appendText(sanitized, sourceText(node, source));
+                }
+                break;
+            default:
+                appendText(sanitized, sourceText(node, source));
+        }
+    }
+    return sanitized;
+}
+export function parseTitleMarkdown(value) {
+    if (!value)
+        return [];
+    try {
+        const prefix = 'title: ';
+        const source = `${prefix}${value.replace(/\n/g, ' ')}`;
+        const root = fromMarkdown(source, {
+            extensions: [gfm()],
+            mdastExtensions: [gfmFromMarkdown()],
+        });
+        const paragraph = root.children.length === 1 ? root.children[0] : undefined;
+        if ((paragraph === null || paragraph === void 0 ? void 0 : paragraph.type) !== 'paragraph')
+            return [{ type: 'text', value }];
+        const nodes = sanitizeNodes(paragraph.children, source);
+        const first = nodes[0];
+        if ((first === null || first === void 0 ? void 0 : first.type) !== 'text' || !first.value.startsWith(prefix)) {
+            return [{ type: 'text', value }];
+        }
+        first.value = first.value.slice(prefix.length);
+        if (!first.value)
+            nodes.shift();
+        return nodes;
+    }
+    catch (_a) {
+        return [{ type: 'text', value }];
+    }
+}
+export function titleMarkdownToText(value) {
+    return getTableOfContentsTitle({
+        type: 'paragraph',
+        children: parseTitleMarkdown(value),
+    });
+}