@mintlify/common 1.0.1114 → 1.0.1116

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/rehype/rehypeDynamicTailwindCss.js

@@ -1,22 +1,21 @@
 import { walk } from 'estree-walker';
 import { visit } from 'unist-util-visit';
+import { segment } from './segment.js';
 export const MINTLIFY_TAILWIND_PREFIX = 'mint-';
 export const rehypeDynamicTailwindCss = (tailwindSelectors) => (tree) => {
+    const normalizedTailwindSelectors = tailwindSelectors === null || tailwindSelectors === void 0 ? void 0 : tailwindSelectors.map(normalizeSelector);
     visit(tree, (node) => {
         if ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') &&
             node.name &&
             typeof node.name === 'string' &&
-            // check for valid html tags
-            (/^[a-z]/.test(node.name) || node.name === 'Heading') &&
-            !node.name.includes('.') &&
             node.attributes.length > 0) {
             const className = node.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'className');
             if (className && typeof className.value === 'string') {
-                className.value = transformClassNames(className.value, tailwindSelectors);
+                className.value = transformClassNames(className.value, normalizedTailwindSelectors);
             }
         }
         if (node.type === 'mdxjsEsm' && node.data && node.data.estree) {
-            transformMdxJsEsmNode(node.data.estree, tailwindSelectors);
+            transformMdxJsEsmNode(node.data.estree, normalizedTailwindSelectors);
         }
     });
 };
@@ -93,31 +92,31 @@ const transformExpressionClassNames = (expr, tailwindSelectors) => {
 const transformClassNames = (value, tailwindSelectors) => {
     if (!tailwindSelectors || !tailwindSelectors.length)
         return value;
-    return value
-        .split(/\s+/)
-        .map((className) => {
-        if (!className)
-            return '';
-        if (className.startsWith('[') || className.startsWith(MINTLIFY_TAILWIND_PREFIX)) {
-            return className;
-        }
-        const parts = className.split(':');
-        let baseClass = parts.pop();
-        const hasImportantModifier = baseClass.startsWith('!');
-        if (hasImportantModifier) {
-            baseClass = baseClass.slice(1);
-        }
-        const variants = parts;
-        if (tailwindSelectors.some((selector) => {
-            // remove the leading dot and any escaping backslashes from the selector
-            // for example, .bg-orange-400\\/50 -> bg-orange-400/50
-            const normalizedSelector = selector.replace(/^\.|\\+/g, '');
-            return normalizedSelector.includes(baseClass);
-        })) {
-            const transformedClass = `${hasImportantModifier ? '!' : ''}${MINTLIFY_TAILWIND_PREFIX}${baseClass}`;
-            return [...variants, transformedClass].join(':');
-        }
-        return className;
-    })
+    return splitClassNames(value)
+        .map((className) => transformClassName(className, tailwindSelectors))
         .join(' ');
 };
+const transformClassName = (className, tailwindSelectors) => {
+    const classSegments = splitClassSegments(className);
+    const baseClassSegment = classSegments[classSegments.length - 1];
+    if (!baseClassSegment)
+        return className;
+    const hasImportantModifier = baseClassSegment.startsWith('!');
+    const baseClass = hasImportantModifier ? baseClassSegment.slice(1) : baseClassSegment;
+    if (!baseClass || baseClass.startsWith(MINTLIFY_TAILWIND_PREFIX)) {
+        return className;
+    }
+    if (!isTailwindClass(className, tailwindSelectors)) {
+        return className;
+    }
+    classSegments[classSegments.length - 1] =
+        `${hasImportantModifier ? '!' : ''}${MINTLIFY_TAILWIND_PREFIX}${baseClass}`;
+    return classSegments.join(':');
+};
+const isTailwindClass = (className, tailwindSelectors) => {
+    const normalizedClassName = normalizeSelector(className);
+    return tailwindSelectors.some((selector) => selector.includes(`.${normalizedClassName}`));
+};
+const splitClassNames = (value) => value.split(/\s+/).filter(Boolean);
+const splitClassSegments = (value) => segment(value, ':').filter(Boolean);
+const normalizeSelector = (selector) => selector.replace(/\\+/g, '');

package/dist/mdx/plugins/rehype/segment.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This splits a string on a top-level character.
+ *
+ * Regex doesn't support recursion (at least not the JS-flavored version),
+ * so we have to use a tiny state machine to keep track of paren placement.
+ *
+ * Expected behavior using commas:
+ * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
+ *        ┬              ┬  ┬    ┬
+ *        x              x  x    ╰──────── Split because top-level
+ *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
+ */
+export declare function segment(input: string, separator: string): string[];

package/dist/mdx/plugins/rehype/segment.js

@@ -0,0 +1,94 @@
+// Vendored from Tailwind CSS v4 (MIT), unchanged apart from formatting:
+// https://github.com/tailwindlabs/tailwindcss/blob/main/packages/tailwindcss/src/utils/segment.ts
+const BACKSLASH = 0x5c;
+const OPEN_CURLY = 0x7b;
+const CLOSE_CURLY = 0x7d;
+const OPEN_PAREN = 0x28;
+const CLOSE_PAREN = 0x29;
+const OPEN_BRACKET = 0x5b;
+const CLOSE_BRACKET = 0x5d;
+const DOUBLE_QUOTE = 0x22;
+const SINGLE_QUOTE = 0x27;
+// This is a shared buffer that is used to keep track of the current nesting level
+// of parens, brackets, and braces. It is used to determine if a character is at
+// the top-level of a string. This is a performance optimization to avoid memory
+// allocations on every call to `segment`.
+const closingBracketStack = new Uint8Array(256);
+/**
+ * This splits a string on a top-level character.
+ *
+ * Regex doesn't support recursion (at least not the JS-flavored version),
+ * so we have to use a tiny state machine to keep track of paren placement.
+ *
+ * Expected behavior using commas:
+ * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
+ *        ┬              ┬  ┬    ┬
+ *        x              x  x    ╰──────── Split because top-level
+ *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
+ */
+export function segment(input, separator) {
+    // SAFETY: We can use an index into a shared buffer because this function is
+    // synchronous, non-recursive, and runs in a single-threaded environment.
+    let stackPos = 0;
+    const parts = [];
+    let lastPos = 0;
+    const len = input.length;
+    const separatorCode = separator.charCodeAt(0);
+    for (let idx = 0; idx < len; idx++) {
+        const char = input.charCodeAt(idx);
+        if (stackPos === 0 && char === separatorCode) {
+            parts.push(input.slice(lastPos, idx));
+            lastPos = idx + 1;
+            continue;
+        }
+        switch (char) {
+            case BACKSLASH:
+                // The next character is escaped, so we skip it.
+                idx += 1;
+                break;
+            // Strings should be handled as-is until the end of the string. No need to
+            // worry about balancing parens, brackets, or curlies inside a string.
+            case SINGLE_QUOTE:
+            case DOUBLE_QUOTE:
+                // Ensure we don't go out of bounds.
+                while (++idx < len) {
+                    const nextChar = input.charCodeAt(idx);
+                    // The next character is escaped, so we skip it.
+                    if (nextChar === BACKSLASH) {
+                        idx += 1;
+                        continue;
+                    }
+                    if (nextChar === char) {
+                        break;
+                    }
+                }
+                break;
+            case OPEN_PAREN:
+                closingBracketStack[stackPos] = CLOSE_PAREN;
+                stackPos++;
+                break;
+            case OPEN_BRACKET:
+                closingBracketStack[stackPos] = CLOSE_BRACKET;
+                stackPos++;
+                break;
+            case OPEN_CURLY:
+                closingBracketStack[stackPos] = CLOSE_CURLY;
+                stackPos++;
+                break;
+            case CLOSE_BRACKET:
+            case CLOSE_CURLY:
+            case CLOSE_PAREN:
+                if (stackPos > 0 && char === closingBracketStack[stackPos - 1]) {
+                    // SAFETY: The buffer does not need to be mutated because the stack is
+                    // only ever read from or written to its current position. Its current
+                    // position is only ever incremented after writing to it. Meaning that
+                    // the buffer can be dirty for the next use and still be correct since
+                    // reading/writing always starts at position `0`.
+                    stackPos--;
+                }
+                break;
+        }
+    }
+    parts.push(input.slice(lastPos));
+    return parts;
+}

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/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),
+    });
+}