@lingui/cli 5.9.3 → 6.0.0-next.1

package/dist/api/workerLogger.js

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerLogger = void 0;
-class WorkerLogger {
-    constructor() {
-        this.errors = [];
-    }
+export class WorkerLogger {
+    errors = [];
     error(msg) {
         this.errors.push(msg);
     }
@@ -16,4 +11,3 @@ class WorkerLogger {
         };
     }
 }
-exports.WorkerLogger = WorkerLogger;

package/dist/api/workerPools.d.ts

@@ -0,0 +1,3 @@
+import { WorkerPool } from "./typedPool.js";
+import type { ExtractWorkerFunction } from "../workers/extractWorker.js";
+export type ExtractWorkerPool = WorkerPool<ExtractWorkerFunction>;

package/dist/api/workerPools.js

@@ -0,0 +1,7 @@
+import { createWorkerPool } from "./typedPool.js";
+/** @internal */
+export const createExtractWorkerPool = (opts) => createWorkerPool("../workers/extractWorkerWrapper", import.meta.url, opts.poolSize);
+/** @internal */
+export const createExtractExperimentalWorkerPool = (opts) => createWorkerPool("../extract-experimental/workers/extractWorkerWrapper", import.meta.url, opts.poolSize);
+/** @internal */
+export const createCompileWorkerPool = (opts) => createWorkerPool("../workers/compileWorkerWrapper", import.meta.url, opts.poolSize);

package/dist/extract-experimental/buildIncludeDepsFilter.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildIncludeDepsFilter = buildIncludeDepsFilter;
 function createPackageRegExp(packageName) {
     return new RegExp("^" + packageName + "(?:\\/.+)?");
 }
-function buildIncludeDepsFilter(includeDeps) {
+export function buildIncludeDepsFilter(includeDeps) {
     const include = includeDeps.map(createPackageRegExp);
     return (id) => include.some((regExp) => regExp.test(id));
 }

package/dist/extract-experimental/bundleSource.d.ts

@@ -1,2 +1,3 @@
-import { LinguiConfigNormalized } from "@lingui/conf";
-export declare function bundleSource(linguiConfig: LinguiConfigNormalized, entryPoints: string[], outDir: string, rootDir: string): Promise<import("esbuild").BuildResult<any>>;
+import { ExperimentalExtractorOptions, LinguiConfigNormalized } from "@lingui/conf";
+import { Metafile } from "esbuild";
+export declare function bundleSource(linguiConfig: LinguiConfigNormalized, extractorConfig: ExperimentalExtractorOptions, entryPoints: string[], outDir: string, rootDir: string): Promise<Metafile>;

package/dist/extract-experimental/bundleSource.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundleSource = bundleSource;
-const linguiEsbuildPlugin_1 = require("./linguiEsbuildPlugin");
-const buildIncludeDepsFilter_1 = require("./buildIncludeDepsFilter");
+import { pluginLinguiMacro } from "./linguiEsbuildPlugin.js";
+import { buildIncludeDepsFilter } from "./buildIncludeDepsFilter.js";
 function createExtRegExp(extensions) {
     return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
 }
-async function bundleSource(linguiConfig, entryPoints, outDir, rootDir) {
+export async function bundleSource(linguiConfig, extractorConfig, entryPoints, outDir, rootDir) {
     const esbuild = await import("esbuild");
-    const config = linguiConfig.experimental.extractor;
-    const excludeExtensions = config.excludeExtensions || [
+    const excludeExtensions = extractorConfig.excludeExtensions || [
         "ico",
         "pot",
         "xliff",
@@ -44,16 +40,16 @@ async function bundleSource(linguiConfig, entryPoints, outDir, rootDir) {
         sourcesContent: false,
         metafile: true,
         plugins: [
-            (0, linguiEsbuildPlugin_1.pluginLinguiMacro)({ linguiConfig }),
+            pluginLinguiMacro({ linguiConfig }),
             {
                 name: "externalize-deps",
                 setup(build) {
-                    const shouldInclude = (0, buildIncludeDepsFilter_1.buildIncludeDepsFilter)(config.includeDeps || []);
+                    const shouldInclude = buildIncludeDepsFilter(extractorConfig.includeDeps || []);
                     // considers all import paths that "look like" package imports in the original source code to be package imports.
                     // Specifically import paths that don't start with a path segment of / or . or .. are considered to be package imports.
                     // The only two exceptions to this rule are subpath imports (which start with a # character) and deps specified in the `includeDeps`
                     build.onResolve({ filter: /^[^.#/].*/ }, async (args) => {
-                        if (shouldInclude(args.path)) {
+                        if (shouldInclude(args.path) || args.kind === "entry-point") {
                             return { external: false };
                         }
                         return {
@@ -72,7 +68,8 @@ async function bundleSource(linguiConfig, entryPoints, outDir, rootDir) {
             },
         ],
     };
-    return await esbuild.build(config.resolveEsbuildOptions
-        ? config.resolveEsbuildOptions(esbuildOptions)
+    const bundleResult = await esbuild.build(extractorConfig.resolveEsbuildOptions
+        ? extractorConfig.resolveEsbuildOptions(esbuildOptions)
         : esbuildOptions);
+    return bundleResult.metafile;
 }

package/dist/extract-experimental/constants.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TEMPLATE_NAME = exports.ENTRY_NAME_PH = void 0;
-exports.ENTRY_NAME_PH = "{entryName}";
-exports.DEFAULT_TEMPLATE_NAME = "messages";
+export const ENTRY_NAME_PH = "{entryName}";
+export const DEFAULT_TEMPLATE_NAME = "messages";

package/dist/extract-experimental/extractFromBundleAndWrite.d.ts

@@ -1,5 +1,5 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { FormatterWrapper } from "../api/formats";
+import { FormatterWrapper } from "../api/formats/index.js";
 export declare function extractFromBundleAndWrite(params: {
     entryPoint: string;
     bundleFile: string;
@@ -11,9 +11,8 @@ export declare function extractFromBundleAndWrite(params: {
     clean: boolean;
     overwrite: boolean;
 }): Promise<{
-    success: boolean;
-    stat?: undefined;
+    success: false;
 } | {
-    success: boolean;
+    success: true;
     stat: string;
 }>;

package/dist/extract-experimental/extractFromBundleAndWrite.js

@@ -1,26 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFromBundleAndWrite = extractFromBundleAndWrite;
-const extractFromFiles_1 = require("../api/catalog/extractFromFiles");
-const writeCatalogs_1 = require("./writeCatalogs");
-const promises_1 = __importDefault(require("fs/promises"));
-const babel_1 = require("../api/extractors/babel");
+import { mergeExtractedMessage } from "../api/catalog/extractFromFiles.js";
+import { writeCatalogs, writeTemplate } from "./writeCatalogs.js";
+import extract from "../api/extractors/index.js";
 async function extractFromBundle(filename, linguiConfig) {
     const messages = {};
     let success;
     try {
-        const file = await promises_1.default.readFile(filename);
-        const parserOptions = linguiConfig.extractorParserOptions;
-        await (0, babel_1.extractFromFileWithBabel)(filename, file.toString(), (msg) => {
-            (0, extractFromFiles_1.mergeExtractedMessage)(msg, messages, linguiConfig);
-        }, {
-            linguiConfig,
-        }, {
-            plugins: (0, babel_1.getBabelParserOptions)(filename, parserOptions),
-        }, true);
+        await extract(filename, (msg) => {
+            mergeExtractedMessage(msg, messages, linguiConfig);
+        }, linguiConfig);
         success = true;
     }
     catch (e) {
@@ -30,7 +17,7 @@ async function extractFromBundle(filename, linguiConfig) {
     }
     return { success, messages };
 }
-async function extractFromBundleAndWrite(params) {
+export async function extractFromBundleAndWrite(params) {
     const { linguiConfig, entryPoint, format, outputPattern, locales, overwrite, clean, template, } = params;
     const { messages, success } = await extractFromBundle(params.bundleFile, params.linguiConfig);
     if (!success) {
@@ -38,7 +25,7 @@ async function extractFromBundleAndWrite(params) {
     }
     let stat;
     if (template) {
-        stat = (await (0, writeCatalogs_1.writeTemplate)({
+        stat = (await writeTemplate({
             linguiConfig,
             clean,
             format,
@@ -48,7 +35,7 @@ async function extractFromBundleAndWrite(params) {
         })).statMessage;
     }
     else {
-        stat = (await (0, writeCatalogs_1.writeCatalogs)({
+        stat = (await writeCatalogs({
             locales,
             linguiConfig,
             clean,

package/dist/extract-experimental/getExperimentalCatalogs.d.ts

@@ -1,3 +1,4 @@
-import { LinguiConfigNormalized } from "@lingui/conf";
-import { Catalog } from "../api/catalog";
-export declare function getExperimentalCatalogs(linguiConfig: LinguiConfigNormalized): Promise<Catalog[]>;
+import { ExperimentalExtractorOptions, LinguiConfigNormalized } from "@lingui/conf";
+import { Catalog } from "../api/catalog.js";
+import { FormatterWrapper } from "../api/formats/index.js";
+export declare function getExperimentalCatalogs(linguiConfig: LinguiConfigNormalized, format: FormatterWrapper, extractorConfig: ExperimentalExtractorOptions): Promise<Catalog[]>;

package/dist/extract-experimental/getExperimentalCatalogs.js

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExperimentalCatalogs = getExperimentalCatalogs;
-const getEntryPoints_1 = require("./getEntryPoints");
-const resolveCatalogPath_1 = require("./resolveCatalogPath");
-const catalog_1 = require("../api/catalog");
-const resolveTemplatePath_1 = require("./resolveTemplatePath");
-const formats_1 = require("../api/formats");
-async function getExperimentalCatalogs(linguiConfig) {
-    const config = linguiConfig.experimental.extractor;
-    const entryPoints = (0, getEntryPoints_1.getEntryPoints)(config.entries);
-    const format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+import { globSync } from "node:fs";
+import { resolveCatalogPath } from "./resolveCatalogPath.js";
+import { Catalog } from "../api/catalog.js";
+import { resolveTemplatePath } from "./resolveTemplatePath.js";
+export async function getExperimentalCatalogs(linguiConfig, format, extractorConfig) {
+    const config = extractorConfig;
+    const entryPoints = globSync(config.entries);
     return entryPoints.map((entryPoint) => {
-        const catalogPath = (0, resolveCatalogPath_1.resolveCatalogPath)(config.output, entryPoint, linguiConfig.rootDir, undefined, "");
-        const templatePath = (0, resolveTemplatePath_1.resolveTemplatePath)(entryPoint, config.output, linguiConfig.rootDir, format.getTemplateExtension());
-        return new catalog_1.Catalog({
+        const catalogPath = resolveCatalogPath(config.output, entryPoint, linguiConfig.rootDir, undefined, "");
+        const templatePath = resolveTemplatePath(entryPoint, config.output, linguiConfig.rootDir, format.getTemplateExtension());
+        return new Catalog({
             name: undefined,
             path: catalogPath,
             templatePath,

package/dist/extract-experimental/linguiEsbuildPlugin.js

@@ -1,36 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginLinguiMacro = void 0;
-const core_1 = require("@babel/core");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const babel_1 = require("../api/extractors/babel");
-const babel_plugin_lingui_macro_1 = __importDefault(require("@lingui/babel-plugin-lingui-macro"));
-const pluginLinguiMacro = (options) => ({
+import { transformAsync } from "@babel/core";
+import fs from "fs";
+import path from "path";
+import { babelRe, getBabelParserOptions } from "../api/extractors/babel.js";
+import linguiMacroPlugin from "@lingui/babel-plugin-lingui-macro";
+export const pluginLinguiMacro = (options) => ({
     name: "linguiMacro",
     setup(build) {
-        build.onLoad({ filter: babel_1.babelRe, namespace: "" }, async (args) => {
-            const filename = path_1.default.relative(process.cwd(), args.path);
-            const contents = await fs_1.default.promises.readFile(args.path, "utf8");
+        build.onLoad({ filter: babelRe, namespace: "" }, async (args) => {
+            const filename = path.relative(process.cwd(), args.path);
+            const contents = await fs.promises.readFile(args.path, "utf8");
             const hasMacroRe = /from ["']@lingui(\/.+)?\/macro["']/g;
             if (!hasMacroRe.test(contents)) {
                 // let esbuild process file as usual
                 return undefined;
             }
-            const result = await (0, core_1.transformAsync)(contents, {
+            const result = await transformAsync(contents, {
                 babelrc: false,
                 configFile: false,
                 filename: filename,
                 sourceMaps: "inline",
                 parserOpts: {
-                    plugins: (0, babel_1.getBabelParserOptions)(filename, options.linguiConfig.extractorParserOptions),
+                    plugins: getBabelParserOptions(filename, {}),
                 },
                 plugins: [
                     [
-                        babel_plugin_lingui_macro_1.default,
+                        linguiMacroPlugin,
                         {
                             extract: true,
                             linguiConfig: options.linguiConfig,
@@ -42,4 +36,3 @@ const pluginLinguiMacro = (options) => ({
         });
     },
 });
-exports.pluginLinguiMacro = pluginLinguiMacro;

package/dist/extract-experimental/resolveCatalogPath.d.ts

@@ -1,2 +1,2 @@
-export declare function resolveCatalogPath(configOutput: string, entryPath: string, rootDir: string, locale: string, extension: string): string;
+export declare function resolveCatalogPath(configOutput: string, entryPath: string, rootDir: string, locale: string | undefined, extension: string): string;
 export declare function getEntryName(entryPath: string): string;

package/dist/extract-experimental/resolveCatalogPath.js

@@ -1,22 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveCatalogPath = resolveCatalogPath;
-exports.getEntryName = getEntryName;
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("../api/utils");
-function resolveCatalogPath(configOutput, entryPath, rootDir, locale, extension) {
+import nodepath from "path";
+import { replacePlaceholders } from "../api/utils.js";
+export function resolveCatalogPath(configOutput, entryPath, rootDir, locale, extension) {
     const entryName = getEntryName(entryPath);
-    const entryDir = path_1.default.relative(rootDir, path_1.default.dirname(entryPath));
-    return path_1.default.normalize((0, utils_1.replacePlaceholders)(configOutput, {
+    const entryDir = nodepath.relative(rootDir, nodepath.dirname(entryPath));
+    return nodepath.normalize(replacePlaceholders(configOutput, {
         entryName,
         entryDir,
         locale,
     }) + extension);
 }
-function getEntryName(entryPath) {
-    const parsedPath = path_1.default.parse(entryPath);
+export function getEntryName(entryPath) {
+    const parsedPath = nodepath.parse(entryPath);
     return parsedPath.name.replace(parsedPath.ext, "");
 }

package/dist/extract-experimental/resolveTemplatePath.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTemplatePath = resolveTemplatePath;
-const resolveCatalogPath_1 = require("./resolveCatalogPath");
-const constants_1 = require("./constants");
-function resolveTemplatePath(entryPoint, output, rootDir, catalogExtension) {
+import { resolveCatalogPath, getEntryName } from "./resolveCatalogPath.js";
+import { DEFAULT_TEMPLATE_NAME, ENTRY_NAME_PH } from "./constants.js";
+export function resolveTemplatePath(entryPoint, output, rootDir, catalogExtension) {
     let templateName;
-    if (output.includes(constants_1.ENTRY_NAME_PH)) {
-        templateName = constants_1.DEFAULT_TEMPLATE_NAME;
+    if (output.includes(ENTRY_NAME_PH)) {
+        templateName = DEFAULT_TEMPLATE_NAME;
     }
     else {
-        templateName = (0, resolveCatalogPath_1.getEntryName)(entryPoint);
+        templateName = getEntryName(entryPoint);
     }
-    return (0, resolveCatalogPath_1.resolveCatalogPath)(output, entryPoint, rootDir, templateName, catalogExtension);
+    return resolveCatalogPath(output, entryPoint, rootDir, templateName, catalogExtension);
 }

package/dist/extract-experimental/workers/extractWorker.d.ts

@@ -1,6 +1,8 @@
 export type ExtractWorkerFunction = typeof extractWorker;
 declare const extractWorker: (linguiConfigPath: string, entryPoint: string, bundleFile: string, outputPattern: string, template: boolean, locales: string[], clean: boolean, overwrite: boolean) => Promise<{
-    success: boolean;
-    stat?: string;
+    success: false;
+} | {
+    success: true;
+    stat: string;
 }>;
-export {};
+export { extractWorker };

package/dist/extract-experimental/workers/extractWorker.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const worker_1 = require("threads/worker");
-const conf_1 = require("@lingui/conf");
-const extractFromBundleAndWrite_1 = require("../extractFromBundleAndWrite");
-const formats_1 = require("../../api/formats");
+import { getConfig } from "@lingui/conf";
+import { extractFromBundleAndWrite } from "../extractFromBundleAndWrite.js";
+import { getFormat } from "../../api/formats/index.js";
 let linguiConfig;
 let format;
 const extractWorker = async (linguiConfigPath, entryPoint, bundleFile, outputPattern, template, locales, clean, overwrite) => {
     if (!linguiConfig) {
         // initialize config once per worker, speed up workers follow execution
-        linguiConfig = (0, conf_1.getConfig)({
+        linguiConfig = getConfig({
             configPath: linguiConfigPath,
             skipValidation: true,
         });
     }
     if (!format) {
-        format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+        format = await getFormat(linguiConfig.format, linguiConfig.sourceLocale);
     }
-    return await (0, extractFromBundleAndWrite_1.extractFromBundleAndWrite)({
+    return await extractFromBundleAndWrite({
         entryPoint,
         bundleFile,
         outputPattern,
@@ -29,4 +26,4 @@ const extractWorker = async (linguiConfigPath, entryPoint, bundleFile, outputPat
         template,
     });
 };
-(0, worker_1.expose)(extractWorker);
+export { extractWorker };

package/dist/extract-experimental/workers/extractWorkerWrapper.prod.d.ts

@@ -0,0 +1,8 @@
+import { extractWorker } from "./extractWorker.js";
+declare const _default: (args: Parameters<typeof extractWorker>) => Promise<{
+    success: false;
+} | {
+    success: true;
+    stat: string;
+}>;
+export default _default;

package/dist/extract-experimental/workers/extractWorkerWrapper.prod.js

@@ -0,0 +1,2 @@
+import { extractWorker } from "./extractWorker.js";
+export default (args) => extractWorker(...args);

package/dist/extract-experimental/writeCatalogs.d.ts

@@ -1,6 +1,6 @@
-import { ExtractedCatalogType } from "../api";
+import { ExtractedCatalogType } from "../api/index.js";
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { FormatterWrapper } from "../api/formats";
+import { FormatterWrapper } from "../api/formats/index.js";
 type ExtractTemplateParams = {
     format: FormatterWrapper;
     clean: boolean;

package/dist/extract-experimental/writeCatalogs.js

@@ -1,40 +1,33 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeCatalogs = writeCatalogs;
-exports.writeTemplate = writeTemplate;
-const resolveTemplatePath_1 = require("./resolveTemplatePath");
-const picocolors_1 = __importDefault(require("picocolors"));
-const resolveCatalogPath_1 = require("./resolveCatalogPath");
-const mergeCatalog_1 = require("../api/catalog/mergeCatalog");
-const stats_1 = require("../api/stats");
-const catalog_1 = require("../api/catalog");
+import { resolveTemplatePath } from "./resolveTemplatePath.js";
+import { styleText } from "node:util";
+import { resolveCatalogPath } from "./resolveCatalogPath.js";
+import { mergeCatalog } from "../api/catalog/mergeCatalog.js";
+import { printStats } from "../api/stats.js";
+import { cleanObsolete, order } from "../api/catalog.js";
 function cleanAndSort(catalog, clean, orderBy) {
     if (clean) {
-        catalog = (0, catalog_1.cleanObsolete)(catalog);
+        catalog = cleanObsolete(catalog);
     }
-    return (0, catalog_1.order)(orderBy, catalog);
+    return order(orderBy, catalog);
 }
-async function writeCatalogs(params) {
+export async function writeCatalogs(params) {
     const { entryPoint, outputPattern, linguiConfig, locales, overwrite, format, clean, messages, } = params;
     const stat = {};
     for (const locale of locales) {
-        const catalogOutput = (0, resolveCatalogPath_1.resolveCatalogPath)(outputPattern, entryPoint, linguiConfig.rootDir, locale, format.getCatalogExtension());
-        const catalog = (0, mergeCatalog_1.mergeCatalog)(await format.read(catalogOutput, locale), messages, locale === linguiConfig.sourceLocale, { overwrite });
+        const catalogOutput = resolveCatalogPath(outputPattern, entryPoint, linguiConfig.rootDir, locale, format.getCatalogExtension());
+        const catalog = mergeCatalog(await format.read(catalogOutput, locale), messages, locale === linguiConfig.sourceLocale, { overwrite });
         await format.write(catalogOutput, cleanAndSort(catalog, clean, linguiConfig.orderBy), locale);
         stat[locale] = catalog;
     }
     return {
-        statMessage: (0, stats_1.printStats)(linguiConfig, stat).toString(),
+        statMessage: printStats(linguiConfig, stat).toString(),
     };
 }
-async function writeTemplate(params) {
+export async function writeTemplate(params) {
     const { entryPoint, outputPattern, linguiConfig, format, clean, messages } = params;
-    const catalogOutput = (0, resolveTemplatePath_1.resolveTemplatePath)(entryPoint, outputPattern, linguiConfig.rootDir, format.getTemplateExtension());
+    const catalogOutput = resolveTemplatePath(entryPoint, outputPattern, linguiConfig.rootDir, format.getTemplateExtension());
     await format.write(catalogOutput, cleanAndSort(messages, clean, linguiConfig.orderBy), undefined);
     return {
-        statMessage: `${picocolors_1.default.bold(Object.keys(messages).length)} message(s) extracted`,
+        statMessage: `${styleText("bold", String(Object.keys(messages).length))} message(s) extracted`,
     };
 }

package/dist/index.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineConfig = void 0;
-var conf_1 = require("@lingui/conf");
-Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return conf_1.defineConfig; } });
+export { defineConfig } from "@lingui/conf";

package/dist/lingui-compile.d.ts

@@ -1,5 +1,5 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { WorkersOptions } from "./api/resolveWorkersOptions";
+import { WorkersOptions } from "./api/resolveWorkersOptions.js";
 export type CliCompileOptions = {
     verbose?: boolean;
     allowEmpty?: boolean;