@mintlify/common 1.0.1228 → 1.0.1230

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

@@ -33,3 +33,4 @@ export * from './remarkUnwrapJsxHeadings.js';
 export { TITLE_COMPONENTS } from './remarkTitleMarkdown.js';
 export * from './remarkUserMentions.js';
 export * from './remarkVisibilityForMarkdown.js';
+export * from './pureTemplateComponents.js';

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

@@ -33,3 +33,4 @@ export * from './remarkUnwrapJsxHeadings.js';
 export { TITLE_COMPONENTS } from './remarkTitleMarkdown.js';
 export * from './remarkUserMentions.js';
 export * from './remarkVisibilityForMarkdown.js';
+export * from './pureTemplateComponents.js';

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

@@ -0,0 +1,7 @@
+import type { Program } from 'estree-jsx';
+import type { Root } from 'mdast';
+export declare const TEMPLATE_BUILT_IN_COMPONENTS: ReadonlySet<string>;
+type Statement = Program['body'][number];
+export declare function getKeptEsmStatements(tree: Root): Set<Statement>;
+export declare function extractIdentifierRef(estree: Program | undefined): string | null;
+export {};

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

@@ -0,0 +1,406 @@
+import { visit } from 'unist-util-visit';
+import { isMdxJsEsm } from '../../utils.js';
+export const TEMPLATE_BUILT_IN_COMPONENTS = new Set([
+    'Accordion',
+    'AccordionGroup',
+    'Badge',
+    'Callout',
+    'Card',
+    'CardGroup',
+    'Check',
+    'CodeBlock',
+    'CodeGroup',
+    'Color',
+    'Column',
+    'Columns',
+    'Danger',
+    'Expandable',
+    'FileTree',
+    'Frame',
+    'GitHub',
+    'Github',
+    'Heading',
+    'Icon',
+    'Info',
+    'Latex',
+    'Link',
+    'MDX',
+    'Mermaid',
+    'Note',
+    'OptimizedVideo',
+    'Panel',
+    'ParamField',
+    'Prompt',
+    'RequestExample',
+    'ResponseExample',
+    'ResponseField',
+    'SnippetGroup',
+    'Step',
+    'Steps',
+    'Tab',
+    'Tabs',
+    'Tile',
+    'Tip',
+    'Tooltip',
+    'Tree',
+    'Update',
+    'Variation',
+    'View',
+    'Visibility',
+    'Warning',
+    'ZoomImage',
+]);
+const UNSAFE_TAGS = new Set([
+    'base',
+    'embed',
+    'form',
+    'frame',
+    'frameset',
+    'iframe',
+    'link',
+    'math',
+    'meta',
+    'noscript',
+    'object',
+    'portal',
+    'script',
+    'style',
+    'svg',
+    'template',
+]);
+const UNSAFE_ATTRIBUTES = new Set([
+    'action',
+    'dangerouslysetinnerhtml',
+    'formaction',
+    'ref',
+    'srcdoc',
+    'style',
+]);
+const MDX_CONTENT_LOCALS = new Set(['props']);
+const VALUE_NAME = /^[a-z][\w$]*$/;
+const COMPONENT_NAME = /^[A-Z]\w*$/;
+const TAG_NAME = /^[a-z][a-z0-9]*$/;
+const ATTRIBUTE_NAME = /^[a-zA-Z][a-zA-Z0-9-]*$/;
+export function getKeptEsmStatements(tree) {
+    const components = new Map();
+    const kept = new Set();
+    const constantNames = new Set();
+    const esmBindings = new Set();
+    visit(tree, (node) => {
+        var _a;
+        if (!isMdxJsEsm(node) || !((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree))
+            return;
+        const program = node.data.estree;
+        collectTopLevelBindings(program, esmBindings);
+        for (const statement of program.body) {
+            const constantName = getLiteralConstantName(statement);
+            if (constantName) {
+                kept.add(statement);
+                constantNames.add(constantName);
+                continue;
+            }
+            const componentName = getPureTemplateComponentName(statement);
+            if (componentName)
+                components.set(statement, componentName);
+        }
+    });
+    if (components.size === 0)
+        return kept;
+    const { rejected, attributeStubNames } = scanContent(tree, new Set(components.values()), constantNames);
+    const shadowing = new Set([...esmBindings, ...attributeStubNames]);
+    for (const [statement, name] of components) {
+        if (rejected.has(name) || !usesOnlyUnshadowedBuiltIns(statement, shadowing))
+            continue;
+        kept.add(statement);
+    }
+    return kept;
+}
+function getLiteralConstantName(statement) {
+    var _a;
+    if (statement.type !== 'ExportNamedDeclaration')
+        return null;
+    const declaration = statement.declaration;
+    if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) !== 'VariableDeclaration' || declaration.kind !== 'const')
+        return null;
+    const declarator = declaration.declarations[0];
+    if (declaration.declarations.length !== 1 || (declarator === null || declarator === void 0 ? void 0 : declarator.id.type) !== 'Identifier')
+        return null;
+    const name = declarator.id.name;
+    if (!VALUE_NAME.test(name) || MDX_CONTENT_LOCALS.has(name))
+        return null;
+    if (((_a = declarator.init) === null || _a === void 0 ? void 0 : _a.type) !== 'Literal')
+        return null;
+    const value = declarator.init.value;
+    const isPrimitive = typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+    return isPrimitive ? name : null;
+}
+function getPureTemplateComponentName(statement) {
+    var _a, _b;
+    if (statement.type !== 'ExportNamedDeclaration' || !statement.declaration)
+        return null;
+    const declaration = statement.declaration;
+    let name;
+    let fn;
+    if (declaration.type === 'FunctionDeclaration') {
+        name = (_a = declaration.id) === null || _a === void 0 ? void 0 : _a.name;
+        fn = declaration;
+    }
+    else if (declaration.type === 'VariableDeclaration' &&
+        declaration.kind === 'const' &&
+        declaration.declarations.length === 1) {
+        const declarator = declaration.declarations[0];
+        if ((declarator === null || declarator === void 0 ? void 0 : declarator.id.type) !== 'Identifier')
+            return null;
+        if (((_b = declarator.init) === null || _b === void 0 ? void 0 : _b.type) !== 'ArrowFunctionExpression')
+            return null;
+        name = declarator.id.name;
+        fn = declarator.init;
+    }
+    else {
+        return null;
+    }
+    if (!name || !COMPONENT_NAME.test(name) || TEMPLATE_BUILT_IN_COMPONENTS.has(name))
+        return null;
+    if (fn.async || fn.generator)
+        return null;
+    const params = getParamNames(fn.params);
+    if (!params)
+        return null;
+    const root = getReturnedExpression(fn);
+    if ((root === null || root === void 0 ? void 0 : root.type) !== 'JSXElement' && (root === null || root === void 0 ? void 0 : root.type) !== 'JSXFragment')
+        return null;
+    return isPureElement(root, params) ? name : null;
+}
+function getParamNames(params) {
+    const names = new Set();
+    if (params.length === 0)
+        return names;
+    const param = params[0];
+    if (params.length > 1 || (param === null || param === void 0 ? void 0 : param.type) !== 'ObjectPattern')
+        return null;
+    for (const property of param.properties) {
+        if (property.type !== 'Property' || property.computed || !property.shorthand)
+            return null;
+        if (property.key.type !== 'Identifier' || property.value.type !== 'Identifier')
+            return null;
+        const name = property.key.name;
+        if (property.value.name !== name || !VALUE_NAME.test(name) || name in Object.prototype) {
+            return null;
+        }
+        names.add(name);
+    }
+    return names;
+}
+function getReturnedExpression(fn) {
+    var _a;
+    if (fn.body.type !== 'BlockStatement')
+        return fn.body;
+    const statement = fn.body.body[0];
+    if (fn.body.body.length !== 1 || (statement === null || statement === void 0 ? void 0 : statement.type) !== 'ReturnStatement')
+        return null;
+    return (_a = statement.argument) !== null && _a !== void 0 ? _a : null;
+}
+function isPureElement(node, params) {
+    if (node.type === 'JSXElement') {
+        const { name, attributes } = node.openingElement;
+        if (name.type !== 'JSXIdentifier' || !isSafeElementName(name.name))
+            return false;
+        if (!attributes.every((attribute) => isPureAttribute(attribute, params)))
+            return false;
+    }
+    return node.children.every((child) => isPureChild(child, params));
+}
+function isSafeElementName(name) {
+    if (TEMPLATE_BUILT_IN_COMPONENTS.has(name))
+        return true;
+    return TAG_NAME.test(name) && !UNSAFE_TAGS.has(name);
+}
+function isPureAttribute(attribute, params) {
+    if (attribute.type !== 'JSXAttribute' || attribute.name.type !== 'JSXIdentifier')
+        return false;
+    const name = attribute.name.name;
+    if (!ATTRIBUTE_NAME.test(name) ||
+        /^on/i.test(name) ||
+        UNSAFE_ATTRIBUTES.has(name.toLowerCase())) {
+        return false;
+    }
+    const value = attribute.value;
+    if (value === null)
+        return true;
+    if (value.type === 'Literal')
+        return typeof value.value === 'string';
+    if (value.type !== 'JSXExpressionContainer')
+        return false;
+    if (value.expression.type === 'JSXEmptyExpression')
+        return false;
+    return isPureValue(value.expression, params);
+}
+function isPureChild(child, params) {
+    switch (child.type) {
+        case 'JSXText':
+            return true;
+        case 'JSXElement':
+        case 'JSXFragment':
+            return isPureElement(child, params);
+        case 'JSXExpressionContainer':
+            return (child.expression.type === 'JSXEmptyExpression' || isPureValue(child.expression, params));
+        default:
+            return false;
+    }
+}
+function isPureValue(node, params) {
+    switch (node.type) {
+        case 'Literal':
+            return typeof node.value === 'string' || typeof node.value === 'number';
+        case 'Identifier':
+            return params.has(node.name);
+        case 'TemplateLiteral':
+            return node.expressions.every((expression) => expression.type === 'Identifier' && params.has(expression.name));
+        default:
+            return false;
+    }
+}
+function scanContent(tree, candidates, constantNames) {
+    const rejected = new Set();
+    const attributeStubNames = new Set();
+    visit(tree, (node) => {
+        var _a, _b, _c;
+        if (isMdxJsEsm(node))
+            return;
+        if ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') &&
+            'name' in node &&
+            typeof node.name === 'string') {
+            const memberRoot = node.name.split('.')[0];
+            if (memberRoot && memberRoot !== node.name && candidates.has(memberRoot)) {
+                rejected.add(memberRoot);
+            }
+            if (candidates.has(node.name) && 'attributes' in node) {
+                const hasOnlyLiteralAttributes = node.attributes.every((attribute) => {
+                    var _a;
+                    return attribute.type === 'mdxJsxAttribute' &&
+                        (attribute.value == null ||
+                            typeof attribute.value === 'string' ||
+                            isConstantReference((_a = attribute.value.data) === null || _a === void 0 ? void 0 : _a.estree, constantNames));
+                });
+                if (!hasOnlyLiteralAttributes)
+                    rejected.add(node.name);
+            }
+        }
+        const referenced = new Set();
+        if ('data' in node && isRecord(node.data) && 'estree' in node.data) {
+            collectIdentifierNames(node.data.estree, referenced);
+        }
+        if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+            for (const attribute of node.attributes) {
+                collectIdentifierNames(attribute, referenced);
+                if (attribute.type !== 'mdxJsxAttribute' || typeof attribute.value !== 'object')
+                    continue;
+                const stubName = extractIdentifierRef((_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 ? _c : undefined);
+                if (stubName)
+                    attributeStubNames.add(stubName);
+            }
+        }
+        for (const name of referenced) {
+            if (candidates.has(name))
+                rejected.add(name);
+        }
+    });
+    return { rejected, attributeStubNames };
+}
+function isConstantReference(program, constantNames) {
+    const statement = program === null || program === void 0 ? void 0 : program.body[0];
+    if ((program === null || program === void 0 ? void 0 : program.body.length) !== 1 || (statement === null || statement === void 0 ? void 0 : statement.type) !== 'ExpressionStatement')
+        return false;
+    return statement.expression.type === 'Identifier' && constantNames.has(statement.expression.name);
+}
+// Returns the identifier name if the estree expression is a bare reference that will be kept
+// by isStringSafe but needs a stub to avoid a ReferenceError at render time:
+//   {foo}    → Identifier
+//   {!!foo}  → UnaryExpression(! UnaryExpression(! Identifier))
+// Parenthesised forms are transparent in ESTree so (foo) produces the same AST as foo.
+export function extractIdentifierRef(estree) {
+    const stmt = estree === null || estree === void 0 ? void 0 : estree.body[0];
+    if ((stmt === null || stmt === void 0 ? void 0 : stmt.type) !== 'ExpressionStatement')
+        return null;
+    const expr = stmt.expression;
+    if (expr.type === 'Identifier')
+        return expr.name;
+    if (expr.type === 'UnaryExpression' &&
+        expr.operator === '!' &&
+        expr.argument.type === 'UnaryExpression' &&
+        expr.argument.operator === '!' &&
+        expr.argument.argument.type === 'Identifier')
+        return expr.argument.argument.name;
+    return null;
+}
+function usesOnlyUnshadowedBuiltIns(statement, shadowing) {
+    const elementNames = new Set();
+    collectJsxElementNames(statement, elementNames);
+    for (const name of elementNames) {
+        if (/^[A-Z]/.test(name) && shadowing.has(name))
+            return false;
+    }
+    return true;
+}
+function collectTopLevelBindings(program, out) {
+    for (const statement of program.body) {
+        if (statement.type === 'ImportDeclaration') {
+            for (const specifier of statement.specifiers)
+                out.add(specifier.local.name);
+            continue;
+        }
+        if ((statement.type !== 'ExportNamedDeclaration' &&
+            statement.type !== 'ExportDefaultDeclaration') ||
+            !statement.declaration) {
+            collectIdentifierNames(statement, out, ['Identifier']);
+            continue;
+        }
+        const declaration = statement.declaration;
+        if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'VariableDeclaration') {
+            for (const declarator of declaration.declarations) {
+                collectIdentifierNames(declarator.id, out, ['Identifier']);
+            }
+        }
+        else if (((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'FunctionDeclaration' || (declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'ClassDeclaration') &&
+            declaration.id) {
+            out.add(declaration.id.name);
+        }
+    }
+}
+function collectIdentifierNames(value, out, types = ['Identifier', 'JSXIdentifier']) {
+    walkEstree(value, (node) => {
+        if (typeof node.type === 'string' &&
+            types.includes(node.type) &&
+            typeof node.name === 'string') {
+            out.add(node.name);
+        }
+    });
+}
+function collectJsxElementNames(value, out) {
+    walkEstree(value, (node) => {
+        if (node.type !== 'JSXOpeningElement' || !('name' in node) || !isRecord(node.name))
+            return;
+        if (node.name.type === 'JSXIdentifier' && typeof node.name.name === 'string') {
+            out.add(node.name.name);
+        }
+    });
+}
+function walkEstree(value, onNode) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            walkEstree(item, onNode);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    if (typeof value.type === 'string')
+        onNode(value);
+    for (const [key, child] of Object.entries(value)) {
+        if (key === 'loc' || key === 'range' || key === 'position')
+            continue;
+        walkEstree(child, onNode);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

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

@@ -1,7 +1,9 @@
+import { jsx as jsxHandlers, toJs } from 'estree-util-to-js';
 import { remove } from 'unist-util-remove';
 import { CONTINUE, visit } from 'unist-util-visit';
 import { UNSAFE_OBJECT_KEYS } from '../../static-object-keys.js';
 import { isMdxJsEsm } from '../../utils.js';
+import { extractIdentifierRef, getKeptEsmStatements } from './pureTemplateComponents.js';
 const objectEstree = {
     type: 'Program',
     body: [
@@ -402,26 +404,6 @@ function collectIdentifiersFromPattern(pattern, out) {
         collectIdentifiersFromPattern(pattern.argument, out);
     }
 }
-// Returns the identifier name if the estree expression is a bare reference that will be kept
-// by isStringSafe but needs a stub to avoid a ReferenceError at render time:
-//   {foo}    → Identifier
-//   {!!foo}  → UnaryExpression(! UnaryExpression(! Identifier))
-// Parenthesised forms are transparent in ESTree so (foo) produces the same AST as foo.
-function extractIdentifierRef(estree) {
-    const stmt = estree === null || estree === void 0 ? void 0 : estree.body[0];
-    if ((stmt === null || stmt === void 0 ? void 0 : stmt.type) !== 'ExpressionStatement')
-        return null;
-    const expr = stmt.expression;
-    if (expr.type === 'Identifier')
-        return expr.name;
-    if (expr.type === 'UnaryExpression' &&
-        expr.operator === '!' &&
-        expr.argument.type === 'UnaryExpression' &&
-        expr.argument.operator === '!' &&
-        expr.argument.argument.type === 'Identifier')
-        return expr.argument.argument.name;
-    return null;
-}
 function collectExportedNames(estree) {
     var _a, _b;
     const names = [];
@@ -690,19 +672,43 @@ function sanitizer(edit) {
             });
         }
         edit.remove(tree, (node) => isMdxExpression(node) && !isInertExpression(node));
+        const keptStatements = getKeptEsmStatements(tree);
+        const keptNames = new Set(collectExportedNames({
+            type: 'Program',
+            body: [...keptStatements],
+            sourceType: 'module',
+        }).map(({ name }) => name));
         // Collect exported names before stripping ESM so we can inject stubs.
         // Map keyed by name deduplicates naturally.
         const stubbedNamesMap = new Map();
-        visit(tree, (node) => {
+        const partiallyKept = [];
+        visit(tree, (node, index, parent) => {
             var _a;
-            if (isMdxJsEsm(node) && ((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree)) {
-                for (const entry of collectExportedNames(node.data.estree)) {
-                    if (!stubbedNamesMap.has(entry.name))
-                        stubbedNamesMap.set(entry.name, entry);
-                }
+            if (!isMdxJsEsm(node) || !((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree))
+                return;
+            const program = node.data.estree;
+            const stripped = program.body.filter((statement) => !keptStatements.has(statement));
+            for (const entry of collectExportedNames(Object.assign(Object.assign({}, program), { body: stripped }))) {
+                if (!stubbedNamesMap.has(entry.name))
+                    stubbedNamesMap.set(entry.name, entry);
+            }
+            if (stripped.length > 0 && stripped.length < program.body.length && parent && index != null) {
+                const body = program.body.filter((statement) => keptStatements.has(statement));
+                partiallyKept.push({ parent, index, program: Object.assign(Object.assign({}, program), { body, comments: [] }) });
             }
         });
-        edit.remove(tree, (node) => isMdxJsEsm(node));
+        for (const { parent, index, program } of partiallyKept) {
+            edit.replaceChild(parent, index, {
+                type: 'mdxjsEsm',
+                value: toJs(program, { handlers: jsxHandlers }).value,
+                data: { estree: program },
+            });
+        }
+        edit.remove(tree, (node) => {
+            var _a, _b;
+            return isMdxJsEsm(node) &&
+                !((_b = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree) === null || _b === void 0 ? void 0 : _b.body.some((statement) => keptStatements.has(statement)));
+        });
         // 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) => {
@@ -717,7 +723,7 @@ function sanitizer(edit) {
                 if (attr.type === 'mdxJsxAttribute' && attr.value instanceof Object) {
                     if (isStringSafe(attr.value.value)) {
                         const ident = extractIdentifierRef((_a = attr.value.data) === null || _a === void 0 ? void 0 : _a.estree);
-                        if (ident && !stubbedNamesMap.has(ident))
+                        if (ident && !stubbedNamesMap.has(ident) && !keptNames.has(ident))
                             stubbedNamesMap.set(ident, { name: ident, isFunction: false });
                         return attr;
                     }

package/dist/navigation/filterDivisions.test.js

@@ -270,6 +270,29 @@ describe(filterDivisions, () => {
         });
     });
 });
+describe('filterDivisions with regional languages', () => {
+    it('matches the same page in a regional language whose prefix is lower case', () => {
+        const page = (href) => ({ title: href, href });
+        const result = filterDivisions({
+            currentPath: '/quickstart',
+            userGroups: new Set(),
+            currentVersion: undefined,
+            currentLanguage: 'en',
+            shouldUseDivisionMatch: false,
+            cache: { dropdownCache: new Map() },
+            decoratedNav: {
+                languages: [
+                    { language: 'en', default: true, pages: [page('/index'), page('/quickstart')] },
+                    { language: 'en-GB', pages: [page('/en-gb/index'), page('/en-gb/quickstart')] },
+                ],
+            },
+        });
+        expect(result.firstHrefInLanguage.get('en-GB')).toEqual({
+            href: '/en-gb/quickstart',
+            matchLevel: DivisionMatchLevel.PATH,
+        });
+    });
+});
 describe('filterDivisions with partial auth', () => {
     const defaultArgs = {
         decoratedNav: { groups: [] },

package/dist/navigation/pathsDifferByOneSegment.test.js

@@ -9,6 +9,23 @@ describe('pathsDifferByOneSegment', () => {
             expect(pathsDifferByOneSegment('/ja/getting-started', '/es/getting-started', 'language')).toBe(true);
             expect(pathsDifferByOneSegment('/fr/docs/intro', '/de/docs/intro', 'language')).toBe(true);
         });
+        it('treats configured regional language prefixes as locales, ignoring case', () => {
+            const languages = ['en', 'en-GB', 'es', 'es-MX'];
+            expect(pathsDifferByOneSegment('/en-gb/quickstart', '/quickstart', 'language', languages)).toBe(true);
+            expect(pathsDifferByOneSegment('/es-MX/quickstart', '/es/quickstart', 'language', languages)).toBe(true);
+        });
+        it('treats a configured regional language after a version segment as a locale', () => {
+            expect(pathsDifferByOneSegment('/v2/en-gb/quickstart', '/v2/quickstart', 'language', [
+                'en',
+                'en-GB',
+            ])).toBe(true);
+            expect(pathsDifferByOneSegment('/v2/hi-fi/quickstart', '/v2/quickstart', 'language')).toBe(false);
+        });
+        it('does not treat unconfigured code-like segments as locales', () => {
+            expect(pathsDifferByOneSegment('/en-gb/quickstart', '/quickstart', 'language')).toBe(false);
+            expect(pathsDifferByOneSegment('/hi-fi/setup', '/de/hi-fi/setup', 'language', ['en', 'de'])).toBe(true);
+            expect(pathsDifferByOneSegment('/hi-fi/setup', '/de/setup', 'language', ['en', 'de'])).toBe(false);
+        });
         it('returns false for paths with different content', () => {
             expect(pathsDifferByOneSegment('/ja/getting-started', '/ja/quickstart', 'language')).toBe(false);
             expect(pathsDifferByOneSegment('/getting-started', '/quickstart', 'language')).toBe(false);

package/dist/navigation/scopeNavToPath.d.ts

@@ -1,5 +1,5 @@
 import { LocaleType } from '@mintlify/models';
-import type { DecoratedNavigationConfig, DocsConfig } from '@mintlify/validation';
+import { type DecoratedNavigationConfig, type DocsConfig } from '@mintlify/validation';
 import { DivisionMatch } from './updateFirstHrefInDivision.js';
 export declare function scopeDecoratedNavToPath(nav: DecoratedNavigationConfig, currentPath: string, userGroups?: Set<string>): DecoratedNavigationConfig;
 export declare function scopeDocsConfigNavToPath(docsConfig: DocsConfig, currentPath: string): DocsConfig;

package/dist/navigation/scopeNavToPath.js

@@ -9,7 +9,8 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { locales } from '@mintlify/models';
+import { isLocale } from '@mintlify/models';
+import { divisions, } from '@mintlify/validation';
 import { generatePathToLanguageDict, generatePathToVersionDict } from '../divisions/index.js';
 import { optionallyRemoveLeadingSlash } from '../fs/optionallySlash.js';
 import { isEqualIgnoringLeadingSlash } from '../paths/isEqualIgnoringLeadingSlash.js';
@@ -49,6 +50,31 @@ const STUB_STRIPPED_KEYS = new Set([
 function isNavNode(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+const LANGUAGE_CONTAINER_KEYS = [...divisions, 'global'];
+function addConfiguredLanguages(node, languages) {
+    if (Array.isArray(node)) {
+        for (const entry of node)
+            addConfiguredLanguages(entry, languages);
+        return;
+    }
+    if (!isNavNode(node))
+        return;
+    if (typeof node.language === 'string' && isLocale(node.language))
+        languages.add(node.language);
+    for (const key of LANGUAGE_CONTAINER_KEYS)
+        addConfiguredLanguages(node[key], languages);
+}
+const configuredLanguagesCache = new WeakMap();
+function getConfiguredLanguages(nav) {
+    const cached = configuredLanguagesCache.get(nav);
+    if (cached)
+        return cached;
+    const languages = new Set();
+    addConfiguredLanguages(nav, languages);
+    const result = [...languages];
+    configuredLanguagesCache.set(nav, result);
+    return result;
+}
 function isScopedDivisionKey(key) {
     return key === 'versions' || key === 'languages';
 }
@@ -143,7 +169,7 @@ function pickStubTarget(division, ctx, type) {
     const exact = pool.find((candidate) => isEqualIgnoringLeadingSlash(candidate.href, ctx.currentPath));
     if (exact)
         return exact;
-    const pathMatch = pool.find((candidate) => pathsDifferByOneSegment(candidate.href, ctx.currentPath, type));
+    const pathMatch = pool.find((candidate) => pathsDifferByOneSegment(candidate.href, ctx.currentPath, type, ctx.languages));
     return pathMatch !== null && pathMatch !== void 0 ? pathMatch : pool[0];
 }
 // carrying the target's hidden/groups keeps a division with no anonymously
@@ -517,13 +543,18 @@ function scopeNode(node, ctx) {
     return scoped;
 }
 export function scopeDecoratedNavToPath(nav, currentPath, userGroups) {
+    const ctx = { currentPath, userGroups, languages: getConfiguredLanguages(nav) };
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
-    return scopeNode(nav, { currentPath, userGroups });
+    return scopeNode(nav, ctx);
 }
 export function scopeDocsConfigNavToPath(docsConfig, currentPath) {
+    const ctx = {
+        currentPath,
+        languages: getConfiguredLanguages(docsConfig.navigation),
+    };
     return Object.assign(Object.assign({}, docsConfig), { 
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
-        navigation: scopeNode(docsConfig.navigation, { currentPath }) });
+        navigation: scopeNode(docsConfig.navigation, ctx) });
 }
 const pathToVersionDictCache = new WeakMap();
 const pathToLanguageDictCache = new WeakMap();
@@ -571,7 +602,7 @@ export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = ne
         const strippedPath = optionallyRemoveLeadingSlash(currentPath);
         const dictVersion = cachedPathToVersionDict(decoratedNav).get(strippedPath);
         const dictLanguage = cachedPathToLanguageDict(decoratedNav).get(strippedPath);
-        const localeFromDict = locales.find((locale) => locale === dictLanguage);
+        const localeFromDict = dictLanguage && isLocale(dictLanguage) ? dictLanguage : undefined;
         currentVersion =
             dictVersion ||
                 getVersionOrLanguageFromPath('version', decoratedNav, currentPath, defaultVersion, (_d = (_c = initial.versions[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '') ||
@@ -596,6 +627,7 @@ export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = ne
         currentPath,
         currentVersion,
         currentLanguage,
+        languages: getConfiguredLanguages(decoratedNav),
         versionTargets: filtered.firstHrefInVersion,
         languageTargets: filtered.firstHrefInLanguage,
         userGroups,