next-intl 4.11.2 → 4.12.0

package/dist/cjs/development/{plugin-0S9vVrVM.cjs → plugin-DlFYUFWh.cjs}

@@ -39,6 +39,73 @@ function once(namespace) {
   };
 }
 
+function stripTrailingSlash(dirPath) {
+  if (dirPath.endsWith('/')) {
+    return dirPath.slice(0, -1);
+  } else {
+    return dirPath;
+  }
+}
+function normalizeMessagesCatalogPaths(messagesPath) {
+  const rawPaths = Array.isArray(messagesPath) ? messagesPath : [messagesPath];
+  return rawPaths.map(dirPath => stripTrailingSlash(String(dirPath).trim())).filter(dirPath => dirPath.length > 0);
+}
+function normalizeExtractorConfig(input) {
+  if (input.messages == null) {
+    throwError('`messages` is required when extracting messages.');
+  }
+  const extract = input.extract;
+  let extractPath;
+  let sourceLocale;
+  if (extract !== undefined && extract !== true) {
+    if (extract.sourceLocale) {
+      warn('`extract.sourceLocale` is deprecated in favor of `messages.sourceLocale`.');
+      sourceLocale = extract.sourceLocale;
+    }
+    if (extract.path) {
+      extractPath = stripTrailingSlash(extract.path);
+    }
+  }
+  const locales = input.messages.locales;
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (!locales) {
+    throwError('`messages.locales` is required when extracting messages.');
+  }
+  if (input.messages.sourceLocale) {
+    sourceLocale = input.messages.sourceLocale;
+  }
+  if (!sourceLocale) {
+    throwError('`messages.sourceLocale` is required when extracting messages.');
+  }
+  const srcPath = input.srcPath;
+  if (srcPath == null) {
+    throwError('`srcPath` is required when extracting messages.');
+  }
+  const pathIsArray = Array.isArray(input.messages.path);
+  const messagesPath = normalizeMessagesCatalogPaths(input.messages.path);
+  if (messagesPath.length === 0) {
+    throwError('`messages.path` must not be empty.');
+  }
+  if (extractPath == null) {
+    if (pathIsArray) {
+      throwError('When `messages.path` is an array, `extract.path` is required to select the writable catalog directory.');
+    }
+    extractPath = messagesPath[0];
+  }
+  return {
+    extract: {
+      locales,
+      path: extractPath,
+      sourceLocale,
+      srcPath
+    },
+    messages: {
+      format: input.messages.format,
+      path: messagesPath
+    }
+  };
+}
+
 /**
  * Wrapper around `fs.watch` that provides a workaround
  * for https://github.com/nodejs/node/issues/5039.
@@ -122,11 +189,11 @@ export default messages;`;
 
 const formats = {
   json: {
-    codec: () => Promise.resolve().then(function () { return require('./JSONCodec-B-lAnRTg.cjs'); }),
+    codec: () => Promise.resolve().then(function () { return require('./JSONCodec-CzA8ubPy.cjs'); }),
     extension: '.json'
   },
   po: {
-    codec: () => Promise.resolve().then(function () { return require('./POCodec-0XdsL-1F.cjs'); }),
+    codec: () => Promise.resolve().then(function () { return require('./POCodec-CWGHK-Gp.cjs'); }),
     extension: '.po'
   }
 };
@@ -231,7 +298,7 @@ class SourceFileWatcher {
         }
         const filtered = await this.normalizeEvents(events);
         if (filtered.length > 0) {
-          void this.onChange(filtered);
+          await this.onChange(filtered);
         }
       }, {
         ignore
@@ -346,6 +413,12 @@ const FORBIDDEN_OBJECT_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
 function isForbiddenObjectKey(key) {
   return FORBIDDEN_OBJECT_KEYS.has(key);
 }
+function hasLocalesToExtract(config) {
+  const {
+    locales
+  } = config.extract;
+  return locales === 'infer' || locales.length > 0;
+}
 
 // Essentialls lodash/set, but we avoid this dependency
 function setNestedProperty(obj, keyPath, value) {
@@ -366,17 +439,34 @@ function setNestedProperty(obj, keyPath, value) {
   current[keys[keys.length - 1]] = value;
 }
 function getSortedMessages(messages) {
+  const warnedMissingReferenceIds = new Set();
   return messages.toSorted((messageA, messageB) => {
-    const refA = messageA.references?.[0];
-    const refB = messageB.references?.[0];
+    const refA = messageA.references[0];
+    const refB = messageB.references[0];
 
-    // No references: preserve original (extraction) order
-    if (!refA || !refB) return 0;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (refA == null) {
+      warnAboutMissingReference(messageA.id, warnedMissingReferenceIds);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (refB == null) {
+      warnAboutMissingReference(messageB.id, warnedMissingReferenceIds);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (refA == null || refB == null) {
+      return 0;
+    }
 
     // Sort by path, then line. Same path+line: preserve original order
     return compareReferences(refA, refB);
   });
 }
+function warnAboutMissingReference(id, warnedMissingReferenceIds) {
+  if (warnedMissingReferenceIds.has(id)) return;
+  warnedMissingReferenceIds.add(id);
+  warn(`Missing file reference for extracted message: ${id}`);
+}
 function localeCompare(a, b) {
   return a.localeCompare(b, 'en');
 }
@@ -613,15 +703,27 @@ class SaveScheduler {
 
 class CatalogManager {
   /**
-   * The source of truth for which messages are used.
-   * NOTE: Should be mutated in place to keep `messagesById` and `messagesByFile` in sync.
+   * Extraction-derived fields aggregated into `ExtractorMessage`.
+   * Source code is the source of truth for these fields, only ancillary
+   * codec fields may merge from disk (e.g. flags).
+   */
+  static extractorOwnedAggregatorKeys = new Set(['description', 'id', 'message', 'references']);
+  /**
+   * Source of truth for statically extracted source messages,
+   * grouped by file and message ID.
    */
-  messagesByFile = new Map();
+  sourceMessagesByFile = new Map();
 
   /**
-   * Fast lookup for messages by ID across all files,
-   * contains the same messages as `messagesByFile`.
-   * NOTE: Should be mutated in place to keep `messagesById` and `messagesByFile` in sync.
+   * Reverse index for rebuilding aggregated messages without scanning all files.
+   * Contains the same `SourceMessage` arrays as `sourceMessagesByFile` and is
+   * kept in sync with it.
+   */
+  sourceMessagesById = new Map();
+
+  /**
+   * Fast lookup for messages by ID, aggregated across all files. This combines
+   * metadata from `sourceMessagesById`, e.g. references and descriptions.
    */
   messagesById = new Map();
 
@@ -640,7 +742,7 @@ class CatalogManager {
 
   constructor(config, opts) {
     this.config = config;
-    this.saveScheduler = new SaveScheduler(50);
+    this.saveScheduler = new SaveScheduler(opts.saveDebounceMs ?? 50);
     this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
     this.isDevelopment = opts.isDevelopment ?? false;
     this.extractor = opts.extractor;
@@ -663,7 +765,7 @@ class CatalogManager {
       return this.persister;
     } else {
       this.persister = new CatalogPersister({
-        messagesPath: this.config.messages.path,
+        messagesPath: this.config.extract.path,
         codec: await this.getCodec(),
         extension: getFormatExtension(this.config.messages.format)
       });
@@ -674,12 +776,12 @@ class CatalogManager {
     if (this.catalogLocales) {
       return this.catalogLocales;
     } else {
-      const messagesDir = path__default.default.join(this.projectRoot, this.config.messages.path);
+      const messagesDir = path__default.default.join(this.projectRoot, this.config.extract.path);
       this.catalogLocales = new CatalogLocales({
         messagesDir,
-        sourceLocale: this.config.sourceLocale,
         extension: getFormatExtension(this.config.messages.format),
-        locales: this.config.messages.locales
+        locales: this.config.extract.locales,
+        sourceLocale: this.config.extract.sourceLocale
       });
       return this.catalogLocales;
     }
@@ -688,15 +790,28 @@ class CatalogManager {
     return this.getCatalogLocales().getTargetLocales();
   }
   getSrcPaths() {
-    return (Array.isArray(this.config.srcPath) ? this.config.srcPath : [this.config.srcPath]).map(srcPath => path__default.default.join(this.projectRoot, srcPath));
+    return (Array.isArray(this.config.extract.srcPath) ? this.config.extract.srcPath : [this.config.extract.srcPath]).map(srcPath => path__default.default.join(this.projectRoot, srcPath));
   }
   async loadMessages() {
     const sourceDiskMessages = await this.loadSourceMessages();
     this.loadCatalogsPromise = this.loadTargetMessages();
     await this.loadCatalogsPromise;
     this.scanCompletePromise = (async () => {
-      const sourceFiles = await SourceFileScanner.getSourceFiles(this.getSrcPaths());
-      await Promise.all(Array.from(sourceFiles).map(async filePath => this.processFile(filePath)));
+      const sourceFiles = Array.from(await SourceFileScanner.getSourceFiles(this.getSrcPaths()))
+      // Stable file order keeps catalog ties independent of processing timing
+      .toSorted(localeCompare);
+      const extractedFiles = await Promise.all(sourceFiles.map(async filePath => ({
+        filePath,
+        messages: await this.extractFile(filePath)
+      })));
+      for (const {
+        filePath,
+        messages
+      } of extractedFiles) {
+        if (messages) {
+          this.applyFileMessages(filePath, messages);
+        }
+      }
       this.mergeSourceDiskMetadata(sourceDiskMessages);
     })();
     await this.scanCompletePromise;
@@ -708,7 +823,7 @@ class CatalogManager {
   async loadSourceMessages() {
     // Load source catalog to hydrate metadata (e.g. flags) later without
     // treating catalog entries as source of truth.
-    const diskMessages = await this.loadLocaleMessages(this.config.sourceLocale);
+    const diskMessages = await this.loadLocaleMessages(this.config.extract.sourceLocale);
     const byId = new Map();
     for (const diskMessage of diskMessages) {
       byId.set(diskMessage.id, diskMessage);
@@ -728,17 +843,13 @@ class CatalogManager {
   }
   async reloadLocaleCatalog(locale) {
     const diskMessages = await this.loadLocaleMessages(locale);
-    if (locale === this.config.sourceLocale) {
+    if (locale === this.config.extract.sourceLocale) {
       // For source: Merge additional properties like flags
       for (const diskMessage of diskMessages) {
         const prev = this.messagesById.get(diskMessage.id);
         if (prev) {
-          // Mutate the existing object instead of creating a copy
-          // to keep messagesById and messagesByFile in sync.
-          // Unknown properties (like flags): disk wins
-          // Known properties: existing (from extraction) wins
           for (const key of Object.keys(diskMessage)) {
-            if (!['id', 'message', 'description', 'references'].includes(key)) {
+            if (!CatalogManager.extractorOwnedAggregatorKeys.has(key)) {
               // For unknown properties (like flags), disk wins
               prev[key] = diskMessage[key];
             }
@@ -770,17 +881,23 @@ class CatalogManager {
       const existing = this.messagesById.get(id);
       if (!existing) continue;
 
-      // Mutate the existing object instead of creating a copy.
-      // This keeps `messagesById` and `messagesByFile` in sync since
-      // they reference the same object instance.
+      // Fill unknown metadata from disk without replacing extraction-owned fields.
       for (const key of Object.keys(diskMessage)) {
-        if (existing[key] == null) {
+        if (!CatalogManager.extractorOwnedAggregatorKeys.has(key) && existing[key] == null) {
           existing[key] = diskMessage[key];
         }
       }
     }
   }
   async processFile(absoluteFilePath) {
+    const messages = await this.extractFile(absoluteFilePath);
+
+    // `undefined` only when `extractFile()` throws. An empty array is success
+    // and must still run `applyFileMessages` to clear stale ids for this file.
+    if (!messages) return false;
+    return this.applyFileMessages(absoluteFilePath, messages);
+  }
+  async extractFile(absoluteFilePath) {
     let messages = [];
     try {
       const content = await fs__default$1.default.readFile(absoluteFilePath, 'utf8');
@@ -788,7 +905,7 @@ class CatalogManager {
       try {
         extraction = await this.extractor.extract(absoluteFilePath, content);
       } catch {
-        return false;
+        return undefined;
       }
       messages = extraction.messages;
     } catch (err) {
@@ -797,71 +914,91 @@ class CatalogManager {
       }
       // ENOENT -> treat as no messages
     }
-    const prevFileMessages = this.messagesByFile.get(absoluteFilePath);
-    const relativeFilePath = normalizePathToPosix(path__default.default.relative(this.projectRoot, absoluteFilePath));
-
-    // Init with all previous ones
-    const idsToRemove = Array.from(prevFileMessages?.keys() ?? []);
-
-    // Replace existing messages with new ones
-    const fileMessages = new Map();
-    for (let message of messages) {
-      const prevMessage = this.messagesById.get(message.id);
-
-      // Merge with previous message if it exists
-      if (prevMessage) {
-        message = {
-          ...message
-        };
-        if (message.references) {
-          message.references = this.mergeReferences(prevMessage.references ?? [], relativeFilePath, message.references);
+    return messages;
+  }
+  applyFileMessages(absoluteFilePath, messages) {
+    const prevFileMessages = this.sourceMessagesByFile.get(absoluteFilePath);
+    const nextFileMessages = this.groupSourceMessagesById(messages);
+    const affectedIds = new Set([...(prevFileMessages?.keys() ?? []), ...nextFileMessages.keys()]);
+    if (nextFileMessages.size > 0) {
+      this.sourceMessagesByFile.set(absoluteFilePath, nextFileMessages);
+    } else {
+      this.sourceMessagesByFile.delete(absoluteFilePath);
+    }
+
+    // Clear this file's contribution from the reverse index, then re-insert
+    // fresh rows and rebuild aggregates (messagesById) per touched id.
+    for (const id of affectedIds) {
+      const sourceMessagesForId = this.sourceMessagesById.get(id);
+      if (sourceMessagesForId) {
+        sourceMessagesForId.delete(absoluteFilePath);
+        // No files left for this id: drop the reverse-index entry.
+        if (sourceMessagesForId.size === 0) {
+          this.sourceMessagesById.delete(id);
         }
-
-        // Merge other properties like description, or unknown
-        // attributes like flags that are opaque to us
-        for (const key of Object.keys(prevMessage)) {
-          if (message[key] == null) {
-            message[key] = prevMessage[key];
-          }
+      }
+      const nextSourceMessagesForId = nextFileMessages.get(id);
+      if (nextSourceMessagesForId) {
+        let sourceMessagesByFile = this.sourceMessagesById.get(id);
+        if (!sourceMessagesByFile) {
+          sourceMessagesByFile = new Map();
+          this.sourceMessagesById.set(id, sourceMessagesByFile);
         }
+        sourceMessagesByFile.set(absoluteFilePath, nextSourceMessagesForId);
       }
-      this.messagesById.set(message.id, message);
-      fileMessages.set(message.id, message);
-
-      // This message continues to exist in this file
-      const index = idsToRemove.indexOf(message.id);
-      if (index !== -1) idsToRemove.splice(index, 1);
-    }
-
-    // Clean up removed messages from `messagesById`
-    idsToRemove.forEach(id => {
-      const message = this.messagesById.get(id);
-      if (!message) return;
-      const hasOtherReferences = message.references?.some(ref => ref.path !== relativeFilePath);
-      if (!hasOtherReferences) {
-        // No other references, delete the message entirely
-        this.messagesById.delete(id);
+      this.rebuildMessageById(id);
+    }
+    const changed = this.haveMessagesChangedForFile(prevFileMessages, nextFileMessages);
+    return changed;
+  }
+  groupSourceMessagesById(messages) {
+    const result = new Map();
+    for (const message of messages) {
+      const messagesById = result.get(message.id);
+      if (messagesById) {
+        messagesById.push(message);
       } else {
-        // Message is used elsewhere, remove this file from references
-        // Mutate the existing object to keep `messagesById` and `messagesByFile` in sync
-        message.references = message.references?.filter(ref => ref.path !== relativeFilePath);
+        result.set(message.id, [message]);
       }
-    });
-
-    // Update the stored messages
-    if (messages.length > 0) {
-      this.messagesByFile.set(absoluteFilePath, fileMessages);
-    } else {
-      this.messagesByFile.delete(absoluteFilePath);
     }
-    const changed = this.haveMessagesChangedForFile(prevFileMessages, fileMessages);
-    return changed;
+    return result;
   }
-  mergeReferences(existing, currentFilePath, currentFileRefs) {
-    // Keep refs from other files, replace all refs from the current file
-    const otherFileRefs = existing.filter(ref => ref.path !== currentFilePath);
-    const merged = [...otherFileRefs, ...currentFileRefs];
-    return merged.sort(compareReferences);
+  rebuildMessageById(id) {
+    const sourceMessages = Array.from(this.sourceMessagesById.get(id)?.values() ?? []).flat();
+    if (sourceMessages.length === 0) {
+      this.messagesById.delete(id);
+      return;
+    }
+    const previousMessage = this.messagesById.get(id);
+    const aggregate = {
+      description: this.mergeDescriptions(sourceMessages),
+      id,
+      message: sourceMessages[0].message,
+      references: sourceMessages.map(message => message.reference).sort(compareReferences)
+    };
+    if (previousMessage) {
+      for (const key of Object.keys(previousMessage)) {
+        // Preserve extra fields (e.g. from disk/codec) across rebuilds; the
+        // four core fields above are always recomputed from source messages.
+        if (!CatalogManager.extractorOwnedAggregatorKeys.has(key) && aggregate[key] == null) {
+          aggregate[key] = previousMessage[key];
+        }
+      }
+    }
+    this.messagesById.set(id, aggregate);
+  }
+  mergeDescriptions(messages) {
+    const sortedByReference = messages.toSorted((a, b) => compareReferences(a.reference, b.reference));
+    const merged = [];
+    for (const message of sortedByReference) {
+      const {
+        description
+      } = message;
+      if (description != null && !merged.includes(description)) {
+        merged.push(description);
+      }
+    }
+    return merged;
   }
   haveMessagesChangedForFile(beforeMessages, afterMessages) {
     // If one exists and the other doesn't, there's a change
@@ -875,25 +1012,28 @@ class CatalogManager {
     }
 
     // Check differences in beforeMessages vs afterMessages
-    for (const [id, msg1] of beforeMessages) {
-      const msg2 = afterMessages.get(id);
-      if (!msg2 || !this.areMessagesEqual(msg1, msg2)) {
+    for (const [id, prevSourceMessages] of beforeMessages) {
+      const nextSourceMessages = afterMessages.get(id);
+      if (!nextSourceMessages) {
+        return true;
+      }
+      if (!this.areSourceMessageArraysEqual(prevSourceMessages, nextSourceMessages)) {
         return true; // Early exit on first difference
       }
     }
     return false;
   }
-  areMessagesEqual(msg1, msg2) {
-    // Note: We intentionally don't compare references here.
-    // References are aggregated metadata from multiple files and comparing
-    // them would cause false positives due to parallel extraction order.
-    return msg1.id === msg2.id && msg1.message === msg2.message && msg1.description === msg2.description;
+  areSourceMessageArraysEqual(messages1, messages2) {
+    return messages1.length === messages2.length && messages1.every((message, index) => this.areSourceMessagesEqual(message, messages2[index]));
+  }
+  areSourceMessagesEqual(msg1, msg2) {
+    return msg1.id === msg2.id && msg1.message === msg2.message && msg1.description === msg2.description && msg1.reference.path === msg2.reference.path && msg1.reference.line === msg2.reference.line;
   }
   async save() {
     return this.saveScheduler.schedule(() => this.saveImpl());
   }
   async saveImpl() {
-    await this.saveLocale(this.config.sourceLocale);
+    await this.saveLocale(this.config.extract.sourceLocale);
     const targetLocales = await this.getTargetLocales();
     await Promise.all(targetLocales.map(locale => this.saveLocale(locale)));
   }
@@ -901,7 +1041,7 @@ class CatalogManager {
     await this.loadCatalogsPromise;
     const messages = Array.from(this.messagesById.values());
     const persister = await this.getPersister();
-    const isSourceLocale = locale === this.config.sourceLocale;
+    const isSourceLocale = locale === this.config.extract.sourceLocale;
 
     // Check if file was modified externally (poll-at-save is cheaper than
     // watchers here since stat() is fast and avoids continuous overhead)
@@ -951,8 +1091,9 @@ class CatalogManager {
       await this.scanCompletePromise;
     }
     let changed = false;
-    const expandedEvents = await this.sourceWatcher.expandDirectoryDeleteEvents(events, Array.from(this.messagesByFile.keys()));
-    for (const event of expandedEvents) {
+    const expandedEvents = await this.sourceWatcher.expandDirectoryDeleteEvents(events, Array.from(this.sourceMessagesByFile.keys()));
+    // Stable file order keeps catalog ties independent of event timing.
+    for (const event of expandedEvents.toSorted((a, b) => localeCompare(a.path, b.path))) {
       const hasChanged = await this.processFile(event.path);
       changed ||= hasChanged;
     }
@@ -999,7 +1140,7 @@ class LRUCache {
   }
 }
 
-const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin-0S9vVrVM.cjs', document.baseURI).href)));
+const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin-DlFYUFWh.cjs', document.baseURI).href)));
 class MessageExtractor {
   compileCache = new LRUCache(750);
   constructor(opts) {
@@ -1104,9 +1245,8 @@ const isDevelopmentOrNextBuild = isDevelopment || isNextBuild;
 // Single compiler instance, initialized once per process
 let compiler;
 const runOnce = once('_NEXT_INTL_EXTRACT');
-function initExtractionCompiler(pluginConfig) {
-  const experimental = pluginConfig.experimental;
-  if (!experimental?.extract) {
+function initExtractionCompiler(extractorConfig) {
+  if (!extractorConfig || !hasLocalesToExtract(extractorConfig)) {
     return;
   }
 
@@ -1125,11 +1265,6 @@ function initExtractionCompiler(pluginConfig) {
   const shouldRun = isDevelopment || isNextBuild;
   if (!shouldRun) return;
   runOnce(() => {
-    const extractorConfig = {
-      srcPath: experimental.srcPath,
-      sourceLocale: experimental.extract.sourceLocale,
-      messages: experimental.messages
-    };
     compiler = new ExtractionCompiler(extractorConfig, {
       isDevelopment,
       projectRoot: process.cwd()
@@ -1157,7 +1292,7 @@ function initExtractionCompiler(pluginConfig) {
 
 function getCurrentVersion() {
   try {
-    const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin-0S9vVrVM.cjs', document.baseURI).href)));
+    const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin-DlFYUFWh.cjs', document.baseURI).href)));
     const pkg = require$1('next/package.json');
     return pkg.version;
   } catch (error) {
@@ -1184,7 +1319,7 @@ function isNextJs16OrHigher() {
   return compareVersions(getCurrentVersion(), '16.0.0') >= 0;
 }
 
-const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin-0S9vVrVM.cjs', document.baseURI).href)));
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin-DlFYUFWh.cjs', document.baseURI).href)));
 function withExtensions(localPath) {
   return [`${localPath}.ts`, `${localPath}.tsx`, `${localPath}.js`, `${localPath}.jsx`];
 }
@@ -1229,7 +1364,7 @@ function resolveI18nPath(providedPath, cwd) {
     }
   }
 }
-function getNextConfig(pluginConfig, nextConfig) {
+function getNextConfig(pluginConfig, nextConfig, extractorConfig) {
   const useTurbo = process.env.TURBOPACK != null;
 
   // `experimental-analyze` doesn’t set the TURBOPACK env param. Since Next.js
@@ -1237,25 +1372,27 @@ function getNextConfig(pluginConfig, nextConfig) {
   // always configure Turbopack just in case.
   const shouldConfigureTurbo = useTurbo || isNextJs16OrHigher();
   const nextIntlConfig = {};
-  function getExtractMessagesLoaderConfig() {
-    const experimental = pluginConfig.experimental;
-    if (!experimental.srcPath || !pluginConfig.experimental?.messages) {
-      throwError('`srcPath` and `messages` are required when using `extractor`.');
-    }
+  let messageLoadPaths = [];
+  if (pluginConfig.experimental?.messages) {
+    messageLoadPaths = normalizeMessagesCatalogPaths(pluginConfig.experimental.messages.path);
+  }
+  function getExtractMessagesLoaderConfig(config) {
     return {
       loader: 'next-intl/extractor/extractionLoader',
-      options: {
-        srcPath: experimental.srcPath,
-        sourceLocale: experimental.extract.sourceLocale,
-        messages: pluginConfig.experimental.messages
-      }
+      options: config
     };
   }
   function getCatalogLoaderConfig() {
+    const messages = pluginConfig.experimental.messages;
     return {
       loader: 'next-intl/extractor/catalogLoader',
       options: {
-        messages: pluginConfig.experimental.messages
+        messages: {
+          format: messages.format,
+          ...(messages.precompile !== undefined && {
+            precompile: messages.precompile
+          })
+        }
       }
     };
   }
@@ -1276,18 +1413,6 @@ function getNextConfig(pluginConfig, nextConfig) {
       rules[glob] = rule;
     }
   }
-
-  // Validate messages config
-  if (pluginConfig.experimental?.messages) {
-    const messages = pluginConfig.experimental.messages;
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- For non-TS consumers
-    if (!messages.format) {
-      throwError('`format` is required when using `messages`.');
-    }
-    if (!messages.path) {
-      throwError('`path` is required when using `messages`.');
-    }
-  }
   if (shouldConfigureTurbo) {
     if (pluginConfig.requestConfig && path__default.default.isAbsolute(pluginConfig.requestConfig)) {
       throwError("Turbopack support for next-intl currently does not support absolute paths, please provide a relative one (e.g. './src/i18n/config.ts').\n\nFound: " + pluginConfig.requestConfig);
@@ -1324,13 +1449,11 @@ function getNextConfig(pluginConfig, nextConfig) {
         throwError('Message extraction requires Next.js 16 or higher.');
       }
       rules ??= getTurboRules();
-      const srcPaths = (Array.isArray(pluginConfig.experimental.srcPath) ? pluginConfig.experimental.srcPath : [pluginConfig.experimental.srcPath]).map(srcPath => srcPath.endsWith('/') ? srcPath.slice(0, -1) : srcPath);
       addTurboRule(rules, `*.{${SourceFileFilter.EXTENSIONS.join(',')}}`, {
-        loaders: [getExtractMessagesLoaderConfig()],
+        loaders: [getExtractMessagesLoaderConfig(extractorConfig)],
         condition: {
-          // Note: We don't need `not: 'foreign'`, because this is
-          // implied by the filter based on `srcPath`.
-          path: `{${srcPaths.join(',')}}` + '/**/*',
+          // We don't filter for `path` here to allow transformation
+          // of `useExtracted` calls in external packages (e.g. monorepos)
           content: /(useExtracted|getExtracted)/
         }
       });
@@ -1346,7 +1469,7 @@ function getNextConfig(pluginConfig, nextConfig) {
       addTurboRule(rules, `*${extension}`, {
         loaders: [getCatalogLoaderConfig()],
         condition: {
-          path: `${pluginConfig.experimental.messages.path}/**/*`
+          path: `{${messageLoadPaths.join(',')}}/**/*`
         },
         as: '*.js'
       });
@@ -1404,11 +1527,9 @@ function getNextConfig(pluginConfig, nextConfig) {
       if (pluginConfig.experimental?.extract) {
         if (!config.module) config.module = {};
         if (!config.module.rules) config.module.rules = [];
-        const srcPath = pluginConfig.experimental.srcPath;
         config.module.rules.push({
           test: new RegExp(`\\.(${SourceFileFilter.EXTENSIONS.join('|')})$`),
-          include: Array.isArray(srcPath) ? srcPath.map(cur => path__default.default.resolve(config.context, cur)) : path__default.default.resolve(config.context, srcPath || ''),
-          use: [getExtractMessagesLoaderConfig()]
+          use: [getExtractMessagesLoaderConfig(extractorConfig)]
         });
       }
 
@@ -1419,7 +1540,7 @@ function getNextConfig(pluginConfig, nextConfig) {
         const extension = getFormatExtension(pluginConfig.experimental.messages.format);
         config.module.rules.push({
           test: new RegExp(`${extension.replace(/\./g, '\\.')}$`),
-          include: path__default.default.resolve(config.context, pluginConfig.experimental.messages.path),
+          include: messageLoadPaths.map(dirPath => path__default.default.resolve(config.context, dirPath)),
           use: [getCatalogLoaderConfig()],
           type: 'javascript/auto'
         });
@@ -1450,10 +1571,20 @@ function initPlugin(pluginConfig, nextConfig) {
   if (messagesPathOrPaths && !skipWatchers) {
     createMessagesDeclaration(typeof messagesPathOrPaths === 'string' ? [messagesPathOrPaths] : messagesPathOrPaths);
   }
+  let extractorConfig;
+  const experimental = pluginConfig.experimental;
+  const extract = experimental?.extract;
+  if (extract) {
+    extractorConfig = normalizeExtractorConfig({
+      extract,
+      messages: experimental.messages,
+      srcPath: experimental.srcPath
+    });
+  }
   if (!skipWatchers) {
-    initExtractionCompiler(pluginConfig);
+    initExtractionCompiler(extractorConfig);
   }
-  return getNextConfig(pluginConfig, nextConfig);
+  return getNextConfig(pluginConfig, nextConfig, extractorConfig);
 }
 function createNextIntlPlugin(i18nPathOrConfig = {}) {
   const config = typeof i18nPathOrConfig === 'string' ? {