gt 2.14.35 → 2.14.37

package/dist/utils/localizeStaticImports.js

@@ -1,397 +1,255 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { createFileMapping } from '../formats/files/fileMapping.js';
-import micromatch from 'micromatch';
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkMdx from 'remark-mdx';
-import remarkFrontmatter from 'remark-frontmatter';
-import { visit } from 'unist-util-visit';
+import { createFileMapping } from "../formats/files/fileMapping.js";
+import * as fs$1 from "fs";
+import micromatch from "micromatch";
+import * as path$1 from "path";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkMdx from "remark-mdx";
+import remarkFrontmatter from "remark-frontmatter";
+import { visit } from "unist-util-visit";
+//#region src/utils/localizeStaticImports.ts
 const { isMatch } = micromatch;
 /**
- * Localizes static imports in content files.
- * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
- * @param settings - The settings object containing the project configuration.
- * @returns void
- *
- * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
- * it can be enabled by default.
- *
- * Before this becomes a non-experimental feature, we need to:
- * - Support more file types
- * - Support more complex paths
- */
-export default async function localizeStaticImports(settings, includeFiles) {
-    if (!settings.files ||
-        (Object.keys(settings.files.placeholderPaths).length === 1 &&
-            settings.files.placeholderPaths.gt)) {
-        return;
-    }
-    const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths ?? {}, settings.files.transformFormats ?? {}, settings.locales, settings.defaultLocale);
-    // Process all file types at once with a single call
-    const processPromises = [];
-    // First, process default locale files (from source files)
-    // This is needed because they might not be in the fileMapping if they're not being translated
-    if (!fileMapping[settings.defaultLocale] && !includeFiles) {
-        const defaultLocaleFiles = [];
-        // Collect all .md and .mdx files from sourceFiles
-        if (sourceFiles.md) {
-            defaultLocaleFiles.push(...sourceFiles.md);
-        }
-        if (sourceFiles.mdx) {
-            defaultLocaleFiles.push(...sourceFiles.mdx);
-        }
-        if (defaultLocaleFiles.length > 0) {
-            const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
-                // Check if file exists before processing
-                if (!fs.existsSync(filePath)) {
-                    return;
-                }
-                // Get file content
-                const fileContent = await fs.promises.readFile(filePath, 'utf8');
-                // Localize the file using default locale
-                const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
-                // Write the localized file back to the same path
-                await fs.promises.writeFile(filePath, localizedFile);
-            }));
-            processPromises.push(defaultPromise);
-        }
-    }
-    // Then process all other locales from fileMapping
-    const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
-        // Get all files that are md or mdx
-        const targetFiles = Object.values(filesMap).filter((p) => (p.endsWith('.md') || p.endsWith('.mdx')) &&
-            (!includeFiles || includeFiles.has(p)));
-        // Replace the placeholder path with the target path
-        await Promise.all(targetFiles.map(async (filePath) => {
-            // Check if file exists before processing
-            if (!fs.existsSync(filePath)) {
-                return;
-            }
-            // Get file content
-            const fileContent = await fs.promises.readFile(filePath, 'utf8');
-            // Localize the file
-            const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, locale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
-            // Write the localized file to the target path
-            await fs.promises.writeFile(filePath, localizedFile);
-        }));
-    });
-    processPromises.push(...mappingPromises);
-    await Promise.all(processPromises);
+* Localizes static imports in content files.
+* Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
+* @param settings - The settings object containing the project configuration.
+* @returns void
+*
+* @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
+* it can be enabled by default.
+*
+* Before this becomes a non-experimental feature, we need to:
+* - Support more file types
+* - Support more complex paths
+*/
+async function localizeStaticImports(settings, includeFiles) {
+	if (!settings.files || Object.keys(settings.files.placeholderPaths).length === 1 && settings.files.placeholderPaths.gt) return;
+	const { resolvedPaths: sourceFiles } = settings.files;
+	const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths ?? {}, settings.files.transformFormats ?? {}, settings.locales, settings.defaultLocale);
+	const processPromises = [];
+	if (!fileMapping[settings.defaultLocale] && !includeFiles) {
+		const defaultLocaleFiles = [];
+		if (sourceFiles.md) defaultLocaleFiles.push(...sourceFiles.md);
+		if (sourceFiles.mdx) defaultLocaleFiles.push(...sourceFiles.mdx);
+		if (defaultLocaleFiles.length > 0) {
+			const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
+				if (!fs$1.existsSync(filePath)) return;
+				const localizedFile = localizeStaticImportsForFile(await fs$1.promises.readFile(filePath, "utf8"), settings.defaultLocale, settings.defaultLocale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
+				await fs$1.promises.writeFile(filePath, localizedFile);
+			}));
+			processPromises.push(defaultPromise);
+		}
+	}
+	const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+		const targetFiles = Object.values(filesMap).filter((p) => (p.endsWith(".md") || p.endsWith(".mdx")) && (!includeFiles || includeFiles.has(p)));
+		await Promise.all(targetFiles.map(async (filePath) => {
+			if (!fs$1.existsSync(filePath)) return;
+			const localizedFile = localizeStaticImportsForFile(await fs$1.promises.readFile(filePath, "utf8"), settings.defaultLocale, locale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
+			await fs$1.promises.writeFile(filePath, localizedFile);
+		}));
+	});
+	processPromises.push(...mappingPromises);
+	await Promise.all(processPromises);
 }
 /**
- * Determines if an import path should be processed based on pattern matching
- */
+* Determines if an import path should be processed based on pattern matching
+*/
 function shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale) {
-    const patternWithoutSlash = patternHead.replace(/\/$/, '');
-    if (targetLocale === defaultLocale) {
-        // For default locale processing, check if path contains the pattern
-        return importPath.includes(patternWithoutSlash);
-    }
-    else {
-        // For non-default locales, check if path starts with pattern
-        return importPath.includes(patternWithoutSlash);
-    }
+	const patternWithoutSlash = patternHead.replace(/\/$/, "");
+	if (targetLocale === defaultLocale) return importPath.includes(patternWithoutSlash);
+	else return importPath.includes(patternWithoutSlash);
 }
 /**
- * Checks if an import path should be excluded based on exclusion patterns
- */
+* Checks if an import path should be excluded based on exclusion patterns
+*/
 function isImportPathExcluded(importPath, exclude, defaultLocale) {
-    const excludePatterns = exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale));
-    return excludePatterns.some((pattern) => isMatch(importPath, pattern));
+	return exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale)).some((pattern) => isMatch(importPath, pattern));
 }
 /**
- * Transforms import path for default locale processing
- */
+* Transforms import path for default locale processing
+*/
 function transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale) {
-    if (hideDefaultLocale) {
-        // Remove locale from imports that have it: '/snippets/en/file.mdx' -> '/snippets/file.mdx'
-        if (fullPath.includes(`/${defaultLocale}/`)) {
-            return fullPath.replace(`/${defaultLocale}/`, '/');
-        }
-        else if (fullPath.endsWith(`/${defaultLocale}`)) {
-            return fullPath.replace(`/${defaultLocale}`, '');
-        }
-        return null; // Path doesn't have default locale
-    }
-    else {
-        // Add locale to imports that don't have it: '/snippets/file.mdx' -> '/snippets/en/file.mdx'
-        if (fullPath.includes(`/${defaultLocale}/`) ||
-            fullPath.endsWith(`/${defaultLocale}`)) {
-            return null; // Already has default locale
-        }
-        if (fullPath.startsWith(patternHead)) {
-            const pathAfterHead = fullPath.slice(patternHead.length);
-            if (pathAfterHead) {
-                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
-            }
-            else {
-                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
-            }
-        }
-        return null; // Path doesn't match pattern
-    }
+	if (hideDefaultLocale) {
+		if (fullPath.includes(`/${defaultLocale}/`)) return fullPath.replace(`/${defaultLocale}/`, "/");
+		else if (fullPath.endsWith(`/${defaultLocale}`)) return fullPath.replace(`/${defaultLocale}`, "");
+		return null;
+	} else {
+		if (fullPath.includes(`/${defaultLocale}/`) || fullPath.endsWith(`/${defaultLocale}`)) return null;
+		if (fullPath.startsWith(patternHead)) {
+			const pathAfterHead = fullPath.slice(patternHead.length);
+			if (pathAfterHead) return `${patternHead}${defaultLocale}/${pathAfterHead}`;
+			else return `${patternHead.replace(/\/$/, "")}/${defaultLocale}`;
+		}
+		return null;
+	}
 }
 /**
- * Transforms import path for non-default locale processing with hideDefaultLocale=true
- */
+* Transforms import path for non-default locale processing with hideDefaultLocale=true
+*/
 function transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale) {
-    // Check if already localized
-    if (fullPath.startsWith(`${patternHead}${targetLocale}/`) ||
-        fullPath === `${patternHead}${targetLocale}`) {
-        return null;
-    }
-    // Replace default locale with target locale
-    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
-    if (fullPath.startsWith(`${expectedPathWithDefaultLocale}/`) ||
-        fullPath === expectedPathWithDefaultLocale) {
-        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    // Handle exact pattern match
-    if (fullPath === patternHead.replace(/\/$/, '')) {
-        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
-    }
-    // Add target locale to path without any locale
-    const pathAfterHead = fullPath.slice(patternHead.length);
-    return pathAfterHead
-        ? `${patternHead}${targetLocale}/${pathAfterHead}`
-        : `${patternHead}${targetLocale}`;
+	if (fullPath.startsWith(`${patternHead}${targetLocale}/`) || fullPath === `${patternHead}${targetLocale}`) return null;
+	const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
+	if (fullPath.startsWith(`${expectedPathWithDefaultLocale}/`) || fullPath === expectedPathWithDefaultLocale) return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+	if (fullPath === patternHead.replace(/\/$/, "")) return `${patternHead.replace(/\/$/, "")}/${targetLocale}`;
+	const pathAfterHead = fullPath.slice(patternHead.length);
+	return pathAfterHead ? `${patternHead}${targetLocale}/${pathAfterHead}` : `${patternHead}${targetLocale}`;
 }
 /**
- * Transforms import path for non-default locale processing with hideDefaultLocale=false
- */
+* Transforms import path for non-default locale processing with hideDefaultLocale=false
+*/
 function transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale) {
-    // If already localized to target, skip
-    const expectedPathWithTarget = `${patternHead}${targetLocale}`;
-    if (fullPath.startsWith(`${expectedPathWithTarget}/`) ||
-        fullPath === expectedPathWithTarget) {
-        return null;
-    }
-    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
-    if (fullPath.startsWith(`${expectedPathWithLocale}/`) ||
-        fullPath === expectedPathWithLocale) {
-        // Replace existing default locale with target locale
-        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    else if (fullPath.startsWith(patternHead)) {
-        // Add target locale to path that doesn't have any locale
-        const pathAfterHead = fullPath.slice(patternHead.length);
-        if (pathAfterHead) {
-            return `${patternHead}${targetLocale}/${pathAfterHead}`;
-        }
-        else {
-            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
-        }
-    }
-    return null; // Path doesn't match pattern
+	const expectedPathWithTarget = `${patternHead}${targetLocale}`;
+	if (fullPath.startsWith(`${expectedPathWithTarget}/`) || fullPath === expectedPathWithTarget) return null;
+	const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
+	if (fullPath.startsWith(`${expectedPathWithLocale}/`) || fullPath === expectedPathWithLocale) return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+	else if (fullPath.startsWith(patternHead)) {
+		const pathAfterHead = fullPath.slice(patternHead.length);
+		if (pathAfterHead) return `${patternHead}${targetLocale}/${pathAfterHead}`;
+		else return `${patternHead.replace(/\/$/, "")}/${targetLocale}`;
+	}
+	return null;
 }
 /**
- * Main import path transformation function that delegates to specific scenarios
- */
-function transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, projectRoot = process.cwd(), // fallback if not provided
-rewrites) {
-    // Apply explicit rewrites first (e.g., Docusaurus @site/docs -> @site/i18n/[locale]/...)
-    if (rewrites && rewrites.length > 0) {
-        const localeMap = {
-            '[locale]': targetLocale,
-            '[defaultLocale]': defaultLocale,
-        };
-        for (const { match, replace } of rewrites) {
-            const resolvedMatch = match.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
-            if (fullPath.startsWith(resolvedMatch)) {
-                const remainder = fullPath.slice(resolvedMatch.length);
-                const resolvedReplace = replace.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
-                let newPath;
-                if (resolvedReplace.endsWith('/')) {
-                    newPath = `${resolvedReplace}${remainder.replace(/^\//, '')}`;
-                }
-                else if (remainder.startsWith('/')) {
-                    newPath = `${resolvedReplace}${remainder}`;
-                }
-                else {
-                    newPath = `${resolvedReplace}/${remainder}`;
-                }
-                return newPath;
-            }
-        }
-    }
-    let newPath;
-    if (targetLocale === defaultLocale) {
-        newPath = transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale);
-    }
-    else if (hideDefaultLocale) {
-        newPath = transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale);
-    }
-    else {
-        newPath = transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale);
-    }
-    if (!newPath)
-        return null;
-    if (currentFilePath) {
-        let resolvedPath;
-        if (newPath.startsWith('/')) {
-            // Interpret as project-root relative
-            resolvedPath = path.join(projectRoot, newPath.replace(/^\//, ''));
-        }
-        else {
-            // Relative to current file
-            const currentDir = path.dirname(currentFilePath);
-            resolvedPath = path.resolve(currentDir, newPath);
-        }
-        if (!fs.existsSync(resolvedPath)) {
-            return null;
-        }
-    }
-    return newPath;
+* Main import path transformation function that delegates to specific scenarios
+*/
+function transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, projectRoot = process.cwd(), rewrites) {
+	if (rewrites && rewrites.length > 0) {
+		const localeMap = {
+			"[locale]": targetLocale,
+			"[defaultLocale]": defaultLocale
+		};
+		for (const { match, replace } of rewrites) {
+			const resolvedMatch = match.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
+			if (fullPath.startsWith(resolvedMatch)) {
+				const remainder = fullPath.slice(resolvedMatch.length);
+				const resolvedReplace = replace.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
+				let newPath;
+				if (resolvedReplace.endsWith("/")) newPath = `${resolvedReplace}${remainder.replace(/^\//, "")}`;
+				else if (remainder.startsWith("/")) newPath = `${resolvedReplace}${remainder}`;
+				else newPath = `${resolvedReplace}/${remainder}`;
+				return newPath;
+			}
+		}
+	}
+	let newPath;
+	if (targetLocale === defaultLocale) newPath = transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale);
+	else if (hideDefaultLocale) newPath = transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale);
+	else newPath = transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale);
+	if (!newPath) return null;
+	if (currentFilePath) {
+		let resolvedPath;
+		if (newPath.startsWith("/")) resolvedPath = path$1.join(projectRoot, newPath.replace(/^\//, ""));
+		else {
+			const currentDir = path$1.dirname(currentFilePath);
+			resolvedPath = path$1.resolve(currentDir, newPath);
+		}
+		if (!fs$1.existsSync(resolvedPath)) return null;
+	}
+	return newPath;
 }
 /**
- * AST-based transformation for MDX files using remark-mdx
- */
-function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], currentFilePath, options) {
-    const transformedImports = [];
-    // Don't auto-prefix relative patterns that start with . or ..
-    if (!pattern.startsWith('/') && !pattern.startsWith('.')) {
-        pattern = '/' + pattern;
-    }
-    const patternHead = pattern.split('[locale]')[0];
-    // Quick check: if the file doesn't contain the pattern, skip expensive AST parsing
-    // For default locale processing, we also need to check if content might need adjustment
-    if (targetLocale === defaultLocale) {
-        // For default locale files, we always need to check as we're looking for either:
-        // - paths without locale (when hideDefaultLocale=false)
-        // - paths with default locale (when hideDefaultLocale=true)
-        const patternWithoutSlash = patternHead.replace(/\/$/, '');
-        if (!mdxContent.includes(patternWithoutSlash)) {
-            return {
-                content: mdxContent,
-                hasChanges: false,
-                transformedImports: [],
-            };
-        }
-    }
-    else {
-        // For non-default locales, use the original logic
-        if (!mdxContent.includes(patternHead.replace(/\/$/, ''))) {
-            return {
-                content: mdxContent,
-                hasChanges: false,
-                transformedImports: [],
-            };
-        }
-    }
-    // Parse the MDX content into an AST
-    let processedAst;
-    try {
-        const parseProcessor = unified()
-            .use(remarkParse)
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        const ast = parseProcessor.parse(mdxContent);
-        processedAst = parseProcessor.runSync(ast);
-    }
-    catch {
-        return transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options);
-    }
-    let content = mdxContent;
-    // Visit only mdxjsEsm nodes (import/export statements) to collect replacements
-    visit(processedAst, 'mdxjsEsm', (node) => {
-        if (node.value && node.value.includes(patternHead.replace(/\/$/, ''))) {
-            // Find import lines that need transformation
-            const lines = node.value.split('\n');
-            lines.forEach((line) => {
-                // Only process import lines that match our pattern
-                if (!line.trim().startsWith('import ')) {
-                    return;
-                }
-                // Check if this line should be processed
-                if (!shouldProcessImportPath(line, patternHead, targetLocale, defaultLocale)) {
-                    return;
-                }
-                // Extract the path from the import statement
-                const quotes = ['"', "'", '`'];
-                for (const quote of quotes) {
-                    // Try both with and without trailing slash
-                    let startPattern = `${quote}${patternHead}`;
-                    let startIndex = line.indexOf(startPattern);
-                    // If pattern has trailing slash but path doesn't, try without slash
-                    if (startIndex === -1 && patternHead.endsWith('/')) {
-                        const patternWithoutSlash = patternHead.slice(0, -1);
-                        startPattern = `${quote}${patternWithoutSlash}`;
-                        startIndex = line.indexOf(startPattern);
-                    }
-                    if (startIndex === -1)
-                        continue;
-                    const pathStart = startIndex + 1; // After the quote
-                    const pathEnd = line.indexOf(quote, pathStart);
-                    if (pathEnd === -1)
-                        continue;
-                    const fullPath = line.slice(pathStart, pathEnd);
-                    // Transform the import path
-                    const newPath = transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
-                    if (!newPath) {
-                        continue; // No transformation needed
-                    }
-                    // Check exclusions
-                    if (isImportPathExcluded(fullPath, exclude, defaultLocale)) {
-                        continue;
-                    }
-                    // Apply the transformation to the original content
-                    // Simply replace the import path with the new path
-                    content = content.replace(`${quote}${fullPath}${quote}`, `${quote}${newPath}${quote}`);
-                    transformedImports.push({ originalPath: fullPath, newPath });
-                    break;
-                }
-            });
-        }
-    });
-    return {
-        content,
-        hasChanges: transformedImports.length > 0,
-        transformedImports,
-    };
+* AST-based transformation for MDX files using remark-mdx
+*/
+function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = "/[locale]", exclude = [], currentFilePath, options) {
+	const transformedImports = [];
+	if (!pattern.startsWith("/") && !pattern.startsWith(".")) pattern = "/" + pattern;
+	const patternHead = pattern.split("[locale]")[0];
+	if (targetLocale === defaultLocale) {
+		const patternWithoutSlash = patternHead.replace(/\/$/, "");
+		if (!mdxContent.includes(patternWithoutSlash)) return {
+			content: mdxContent,
+			hasChanges: false,
+			transformedImports: []
+		};
+	} else if (!mdxContent.includes(patternHead.replace(/\/$/, ""))) return {
+		content: mdxContent,
+		hasChanges: false,
+		transformedImports: []
+	};
+	let processedAst;
+	try {
+		const parseProcessor = unified().use(remarkParse).use(remarkFrontmatter, ["yaml", "toml"]).use(remarkMdx);
+		const ast = parseProcessor.parse(mdxContent);
+		processedAst = parseProcessor.runSync(ast);
+	} catch {
+		return transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options);
+	}
+	let content = mdxContent;
+	visit(processedAst, "mdxjsEsm", (node) => {
+		if (node.value && node.value.includes(patternHead.replace(/\/$/, ""))) node.value.split("\n").forEach((line) => {
+			if (!line.trim().startsWith("import ")) return;
+			if (!shouldProcessImportPath(line, patternHead, targetLocale, defaultLocale)) return;
+			for (const quote of [
+				"\"",
+				"'",
+				"`"
+			]) {
+				let startPattern = `${quote}${patternHead}`;
+				let startIndex = line.indexOf(startPattern);
+				if (startIndex === -1 && patternHead.endsWith("/")) {
+					startPattern = `${quote}${patternHead.slice(0, -1)}`;
+					startIndex = line.indexOf(startPattern);
+				}
+				if (startIndex === -1) continue;
+				const pathStart = startIndex + 1;
+				const pathEnd = line.indexOf(quote, pathStart);
+				if (pathEnd === -1) continue;
+				const fullPath = line.slice(pathStart, pathEnd);
+				const newPath = transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
+				if (!newPath) continue;
+				if (isImportPathExcluded(fullPath, exclude, defaultLocale)) continue;
+				content = content.replace(`${quote}${fullPath}${quote}`, `${quote}${newPath}${quote}`);
+				transformedImports.push({
+					originalPath: fullPath,
+					newPath
+				});
+				break;
+			}
+		});
+	});
+	return {
+		content,
+		hasChanges: transformedImports.length > 0,
+		transformedImports
+	};
 }
 /**
- * String-based fallback for import localization when MDX parsing fails (e.g., on .md files)
- */
-function transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], currentFilePath, options) {
-    const transformedImports = [];
-    if (!pattern.startsWith('/') && !pattern.startsWith('.')) {
-        pattern = '/' + pattern;
-    }
-    const patternHead = pattern.split('[locale]')[0];
-    let content = mdxContent;
-    const importRegex = /import\s+[^'"]*['"]([^'"]+)['"]\s*;?/g;
-    let match;
-    while ((match = importRegex.exec(mdxContent)) !== null) {
-        const fullMatch = match[0];
-        const importPath = match[1];
-        if (!shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale)) {
-            continue;
-        }
-        if (isImportPathExcluded(importPath, exclude, defaultLocale)) {
-            continue;
-        }
-        const newPath = transformImportPath(importPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
-        if (!newPath)
-            continue;
-        const updatedImport = fullMatch.replace(importPath, newPath);
-        content = content.replace(fullMatch, updatedImport);
-        transformedImports.push({ originalPath: importPath, newPath });
-    }
-    return {
-        content,
-        hasChanges: transformedImports.length > 0,
-        transformedImports,
-    };
+* String-based fallback for import localization when MDX parsing fails (e.g., on .md files)
+*/
+function transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = "/[locale]", exclude = [], currentFilePath, options) {
+	const transformedImports = [];
+	if (!pattern.startsWith("/") && !pattern.startsWith(".")) pattern = "/" + pattern;
+	const patternHead = pattern.split("[locale]")[0];
+	let content = mdxContent;
+	const importRegex = /import\s+[^'"]*['"]([^'"]+)['"]\s*;?/g;
+	let match;
+	while ((match = importRegex.exec(mdxContent)) !== null) {
+		const fullMatch = match[0];
+		const importPath = match[1];
+		if (!shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale)) continue;
+		if (isImportPathExcluded(importPath, exclude, defaultLocale)) continue;
+		const newPath = transformImportPath(importPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
+		if (!newPath) continue;
+		const updatedImport = fullMatch.replace(importPath, newPath);
+		content = content.replace(fullMatch, updatedImport);
+		transformedImports.push({
+			originalPath: importPath,
+			newPath
+		});
+	}
+	return {
+		content,
+		hasChanges: transformedImports.length > 0,
+		transformedImports
+	};
 }
 /**
- * AST-based transformation for MDX files only
- */
-function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = [], currentFilePath, options) {
-    // For MDX files, use AST-based transformation
-    const result = transformMdxImports(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options);
-    return result.content;
+* AST-based transformation for MDX files only
+*/
+function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = "/[locale]", exclude = [], currentFilePath, options) {
+	return transformMdxImports(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options).content;
 }
+//#endregion
+export { localizeStaticImports as default };
+
+//# sourceMappingURL=localizeStaticImports.js.map