@mintlify/common 1.0.1204 → 1.0.1205

package/dist/mdx/getMDXOptions.d.ts

@@ -4,6 +4,7 @@ import { DocsConfig } from '@mintlify/validation';
 import type { Root } from 'mdast';
 import type { PluggableList } from 'unified';
 import { MdxExtracts } from '../types/mdx/MdxExtracts.js';
+import { type MdxJsDetection } from './plugins/remark/remarkMdxRemoveJs.js';
 type MDXOptionsData = {
     snippetTreeMap: Record<string, Root>;
     pageMetadata: PageMetaTags;
@@ -12,7 +13,7 @@ type MDXOptionsData = {
     tailwindSelectors?: string[];
     path?: string;
 };
-export declare const getMDXOptions: ({ data, remarkPlugins, earlyRemarkPlugins, rehypePlugins, mdxExtracts, allowedComponents, fragmentPlugins, }: {
+export declare const getMDXOptions: ({ data, remarkPlugins, earlyRemarkPlugins, rehypePlugins, mdxExtracts, allowedComponents, fragmentPlugins, detectJs, }: {
     data: MDXOptionsData;
     remarkPlugins?: PluggableList;
     earlyRemarkPlugins?: PluggableList;
@@ -24,5 +25,6 @@ export declare const getMDXOptions: ({ data, remarkPlugins, earlyRemarkPlugins,
         remarkPlugins: PluggableList;
         rehypePlugins: PluggableList;
     };
+    detectJs?: MdxJsDetection;
 }) => SerializeOptions["mdxOptions"];
 export {};

package/dist/mdx/getMDXOptions.js

@@ -1,5 +1,6 @@
 import { rehypeCodeBlocks, rehypeDynamicTailwindCss, rehypeKeyboardSymbols, rehypeListItemText, rehypeMdxExtractEndpoint, rehypeMdxExtractExamples, rehypeParamFieldIds, rehypeRawComponents, rehypeTable, rehypeUnicodeIds, rehypeZoomImages, remarkExtractChangelogFilters, remarkExtractTableOfContents, remarkFileTree, remarkFrames, remarkComponentIds, remarkMdxInjectSnippets, remarkMdxStyleStringToObject, remarkMdxRemoveUnusedVariables, remarkRemoveImports, remarkMdxExtractPanel, remarkResolveRelativeLinks, remarkVideo, remarkMdxClientComponentBoundaries, remarkExtractMultiView, remarkPrompt, remarkUnwrapInlineJsx, remarkUnwrapJsxHeadings, remarkMapExplicitAnchors, } from './plugins/index.js';
 import { remarkMdxExpandExpressions, } from './plugins/remark/remarkMdxExpandExpressions.js';
+import { remarkMdxDetectJs } from './plugins/remark/remarkMdxRemoveJs.js';
 import { remarkMdxRemoveUnknownJsx } from './plugins/remark/remarkMdxRemoveUnknownJsx/index.js';
 import { remarkMermaid } from './plugins/remark/remarkMermaid.js';
 import { remarkNoCopyLanguage } from './plugins/remark/remarkNoCopyLanguage.js';
@@ -13,7 +14,7 @@ const rehypeExtractors = (mdxExtracts, data) => {
         [rehypeMdxExtractEndpoint, data.pageMetadata, data.config, mdxExtracts],
     ];
 };
-export const getMDXOptions = ({ data, remarkPlugins = [], earlyRemarkPlugins = [], rehypePlugins = [], mdxExtracts, allowedComponents = [], fragmentPlugins, }) => {
+export const getMDXOptions = ({ data, remarkPlugins = [], earlyRemarkPlugins = [], rehypePlugins = [], mdxExtracts, allowedComponents = [], fragmentPlugins, detectJs, }) => {
     // `fragment`: the list is compiling the body of an `<MDX>` inside an expression. Page-level
     // extractors that hoist an element out of the tree (`<Panel>`, `<RequestExample>`,
     // `<ResponseExample>`) are skipped there so the element stays in its branch and renders inline
@@ -55,6 +56,7 @@ export const getMDXOptions = ({ data, remarkPlugins = [], earlyRemarkPlugins = [
             remarkMermaid,
             remarkNoCopyLanguage,
             remarkVideo,
+            ...(fragment || !detectJs ? [] : [[remarkMdxDetectJs, detectJs]]),
             ...remarkPlugins,
             remarkRenderTitleMarkdown,
             remarkMapExplicitAnchors,

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

@@ -8,3 +8,7 @@ export declare function isPureDataExpression(value: unknown, depth?: number): bo
 export declare function isPureDataProgram(estree: Program): boolean;
 export declare function isUnsafeDataAttributeName(name: string): boolean;
 export declare function remarkMdxRemoveJs(): (tree: Root) => void;
+export type MdxJsDetection = {
+    hasJs: boolean;
+};
+export declare function remarkMdxDetectJs(detection: MdxJsDetection): (tree: Root) => void;

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

@@ -570,7 +570,106 @@ function tryResolveAsString(estree, constants) {
     const val = constants.get(expr.name);
     return val !== undefined ? val : null;
 }
+const isMdxExpression = (node) => node.type === 'mdxTextExpression' || node.type === 'mdxFlowExpression';
+// mdx comments ({/* … */}) parse to an expression with an empty estree body.
+// the raw source must also be comment/whitespace-only: empty-body alone is an
+// undocumented parser detail a toolchain bump could silently widen
+// linear scan: a regex over repeated block comments backtracks exponentially
+function isBlockCommentsAndWhitespace(value) {
+    let index = 0;
+    while (index < value.length) {
+        if (/\s/.test(value.charAt(index))) {
+            index++;
+        }
+        else if (value.startsWith('/*', index)) {
+            const end = value.indexOf('*/', index + 2);
+            if (end === -1)
+                return false;
+            index = end + 2;
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+}
+function isCommentOnlyExpression(node) {
+    var _a, _b, _c;
+    const estree = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree;
+    return (estree != null &&
+        estree.body.length === 0 &&
+        ((_b = estree.comments) !== null && _b !== void 0 ? _b : []).every((comment) => comment.type === 'Block' && !comment.value.includes('*/')) &&
+        isBlockCommentsAndWhitespace((_c = node.value) !== null && _c !== void 0 ? _c : ''));
+}
+// prettier emits {" "} to preserve spaces between inline elements. whitespace-only
+// string literals are inert in every render position (unlike arbitrary string
+// literals, which would become executable text inside kept <script> children),
+// so both passes keep them and rendering stays byte-identical by construction
+function isWhitespaceStringExpression(node) {
+    var _a;
+    const estree = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree;
+    if (estree == null || estree.body.length !== 1)
+        return false;
+    const stmt = estree.body[0];
+    if ((stmt === null || stmt === void 0 ? void 0 : stmt.type) !== 'ExpressionStatement')
+        return false;
+    const expr = stmt.expression;
+    return (expr.type === 'Literal' &&
+        typeof expr.value === 'string' &&
+        expr.value.trim() === '' &&
+        typeof expr.raw === 'string' &&
+        /^(["'])(?:\s|\\[nrt])*\1$/.test(expr.raw));
+}
+function isInertExpression(node) {
+    return isCommentOnlyExpression(node) || isWhitespaceStringExpression(node);
+}
+const applyEdits = {
+    replaceChild: (parent, index, node) => {
+        parent.children[index] = node;
+    },
+    remove: (tree, test) => {
+        remove(tree, test);
+    },
+    setAttributes: (node, attributes) => {
+        node.attributes = attributes;
+    },
+    rewriteAttribute: (value, raw, estree) => {
+        value.value = raw;
+        value.data = Object.assign(Object.assign({}, value.data), { estree });
+    },
+    prepend: (tree, node) => {
+        tree.children.unshift(node);
+    },
+};
+const WOULD_CHANGE = new Error('remarkMdxRemoveJs would change the tree');
+const detectEdits = {
+    replaceChild: () => {
+        throw WOULD_CHANGE;
+    },
+    remove: (tree, test) => {
+        visit(tree, (node) => {
+            if (test(node))
+                throw WOULD_CHANGE;
+        });
+    },
+    setAttributes: (node, attributes) => {
+        if (attributes.length !== node.attributes.length ||
+            attributes.some((attr, i) => attr !== node.attributes[i]))
+            throw WOULD_CHANGE;
+    },
+    rewriteAttribute: () => {
+        throw WOULD_CHANGE;
+    },
+    prepend: () => {
+        throw WOULD_CHANGE;
+    },
+};
 export function remarkMdxRemoveJs() {
+    return sanitizer(applyEdits);
+}
+// change the tree only through edit: remarkMdxDetectJs only sees edits, so a direct mutation
+// would skip the no-js compile and serve unsanitized output
+function sanitizer(edit) {
     return (tree) => {
         const constantStrings = collectStringConstants(tree);
         if (constantStrings.size > 0) {
@@ -587,10 +686,10 @@ export function remarkMdxRemoveJs() {
                 const replacement = node.type === 'mdxTextExpression'
                     ? { type: 'text', value: substitution }
                     : { type: 'paragraph', children: [{ type: 'text', value: substitution }] };
-                parent.children[index] = replacement;
+                edit.replaceChild(parent, index, replacement);
             });
         }
-        remove(tree, ['mdxTextExpression', 'mdxFlowExpression']);
+        edit.remove(tree, (node) => isMdxExpression(node) && !isInertExpression(node));
         // Collect exported names before stripping ESM so we can inject stubs.
         // Map keyed by name deduplicates naturally.
         const stubbedNamesMap = new Map();
@@ -603,7 +702,7 @@ export function remarkMdxRemoveJs() {
                 }
             }
         });
-        remove(tree, (node) => isMdxJsEsm(node));
+        edit.remove(tree, (node) => isMdxJsEsm(node));
         // Sanitize JSX attributes. Any bare identifier that survives is added to stubbedNamesMap
         // so it gets a stub even if its import was already stripped by a prior plugin.
         visit(tree, (node) => {
@@ -634,28 +733,42 @@ export function remarkMdxRemoveJs() {
                             const stmt = filteredEstree.body[0];
                             if ((stmt === null || stmt === void 0 ? void 0 : stmt.type) === 'ExpressionStatement' &&
                                 stmt.expression.type === 'ObjectExpression') {
-                                attr.value.value = rebuildStyleValue(stmt.expression.properties);
-                                attr.value.data.estree = filteredEstree;
+                                edit.rewriteAttribute(attr.value, rebuildStyleValue(stmt.expression.properties), filteredEstree);
                                 return attr;
                             }
                         }
                         return undefined;
                     }
                     if (Object.keys(DEFAULT_PROP_EXPRESSIONS).includes(attr.name)) {
-                        attr.value.value = (_f = (_e = DEFAULT_PROP_EXPRESSIONS[attr.name]) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : '{}';
-                        attr.value.data = {
-                            estree: structuredClone((_h = (_g = DEFAULT_PROP_EXPRESSIONS[attr.name]) === null || _g === void 0 ? void 0 : _g.estree) !== null && _h !== void 0 ? _h : objectEstree),
-                        };
+                        edit.rewriteAttribute(attr.value, (_f = (_e = DEFAULT_PROP_EXPRESSIONS[attr.name]) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : '{}', structuredClone((_h = (_g = DEFAULT_PROP_EXPRESSIONS[attr.name]) === null || _g === void 0 ? void 0 : _g.estree) !== null && _h !== void 0 ? _h : objectEstree));
                         return attr;
                     }
                 }
                 return undefined;
             });
-            node.attributes = newAttributes.filter((attr) => attr !== undefined);
+            edit.setAttributes(node, newAttributes.filter((attr) => attr !== undefined));
         });
         // Inject stubs after the attribute walk so identifiers collected from attributes are included
         if (stubbedNamesMap.size > 0) {
-            tree.children.unshift(buildStubEsmNode([...stubbedNamesMap.values()]));
+            edit.prepend(tree, buildStubEsmNode([...stubbedNamesMap.values()]));
+        }
+    };
+}
+// dry-run twin of remarkMdxRemoveJs for the with-js compile pass: reports
+// whether the sanitizer would change this tree, without touching it. a false
+// detection proves the no-js compile would be byte-identical and can be skipped
+export function remarkMdxDetectJs(detection) {
+    const detect = sanitizer(detectEdits);
+    return (tree) => {
+        let hasJs = false;
+        try {
+            detect(tree);
+        }
+        catch (error) {
+            if (error !== WOULD_CHANGE)
+                throw error;
+            hasJs = true;
         }
+        detection.hasJs = hasJs;
     };
 }

package/dist/mdx/server-only/getMdx.d.ts

@@ -13,7 +13,7 @@ export type GetMdxType = {
     panelMdxSourceWithNoJs?: SerializeSuccess;
     parseFailed?: boolean;
 };
-export declare function getMdx({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors, pageType, trace, customLanguages, variables, rehypePlugins, remarkPlugins, earlyRemarkPlugins, allowedComponents, }: {
+export declare function getMdx({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors, pageType, trace, customLanguages, variables, rehypePlugins, remarkPlugins, earlyRemarkPlugins, allowedComponents, singlePass, }: {
     path: string;
     content: string;
     metadata: PageMetaTags;
@@ -30,5 +30,6 @@ export declare function getMdx({ path, content, metadata, snippets, subdomain, c
     remarkPlugins?: PluggableList;
     earlyRemarkPlugins?: PluggableList;
     allowedComponents?: string[];
+    singlePass?: boolean;
 }): Promise<GetMdxType>;
 export { createSnippetTreeMap, type Snippet };

package/dist/mdx/server-only/getMdx.js

@@ -17,7 +17,7 @@ import { replaceVariables } from '../replaceVariables.js';
 import { createSnippetTreeMap } from './getMdx/snippets.js';
 import { getSerializeExtras } from './getSerializeExtras.js';
 export function getMdx(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors = undefined, pageType = 'default', trace = undefined, customLanguages = [], variables = undefined, rehypePlugins = [], remarkPlugins = [], earlyRemarkPlugins = [], allowedComponents = [], }) {
+    return __awaiter(this, arguments, void 0, function* ({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors = undefined, pageType = 'default', trace = undefined, customLanguages = [], variables = undefined, rehypePlugins = [], remarkPlugins = [], earlyRemarkPlugins = [], allowedComponents = [], singlePass = true, }) {
         const traceFn = trace !== null && trace !== void 0 ? trace : ((_name, fn) => fn());
         const processedContent = preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(content, variables)));
         const processedSnippets = snippets.map((snippet) => (Object.assign(Object.assign({}, snippet), { content: preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(snippet.content, variables))) })));
@@ -46,12 +46,16 @@ export function getMdx(_a) {
             plugins = [...plugins, remarkExpandContent, remarkSplitCodeGroup, remarkSplitTabs];
         }
         const syntaxHighlightingOptions = Object.assign(Object.assign({}, codeStylingToThemeOrThemes(codeStyling)), { customLanguages });
+        // detector sits exactly where remarkMdxRemoveJs sits in the no-js pass, so it
+        // sees the identical tree state and applies the identical decisions
+        const jsDetection = { hasJs: true };
         const mdxOptions = getMDXOptions({
             data: mdxOptionsData,
             remarkPlugins: plugins,
             earlyRemarkPlugins,
             rehypePlugins,
             mdxExtracts,
+            detectJs: jsDetection,
             allowedComponents,
             fragmentPlugins: getSerializeExtras(syntaxHighlightingOptions),
         });
@@ -78,6 +82,7 @@ export function getMdx(_a) {
                 path,
                 traceFn,
                 customLanguages,
+                skipNoJs: singlePass ? { detection: jsDetection, mdxExtracts } : undefined,
             });
         }));
         let parseFailed = mainParseFailed;
@@ -117,7 +122,7 @@ export function getMdx(_a) {
     });
 }
 function compileMdx(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ content, scope, mdxOptions, mdxOptionsNoJs, codeStyling, path, traceFn, customLanguages, }) {
+    return __awaiter(this, arguments, void 0, function* ({ content, scope, mdxOptions, mdxOptionsNoJs, codeStyling, path, traceFn, customLanguages, skipNoJs, }) {
         const withJs = yield traceFn('compileMdx.withJs', () => __awaiter(this, void 0, void 0, function* () {
             return getCompiledMdxWithFallback({
                 source: content,
@@ -129,6 +134,22 @@ function compileMdx(_a) {
                 customLanguages,
             });
         }));
+        // the two passes differ only in remarkMdxRemoveJs (detector reported a no-op)
+        // and rehypeMdxExtractExamples splicing (nothing was collected), so the no-js
+        // compile would be byte-identical: reuse the with-js result
+        const examples = skipNoJs === null || skipNoJs === void 0 ? void 0 : skipNoJs.mdxExtracts.codeExamples;
+        const canSkip = skipNoJs !== undefined &&
+            !withJs.parseFailed &&
+            !skipNoJs.detection.hasJs &&
+            !(examples === null || examples === void 0 ? void 0 : examples.request) &&
+            !(examples === null || examples === void 0 ? void 0 : examples.response);
+        if (canSkip) {
+            return {
+                mdxSource: withJs.result,
+                mdxSourceWithNoJs: withJs.result,
+                parseFailed: withJs.parseFailed,
+            };
+        }
         const withoutJs = yield traceFn('compileMdx.withoutJs', () => __awaiter(this, void 0, void 0, function* () {
             return getCompiledMdxWithFallback({
                 source: content,