@mintlify/common 1.0.1229 → 1.0.1231

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

@@ -1,9 +1,10 @@
 import { visit } from 'unist-util-visit';
+import { normalizeGroups } from '../../../navigation/groupAccess.js';
 import { safeCleanHeadingId, slugify } from '../../../slugify.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, toVisibilityAuthRule, } from './remarkVisibilityForMarkdown.js';
+import { isHiddenFromHumans, isVisibilityElement, resolveVisibilityFor, toPageGroups, toVisibilityAuthRule, } from './remarkVisibilityForMarkdown.js';
 import { isVariationElement, resolveVariationIds } from './variation.js';
 export const HEADING_NAMES = ['h1', 'h2', 'h3', 'h4'];
 const COMPONENTS_TO_EXCLUDE_HEADINGS = [
@@ -20,7 +21,13 @@ function getStringAttribute(attributes, name) {
     }
     return undefined;
 }
-const authRuleKey = (rule) => typeof rule === 'string' ? rule : JSON.stringify([...rule.groups].sort());
+const sortedGroups = (groups) => groups && [...groups].sort();
+const authRuleKey = (rule) => {
+    if (typeof rule === 'string')
+        return rule;
+    const normalized = normalizeGroups(toPageGroups(rule.groups));
+    return JSON.stringify([sortedGroups(normalized === null || normalized === void 0 ? void 0 : normalized.includes), sortedGroups(normalized === null || normalized === void 0 ? void 0 : normalized.excludes)]);
+};
 const hasAuthRules = (childRules, parentRules) => {
     if (parentRules === undefined)
         return true;

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

@@ -1,3 +1,4 @@
+import type { PageGroupRule, PageGroups } from '@mintlify/models';
 import type { Root } from 'mdast';
 import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
 export type MdxJsxElement = MdxJsxFlowElement | MdxJsxTextElement;
@@ -8,9 +9,11 @@ export declare function isVisibilityElement(node: {
 export declare const VISIBILITY_AUDIENCES: readonly ["humans", "agents", "signed-in", "signed-out"];
 export type VisibilityAudience = (typeof VISIBILITY_AUDIENCES)[number];
 export declare const VISIBILITY_FOR_EXPECTED = "\"humans\", \"agents\", \"signed-in\", \"signed-out\", or { groups: [...] }";
-export type VisibilityAuthRule = 'signed-in' | 'signed-out' | {
-    groups: string[];
+export type VisibilityGroups = string[] | PageGroupRule;
+export type VisibilityGroupsRule = {
+    groups: VisibilityGroups;
 };
+export type VisibilityAuthRule = 'signed-in' | 'signed-out' | VisibilityGroupsRule;
 export type VisibilityViewer = {
     signedIn: boolean;
     groups: readonly string[];
@@ -20,7 +23,7 @@ export type VisibilityResolution = {
     audience: VisibilityAudience;
 } | {
     kind: 'groups';
-    groups: string[];
+    groups: VisibilityGroups;
 } | {
     kind: 'invalid';
     raw: string;
@@ -30,6 +33,8 @@ export type VisibilityResolution = {
     kind: 'missing';
 };
 export declare function isVisibilityAudience(value: unknown): value is VisibilityAudience;
+export declare const toPageGroups: (groups: VisibilityGroups) => PageGroups;
+export declare function toVisibilityGroupsRule(value: unknown): VisibilityGroupsRule | undefined;
 export declare function resolveVisibilityFor(node: MdxJsxElement): VisibilityResolution;
 export declare function isHiddenFromHumans(resolution: VisibilityResolution): boolean;
 export declare function isHiddenFromAgents(resolution: VisibilityResolution): boolean;

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

@@ -1,3 +1,4 @@
+import { WILDCARD_GROUP, checkGroupAccess, isPageGroups } from '../../../navigation/groupAccess.js';
 export function isVisibilityElement(node) {
     return ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') &&
         node.name === 'Visibility');
@@ -42,19 +43,68 @@ function foldString(node) {
             return undefined;
     }
 }
+const trimGroupNames = (names) => [...new Set(names.map((name) => name.trim()))];
+const isGroupNames = (groups) => groups.every((entry) => typeof entry === 'string');
+export const toPageGroups = (groups) => Array.isArray(groups) ? groups : [groups];
+function toVisibilityGroups(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0 || !isPageGroups(value) || !isGroupNames(value))
+            return undefined;
+        const names = trimGroupNames(value);
+        return isPageGroups(names) ? names : undefined;
+    }
+    const rules = [value];
+    if (!isPageGroups(rules) || isGroupNames(rules))
+        return undefined;
+    const [rule] = rules.map(({ includes, excludes }) => (Object.assign(Object.assign({}, (includes && { includes: trimGroupNames(includes) })), (excludes && { excludes: trimGroupNames(excludes) }))));
+    return rule && isPageGroups([rule]) ? rule : undefined;
+}
+export function toVisibilityGroupsRule(value) {
+    if (!isRecord(value) || Object.keys(value).length !== 1)
+        return undefined;
+    const groups = toVisibilityGroups(value.groups);
+    return groups && { groups };
+}
+function staticKey(property) {
+    if (property.type !== 'Property' || property.computed)
+        return undefined;
+    if (property.key.type === 'Identifier')
+        return property.key.name;
+    return property.key.type === 'Literal' && typeof property.key.value === 'string'
+        ? property.key.value
+        : undefined;
+}
+function foldGroupNames(array) {
+    const names = array.elements.map((element) => foldString(element));
+    return names.every((name) => name !== undefined) ? names : undefined;
+}
+function foldGroupRule(object) {
+    const rule = {};
+    for (const property of object.properties) {
+        const key = staticKey(property);
+        if (property.type !== 'Property' || (key !== 'includes' && key !== 'excludes')) {
+            return undefined;
+        }
+        const names = property.value.type === 'ArrayExpression' ? foldGroupNames(property.value) : undefined;
+        if (!names)
+            return undefined;
+        rule[key] = names;
+    }
+    return rule;
+}
 function resolveGroups(value) {
     const expression = expressionOf(value);
     if ((expression === null || expression === void 0 ? void 0 : expression.type) !== 'ObjectExpression' || expression.properties.length !== 1)
         return undefined;
     const [property] = expression.properties;
-    if ((property === null || property === void 0 ? void 0 : property.type) !== 'Property' || property.computed)
-        return undefined;
-    const key = property.key.type === 'Identifier' ? property.key.name : undefined;
-    const literalKey = property.key.type === 'Literal' ? property.key.value : undefined;
-    if ((key !== null && key !== void 0 ? key : literalKey) !== 'groups' || property.value.type !== 'ArrayExpression')
+    if ((property === null || property === void 0 ? void 0 : property.type) !== 'Property' || staticKey(property) !== 'groups')
         return undefined;
-    const groups = property.value.elements.map((element) => { var _a, _b; return (_b = (_a = foldString(element)) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ''; });
-    return groups.length > 0 && groups.every(Boolean) ? [...new Set(groups)] : undefined;
+    if (property.value.type === 'ObjectExpression') {
+        return toVisibilityGroups(foldGroupRule(property.value));
+    }
+    return property.value.type === 'ArrayExpression'
+        ? toVisibilityGroups(foldGroupNames(property.value))
+        : undefined;
 }
 function mayOverrideFor(attr) {
     if (attr.type !== 'mdxJsxExpressionAttribute')
@@ -172,7 +222,7 @@ export function matchesVisibilityAuthRule(rule, viewer) {
         return viewer.signedIn;
     if (rule === 'signed-out')
         return !viewer.signedIn;
-    return viewer.signedIn && rule.groups.some((group) => viewer.groups.includes(group));
+    return checkGroupAccess(toPageGroups(rule.groups), new Set(viewer.signedIn ? [...viewer.groups, WILDCARD_GROUP] : []));
 }
 // `export * from` is intentionally ignored: it exposes no statically-knowable
 // names and creates no page-local JSX bindings in MDX, so there is nothing to

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,

package/dist/navigation/scopeNavToPath.test.js

@@ -43,6 +43,43 @@ describe('scopeDecoratedNavToPath', () => {
         expect(es.pages).toEqual([{ title: 'es', href: '/es/get-started/intro' }]);
         expect(fr.pages).toEqual([{ title: 'fr', href: '/fr/other/page' }]);
     });
+    it('keeps a regional language division active on its own pages', () => {
+        const regionalNav = {
+            languages: [
+                { language: 'en', default: true, pages: [page('/intro'), page('/install')] },
+                { language: 'en-GB', pages: [page('/en-gb/intro'), page('/en-gb/install')] },
+            ],
+        };
+        const [en, enGB] = loose(scopeDecoratedNavToPath(regionalNav, '/en-gb/intro')).languages;
+        if (!en || !enGB)
+            throw new Error('missing languages');
+        expect(enGB.pages).toEqual([page('/en-gb/intro'), page('/en-gb/install')]);
+        expect(en.pages).toEqual([{ title: 'en', href: '/intro' }]);
+    });
+    it('stubs a regional language division with the same page under its prefix', () => {
+        const regionalNav = {
+            languages: [
+                { language: 'en', default: true, pages: [page('/intro'), page('/install')] },
+                { language: 'en-GB', pages: [page('/en-gb/intro'), page('/en-gb/install')] },
+            ],
+        };
+        const [, enGB] = loose(scopeDecoratedNavToPath(regionalNav, '/install')).languages;
+        expect(enGB === null || enGB === void 0 ? void 0 : enGB.pages).toEqual([{ title: 'en-GB', href: '/en-gb/install' }]);
+    });
+    it('ignores a page field named language when finding configured languages', () => {
+        const nav = {
+            languages: [
+                {
+                    language: 'en',
+                    default: true,
+                    pages: [{ title: 'Setup', href: '/hi-fi/setup', language: 'hi-fi' }],
+                },
+                { language: 'de', pages: [page('/de/setup'), page('/de/hi-fi/setup')] },
+            ],
+        };
+        const [, de] = loose(scopeDecoratedNavToPath(nav, '/hi-fi/setup')).languages;
+        expect(de === null || de === void 0 ? void 0 : de.pages).toEqual([{ title: 'de', href: '/de/hi-fi/setup' }]);
+    });
     it('falls back to the default division when the path is not found', () => {
         const scoped = scopeDecoratedNavToPath(decoratedNav, '/does/not/exist');
         const [en, es] = loose(scoped).languages;

package/dist/navigation/updateFirstHrefInDivision.d.ts

@@ -28,4 +28,4 @@ export declare function updateFirstHrefInDivision({ type, currentPath, entry, pa
     activeGroupNames?: Set<string>;
     activeDivisionOwner?: object;
 }): void;
-export declare function pathsDifferByOneSegment(a: string, b: string, type: 'version' | 'language'): boolean;
+export declare function pathsDifferByOneSegment(a: string, b: string, type: 'version' | 'language', languages?: readonly string[]): boolean;

package/dist/navigation/updateFirstHrefInDivision.js

@@ -1,4 +1,4 @@
-import { locales } from '@mintlify/models';
+import { isKnownLocale } from '@mintlify/models';
 import { divisions, } from '@mintlify/validation';
 import { readObjectArrayProperty } from '../divisions/iterateObjectArrayProperty.js';
 import { isEqualIgnoringLeadingSlash } from '../paths/isEqualIgnoringLeadingSlash.js';
@@ -209,29 +209,30 @@ function findActiveGroupNames(entry, currentPath, activeGroupNames = new Set())
     }
     return activeGroupNames;
 }
-function parseLanguagePath(segments) {
+const isLanguageSegment = (segment, languages) => {
+    if (segment === undefined)
+        return false;
+    if (isKnownLocale(segment))
+        return true;
+    const lowerCaseSegment = segment.toLowerCase();
+    return languages.some((language) => language.toLowerCase() === lowerCaseSegment);
+};
+function parseLanguagePath(segments, languages) {
     let index = 0;
     let locale;
     let hasDocsBase = false;
     const firstSegment = segments[0];
     const firstIsDocsBase = !!firstSegment && ACCEPTED_BASE_PATHS.includes(firstSegment);
-    const firstIsLocale = !!firstSegment &&
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
-        locales.includes(firstSegment);
     if (firstIsDocsBase) {
         hasDocsBase = true;
         index = 1;
         const maybeLocale = segments[index];
-        if (maybeLocale &&
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
-            locales.includes(maybeLocale)) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
+        if (isLanguageSegment(maybeLocale, languages)) {
             locale = maybeLocale;
             index++;
         }
     }
-    else if (firstIsLocale) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
+    else if (isLanguageSegment(firstSegment, languages)) {
         locale = firstSegment;
         index = 1;
         const maybeDocsBase = segments[index];
@@ -283,8 +284,9 @@ function maybeUpdateFirstHrefInDivision(type, href, finalVersion, inActiveGroup,
     // we make the BOLD assumption that href is a different version of the same page
     if (currentVersion !== undefined && finalVersion !== undefined) {
         const existingRef = firstHrefInDivision.get(finalVersion);
+        const languages = type === 'language' ? versionStrings : undefined;
         if ((existingRef === undefined || DivisionMatchLevel.PATH < existingRef.matchLevel) &&
-            pathsDifferByOneSegment(href, currentPath, type)) {
+            pathsDifferByOneSegment(href, currentPath, type, languages)) {
             firstHrefInDivision.set(finalVersion, { href, matchLevel: DivisionMatchLevel.PATH });
         }
     }
@@ -316,18 +318,19 @@ function maybeUpdateFirstHrefInDivision(type, href, finalVersion, inActiveGroup,
         }
     }
 }
-export function pathsDifferByOneSegment(a, b, type) {
+export function pathsDifferByOneSegment(a, b, type, languages = []) {
+    var _a, _b;
     const aSegments = a.split('/').filter(Boolean);
     const bSegments = b.split('/').filter(Boolean);
     // For language switching, we need to be more strict - paths should be identical except for the language segment
     // once normalized, content segments should be identical and only locale prefix may differ.
     if (type === 'language') {
-        const aPath = parseLanguagePath(aSegments);
-        const bPath = parseLanguagePath(bSegments);
+        const aPath = parseLanguagePath(aSegments, languages);
+        const bPath = parseLanguagePath(bSegments, languages);
         if (aPath.hasDocsBase !== bPath.hasDocsBase)
             return false;
         if (!aPath.locale && !bPath.locale) {
-            return differByOneLocaleSegment(aPath.contentSegments, bPath.contentSegments);
+            return differByOneLocaleSegment(aPath.contentSegments, bPath.contentSegments, languages);
         }
         // For language switching, the content parts (including version segments) must be identical.
         if (aPath.contentSegments.length !== bPath.contentSegments.length)
@@ -340,7 +343,7 @@ export function pathsDifferByOneSegment(a, b, type) {
         // The paths are language variants if locale presence/value differs.
         if (!aPath.locale && !bPath.locale)
             return false;
-        return aPath.locale !== bPath.locale;
+        return ((_a = aPath.locale) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== ((_b = bPath.locale) === null || _b === void 0 ? void 0 : _b.toLowerCase());
     }
     const aStartsWithDocs = aSegments[0] && ACCEPTED_BASE_PATHS.includes(aSegments[0]);
     const bStartsWithDocs = bSegments[0] && ACCEPTED_BASE_PATHS.includes(bSegments[0]);
@@ -377,22 +380,22 @@ export function pathsDifferByOneSegment(a, b, type) {
     }
     return true;
 }
-function isLocale(segment) {
-    return locales.some((locale) => locale === segment);
-}
-function differByOneLocaleSegment(a, b) {
+function differByOneLocaleSegment(a, b, languages) {
     if (a.length === b.length) {
         const mismatches = a.flatMap((segment, i) => (segment === b[i] ? [] : [i]));
         if (mismatches.length !== 1)
             return false;
         const [index] = mismatches;
-        return index !== undefined && isLocale(a[index]) && isLocale(b[index]);
+        return (index !== undefined &&
+            isLanguageSegment(a[index], languages) &&
+            isLanguageSegment(b[index], languages));
     }
     const [longer, shorter] = a.length > b.length ? [a, b] : [b, a];
     if (longer.length !== shorter.length + 1)
         return false;
     const index = longer.findIndex((segment, i) => segment !== shorter[i]);
-    return (isLocale(longer[index]) && longer.slice(index + 1).every((s, i) => s === shorter[index + i]));
+    return (isLanguageSegment(longer[index], languages) &&
+        longer.slice(index + 1).every((s, i) => s === shorter[index + i]));
 }
 function checkActiveGroup(group, currentPath) {
     if (isPage(group)) {