Update (part 25)

e-commerce/node_modules/next-intl-swc-plugin-extractor/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jan Amann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

e-commerce/node_modules/next-intl-swc-plugin-extractor/README.md

@@ -0,0 +1,5 @@
+# next-intl-swc-plugin-extractor
+
+SWC plugin for extracting inline messages.
+
+**Important:** This package is only intended for internal use and it's API may change at any time.

e-commerce/node_modules/next-intl-swc-plugin-extractor/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "next-intl-swc-plugin-extractor",
+  "version": "4.14.9",
+  "sideEffects": false,
+  "author": "Jan Amann <jan@amann.work>",
+  "contributors": [
+    "강동윤 <kdy1997.dev@gmail.com>"
+  ],
+  "description": "SWC plugin for extracting inline messages.",
+  "license": "MIT",
+  "homepage": "https://next-intl.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amannn/next-intl.git"
+  },
+  "scripts": {
+    "prepublishOnly": "turbo build",
+    "test": "cargo test --release",
+    "build": "cargo build --release --target wasm32-wasip1 --target-dir target"
+  },
+  "main": "target/wasm32-wasip1/release/swc_plugin_extractor.wasm",
+  "files": [
+    "target/wasm32-wasip1/release/swc_plugin_extractor.wasm"
+  ],
+  "gitHead": "b9fc98a814957b9c97894c7b57151215ac39afa6"
+}

e-commerce/node_modules/next-intl-swc-plugin-extractor/target/wasm32-wasip1/release/swc_plugin_extractor.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe1a1051266f0e28e75d123b88d9bd170a7ea26c568ef9e2fcf5e577ba19af40
+size 1269847

e-commerce/node_modules/next-intl/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jan Amann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

e-commerce/node_modules/next-intl/README.md

@@ -0,0 +1,99 @@
+<p align="center">
+  <br>
+  <a href="https://next-intl.dev">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="media/logo-dark-mode.svg">
+      <source media="(prefers-color-scheme: light)" srcset="media/logo.svg">
+      <img alt="next-intl" src="media/logo.svg" width="600">
+    </picture>
+  </a>
+  <br>
+  <br>
+</p>
+
+Internationalization for Next.js.
+
+## Features
+
+Internationalization (i18n) is an essential part of the user experience, therefore `next-intl` gives you all the parts you need to get language nuances right.
+
+- 🌟 **ICU message syntax**: Localize your messages with interpolation, cardinal & ordinal plurals, enum-based label selection and rich text.
+- 📅 **Dates, times & numbers**: Apply appropriate formatting without worrying about server/client differences like time zones.
+- ✅ **Type-safe**: Speed up development with autocompletion for message keys and catch typos early with compile-time checks.
+- 💡 **Hooks-based API**: Learn a single API that can be used across your code base to turn translations into plain strings or rich text.
+- 🚀 **Next.js-native and performance-obsessed**: App Router, Server Components, static rendering—pick the right tool for the right job, next-intl works everywhere.
+- 🌍 **Internationalized routing**: Provide unique pathnames per language and optionally localize pathnames for search engine optimization.
+
+[→ Read the docs](https://next-intl.dev)
+
+## What does it look like?
+
+```jsx
+// UserProfile.tsx
+import {useTranslations} from 'next-intl';
+
+export default function UserProfile({user}) {
+  const t = useTranslations('UserProfile');
+
+  return (
+    <section>
+      <h1>{t('title', {firstName: user.firstName})}</h1>
+      <p>{t('membership', {memberSince: user.memberSince})}</p>
+      <p>{t('followers', {count: user.numFollowers})}</p>
+    </section>
+  );
+}
+```
+
+```js
+// en.json
+{
+  "UserProfile": {
+    "title": "{firstName}'s profile",
+    "membership": "Member since {memberSince, date, short}",
+    "followers": "{count, plural, ↵
+                    =0 {No followers yet} ↵
+                    =1 {One follower} ↵
+                    other {# followers} ↵
+                  }"
+  }
+}
+```
+
+## Lint your messages
+
+As an app grows, messages may drift and become inconsistent.
+
+A companion tool, [`eloqnt/cli`](https://cli.eloqnt.dev/docs), catches this by analyzing your source code and messages statically:
+
+```console
+$ eloqnt lint
+
+messages/de.json
+│
+│  "UserProfile.title": "Dein Profil"
+│                        ─┬──────────
+│                         ╰─ Inconsistent ICU arguments: missing {firstName} (inconsistent-args)
+│
+│  "UserProfile.membership": "Member since {memberSince, date, short}"
+│  ─┬──────────────────────
+│   ╰─ Missing translation for de (missing-translation)
+
+✗ 1 error
+! 1 warning
+
+→ Rule details: https://cli.eloqnt.dev/docs/lint-rules/<rule>
+→ Run `eloqnt translate` to fill in 1 missing translation
+```
+
+It can optionally also fill in missing translations with [`eloqnt translate`](https://cli.eloqnt.dev/docs/cli/translate), using your source code as context.
+
+---
+
+<div align="center">
+  <a href="https://next-intl.dev/redirect?href=https://crowdin.com" target="_blank">
+    <img width="350" src="media/partner.svg" alt="Crowdin logo">
+  </a>
+  <br>
+  <p>Hosted on <a href="https://vercel.com?utm_source=next-intl&utm_campaign=oss">Vercel</a></p>
+</div>

e-commerce/node_modules/next-intl/config.d.ts

@@ -0,0 +1,4 @@
+// Needed for projects with `moduleResolution: 'node'`
+import config from './dist/types/config';
+
+export default config;

e-commerce/node_modules/next-intl/dist/cjs/development/BuiltInPoCodec-B6w-kmTx.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var createPoCodec = require('@eloqnt/format-po');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var createPoCodec__default = /*#__PURE__*/_interopDefaultCompat(createPoCodec);
+
+// Derived from `@eloqnt/config`, so next-intl and eloqnt pass identical
+// options to codecs.
+
+function defineCodec(factory) {
+  return factory;
+}
+
+// `@eloqnt/format-po`, guarded so catalogs in the previous key-based layout
+// fail loudly. Custom codecs referencing the package directly opt out.
+var BuiltInPoCodec = defineCodec(() => {
+  const codec = createPoCodec__default.default();
+  function assertMigrated(content) {
+    if (content.includes('X-Crowdin-SourceKey: msgstr')) {
+      throw new Error('This catalog uses the previous PO layout of next-intl, which stored message keys in `msgid`. The PO format now follows the gettext convention: the source text in `msgid` and the message key in `msgctxt`. Please migrate your catalogs, or use a custom codec to keep the previous layout: https://github.com/amannn/next-intl/pull/2393');
+    }
+  }
+  return {
+    ...codec,
+    decode(content, context) {
+      assertMigrated(content);
+      return codec.decode(content, context);
+    }
+  };
+});
+
+exports.default = BuiltInPoCodec;

e-commerce/node_modules/next-intl/dist/cjs/development/plugin.cjs

@@ -0,0 +1,1637 @@
+'use strict';
+
+var fs$1 = require('fs/promises');
+var path = require('path');
+var module$1 = require('module');
+var url = require('url');
+var watcher = require('@parcel/watcher');
+var fs = require('fs');
+var core = require('@swc/core');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function formatMessage(message) {
+  return `\n[next-intl] ${message}\n`;
+}
+function throwError(message) {
+  throw new Error(formatMessage(message));
+}
+function warn(message) {
+  console.warn(formatMessage(message));
+}
+
+/**
+ * Returns a function that runs the provided callback only once per process.
+ * Next.js can call the config multiple times - this ensures we only run once.
+ * Uses an environment variable to track execution across config loads.
+ */
+function once(namespace) {
+  return function runOnce(fn) {
+    if (process.env[namespace] === '1') {
+      return;
+    }
+    process.env[namespace] = '1';
+    fn();
+  };
+}
+
+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.
+ */
+function watchFile(filepath, callback) {
+  const directory = path__default.default.dirname(filepath);
+  const filename = path__default.default.basename(filepath);
+  return fs__default.default.watch(directory, {
+    persistent: false,
+    recursive: false
+  }, (event, changedFilename) => {
+    if (changedFilename === filename) {
+      callback();
+    }
+  });
+}
+
+const runOnce$1 = once('_NEXT_INTL_COMPILE_MESSAGES');
+function createMessagesDeclaration(messagesPaths) {
+  // Instead of running _only_ in certain cases, it's
+  // safer to _avoid_ running for certain known cases.
+  // https://github.com/amannn/next-intl/issues/2006
+  const shouldBailOut = ['info', 'start'
+
+  // Note: These commands don't consult the
+  // Next.js config, so we can't detect them here.
+  // - telemetry (however, the `detached-flush` DOES - see `createNextIntlPlugin`)
+  // - lint
+  //
+  // What remains are:
+  // - dev
+  // - build
+  // - typegen
+  ].some(arg => process.argv.includes(arg));
+  if (shouldBailOut) {
+    return;
+  }
+  runOnce$1(() => {
+    for (const messagesPath of messagesPaths) {
+      const fullPath = path__default.default.resolve(messagesPath);
+      if (!fs__default.default.existsSync(fullPath)) {
+        throwError(`\`createMessagesDeclaration\` points to a non-existent file: ${fullPath}`);
+      }
+      if (!fullPath.endsWith('.json')) {
+        throwError(`\`createMessagesDeclaration\` needs to point to a JSON file. Received: ${fullPath}`);
+      }
+
+      // Keep this as a runtime check and don't replace
+      // this with a constant during the build process
+      const env = process.env['NODE_ENV'.trim()];
+      compileDeclaration(messagesPath);
+      if (env === 'development') {
+        startWatching(messagesPath);
+      }
+    }
+  });
+}
+function startWatching(messagesPath) {
+  const watcher = watchFile(messagesPath, () => {
+    compileDeclaration(messagesPath, true);
+  });
+  process.on('exit', () => {
+    watcher.close();
+  });
+}
+function compileDeclaration(messagesPath, async = false) {
+  const declarationPath = messagesPath.replace(/\.json$/, '.d.json.ts');
+  function createDeclaration(content) {
+    return `// This file is auto-generated by next-intl, do not edit directly.
+// See: https://next-intl.dev/docs/workflows/typescript#messages-arguments
+
+declare const messages: ${content.trim()};
+export default messages;`;
+  }
+  if (async) {
+    return fs__default.default.promises.readFile(messagesPath, 'utf-8').then(content => fs__default.default.promises.writeFile(declarationPath, createDeclaration(content)));
+  }
+  const content = fs__default.default.readFileSync(messagesPath, 'utf-8');
+  fs__default.default.writeFileSync(declarationPath, createDeclaration(content));
+}
+
+const formats = {
+  json: {
+    codec: () => import('@eloqnt/format-json'),
+    extension: '.json'
+  },
+  po: {
+    codec: () => Promise.resolve().then(function () { return require('./BuiltInPoCodec-B6w-kmTx.cjs'); }),
+    extension: '.po'
+  }
+};
+function isBuiltInFormat(format) {
+  return typeof format === 'string' && format in formats;
+}
+function getFormatExtension(format) {
+  if (isBuiltInFormat(format)) {
+    return formats[format].extension;
+  } else {
+    return format.extension;
+  }
+}
+async function resolveCodec(format, projectRoot) {
+  if (isBuiltInFormat(format)) {
+    const factory = (await formats[format].codec()).default;
+    return factory();
+  } else {
+    // A codec that starts with `.` or a filesystem root is a file path;
+    // everything else reads as a package specifier, mirroring how imports
+    // distinguish the two. Packages resolve from the project's dependencies.
+    const isPath = format.codec.startsWith('.') || path__default.default.isAbsolute(format.codec);
+    let resolvedPath;
+    if (isPath) {
+      resolvedPath = path__default.default.resolve(projectRoot, format.codec);
+    } else {
+      try {
+        resolvedPath = module$1.createRequire(path__default.default.join(projectRoot, 'noop.js')).resolve(format.codec);
+      } catch (error) {
+        throwError(`Could not resolve the codec package "${format.codec}". Is it installed?\n${error}`);
+      }
+    }
+    let module;
+    try {
+      module = await import(url.pathToFileURL(resolvedPath).href);
+    } catch (error) {
+      throwError(`Could not load codec from "${resolvedPath}".\n${error}`);
+    }
+    const factory = module.default;
+    if (!factory || typeof factory !== 'function') {
+      throwError(`Codec at "${resolvedPath}" must have a default export returned from \`defineCodec\`.`);
+    }
+    return factory();
+  }
+}
+
+class SourceFileFilter {
+  static EXTENSIONS = ['ts', 'tsx', 'js', 'jsx'];
+
+  // Will not be entered, except if explicitly asked for
+  // TODO: At some point we should infer these from .gitignore
+  static IGNORED_DIRECTORIES = ['node_modules', '.next', '.git'];
+  static isSourceFile(filePath) {
+    const ext = path__default.default.extname(filePath);
+    return SourceFileFilter.EXTENSIONS.map(cur => '.' + cur).includes(ext);
+  }
+  static shouldEnterDirectory(dirPath, srcPaths) {
+    const dirName = path__default.default.basename(dirPath);
+    if (SourceFileFilter.IGNORED_DIRECTORIES.includes(dirName)) {
+      return SourceFileFilter.isIgnoredDirectoryExplicitlyIncluded(dirPath, srcPaths);
+    }
+    return true;
+  }
+  static isIgnoredDirectoryExplicitlyIncluded(ignoredDirPath, srcPaths) {
+    return srcPaths.some(srcPath => SourceFileFilter.isWithinPath(srcPath, ignoredDirPath));
+  }
+  static isWithinPath(targetPath, basePath) {
+    const relativePath = path__default.default.relative(basePath, targetPath);
+    return relativePath === '' || !relativePath.startsWith('..');
+  }
+}
+
+class SourceFileScanner {
+  static async walkSourceFiles(dir, srcPaths, acc = []) {
+    const entries = await fs__default$1.default.readdir(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const entryPath = path__default.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SourceFileFilter.shouldEnterDirectory(entryPath, srcPaths)) {
+          continue;
+        }
+        await SourceFileScanner.walkSourceFiles(entryPath, srcPaths, acc);
+      } else {
+        if (SourceFileFilter.isSourceFile(entry.name)) {
+          acc.push(entryPath);
+        }
+      }
+    }
+    return acc;
+  }
+  static async getSourceFiles(srcPaths) {
+    const files = (await Promise.all(srcPaths.map(srcPath => SourceFileScanner.walkSourceFiles(srcPath, srcPaths)))).flat();
+    return new Set(files);
+  }
+}
+
+class SourceFileWatcher {
+  subscriptions = [];
+  constructor(roots, onChange) {
+    this.roots = roots;
+    this.onChange = onChange;
+  }
+  async start() {
+    if (this.subscriptions.length > 0) {
+      return;
+    }
+    const ignore = SourceFileFilter.IGNORED_DIRECTORIES.map(dir => `**/${dir}/**`);
+    for (const root of this.roots) {
+      const sub = await watcher.subscribe(root, async (err, events) => {
+        if (err) {
+          console.error(err);
+          return;
+        }
+        const filtered = await this.normalizeEvents(events);
+        if (filtered.length > 0) {
+          await this.onChange(filtered);
+        }
+      }, {
+        ignore
+      });
+      this.subscriptions.push(sub);
+    }
+  }
+  async normalizeEvents(events) {
+    const directoryCreatePaths = [];
+    const otherEvents = [];
+
+    // We need to expand directory creates because during rename operations,
+    // @parcel/watcher emits a directory create event but may not emit individual
+    // file events for the moved files
+    await Promise.all(events.map(async event => {
+      if (event.type === 'create') {
+        try {
+          const stats = await fs__default$1.default.stat(event.path);
+          if (stats.isDirectory()) {
+            directoryCreatePaths.push(event.path);
+            return;
+          }
+        } catch {
+          // Path doesn't exist or is inaccessible, treat as file
+        }
+      }
+      otherEvents.push(event);
+    }));
+
+    // Expand directory create events to find source files inside
+    let expandedCreateEvents = [];
+    if (directoryCreatePaths.length > 0) {
+      try {
+        const sourceFiles = await SourceFileScanner.getSourceFiles(directoryCreatePaths);
+        expandedCreateEvents = Array.from(sourceFiles).map(filePath => ({
+          type: 'create',
+          path: filePath
+        }));
+      } catch {
+        // Directories might have been deleted or are inaccessible
+      }
+    }
+
+    // Combine original events with expanded directory creates.
+    // Deduplicate by path to avoid processing the same file twice
+    // in case @parcel/watcher also emitted individual file events.
+    const allEvents = [...otherEvents, ...expandedCreateEvents];
+    const seenPaths = new Set();
+    const deduplicated = [];
+    for (const event of allEvents) {
+      const key = `${event.type}:${event.path}`;
+      if (!seenPaths.has(key)) {
+        seenPaths.add(key);
+        deduplicated.push(event);
+      }
+    }
+    return deduplicated.filter(event => {
+      // Keep all delete events (might be deleted directories that no longer exist)
+      if (event.type === 'delete') {
+        return true;
+      }
+      // Keep source files
+      return SourceFileFilter.isSourceFile(event.path);
+    });
+  }
+  async expandDirectoryDeleteEvents(events, prevKnownFiles) {
+    const expanded = [];
+    for (const event of events) {
+      if (event.type === 'delete' && !SourceFileFilter.isSourceFile(event.path)) {
+        const dirPath = path__default.default.resolve(event.path);
+        const filesInDirectory = [];
+        for (const filePath of prevKnownFiles) {
+          if (SourceFileFilter.isWithinPath(filePath, dirPath)) {
+            filesInDirectory.push(filePath);
+          }
+        }
+
+        // If we found files within this path, it was a directory
+        if (filesInDirectory.length > 0) {
+          for (const filePath of filesInDirectory) {
+            expanded.push({
+              type: 'delete',
+              path: filePath
+            });
+          }
+        } else {
+          // Not a directory or no files in it, pass through as-is
+          expanded.push(event);
+        }
+      } else {
+        // Pass through as-is
+        expanded.push(event);
+      }
+    }
+    return expanded;
+  }
+  async stop() {
+    await Promise.all(this.subscriptions.map(sub => sub.unsubscribe()));
+    this.subscriptions = [];
+  }
+  [Symbol.dispose]() {
+    void this.stop();
+  }
+}
+
+function normalizePathToPosix(filePath) {
+  // `path.relative` uses OS-specific separators. For stable `.po` references we
+  // always use POSIX separators, regardless of the OS that ran extraction.
+  return path__default.default.posix.normalize(filePath.split(path__default.default.win32.sep).join(path__default.default.posix.sep));
+}
+function hasLocalesToExtract(config) {
+  const {
+    locales
+  } = config.extract;
+  return locales === 'infer' || locales.length > 0;
+}
+function warnAboutMissingReferences(messages) {
+  const warnedIds = new Set();
+  for (const message of messages) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (message.references[0] == null && !warnedIds.has(message.id)) {
+      warnedIds.add(message.id);
+      warn(`Missing file reference for extracted message: ${message.id}`);
+    }
+  }
+}
+function localeCompare(a, b) {
+  return a.localeCompare(b, 'en');
+}
+function compareReferences(refA, refB) {
+  const pathCompare = localeCompare(refA.path, refB.path);
+  if (pathCompare !== 0) return pathCompare;
+  return (refA.line ?? 0) - (refB.line ?? 0) || (refA.column ?? 0) - (refB.column ?? 0);
+}
+function getDefaultProjectRoot() {
+  return process.cwd();
+}
+
+class CatalogLocales {
+  onChangeCallbacks = new Set();
+  constructor(params) {
+    this.messagesDir = params.messagesDir;
+    this.sourceLocale = params.sourceLocale;
+    this.extension = params.extension;
+    this.locales = params.locales;
+  }
+  async getTargetLocales() {
+    if (this.targetLocales) {
+      return this.targetLocales;
+    }
+    if (this.locales === 'infer') {
+      this.targetLocales = await this.readTargetLocales();
+    } else {
+      this.targetLocales = this.locales.filter(locale => locale !== this.sourceLocale);
+    }
+    return this.targetLocales;
+  }
+  async readTargetLocales() {
+    try {
+      const files = await fs__default$1.default.readdir(this.messagesDir);
+      return files.filter(file => file.endsWith(this.extension)).map(file => path__default.default.basename(file, this.extension)).filter(locale => locale !== this.sourceLocale);
+    } catch {
+      return [];
+    }
+  }
+  subscribeLocalesChange(callback) {
+    this.onChangeCallbacks.add(callback);
+    if (this.locales === 'infer' && !this.watcher) {
+      void this.startWatcher();
+    }
+  }
+  unsubscribeLocalesChange(callback) {
+    this.onChangeCallbacks.delete(callback);
+    if (this.onChangeCallbacks.size === 0) {
+      this.stopWatcher();
+    }
+  }
+  async startWatcher() {
+    if (this.watcher) {
+      return;
+    }
+    await fs__default$1.default.mkdir(this.messagesDir, {
+      recursive: true
+    });
+    this.watcher = fs__default.default.watch(this.messagesDir, {
+      persistent: false,
+      recursive: false
+    }, (event, filename) => {
+      const isCatalogFile = filename != null && filename.endsWith(this.extension) && !filename.includes(path__default.default.sep);
+      if (isCatalogFile) {
+        void this.onChange();
+      }
+    });
+  }
+  stopWatcher() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
+    }
+  }
+  async onChange() {
+    const oldLocales = new Set(this.targetLocales || []);
+    this.targetLocales = await this.readTargetLocales();
+    const newLocalesSet = new Set(this.targetLocales);
+    const added = this.targetLocales.filter(locale => !oldLocales.has(locale));
+    const removed = Array.from(oldLocales).filter(locale => !newLocalesSet.has(locale));
+    if (added.length > 0 || removed.length > 0) {
+      for (const callback of this.onChangeCallbacks) {
+        callback({
+          added,
+          removed
+        });
+      }
+    }
+  }
+}
+
+class CatalogPersister {
+  constructor(params) {
+    this.messagesPath = params.messagesPath;
+    this.codec = params.codec;
+    this.extension = params.extension;
+    this.sourceLocale = params.sourceLocale;
+  }
+  getFileName(locale) {
+    return locale + this.extension;
+  }
+  getFilePath(locale) {
+    return path__default.default.join(this.messagesPath, this.getFileName(locale));
+  }
+  async read(locale) {
+    const filePath = this.getFilePath(locale);
+    let content;
+    try {
+      content = await fs__default$1.default.readFile(filePath, 'utf8');
+    } catch (error) {
+      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+        return [];
+      }
+      throw new Error(`Error while reading ${this.getFileName(locale)}:\n> ${error}`, {
+        cause: error
+      });
+    }
+    try {
+      const messages = this.codec.decode(content, {
+        locale,
+        sourceLocale: this.sourceLocale
+      });
+      assertNoArrayMessages(messages);
+      return messages;
+    } catch (error) {
+      throw new Error(`Error while decoding ${this.getFileName(locale)}:\n> ${error}`, {
+        cause: error
+      });
+    }
+  }
+  async write(messages, context) {
+    const filePath = this.getFilePath(context.locale);
+    warnAboutMissingReferences(messages);
+    const content = this.codec.encode(messages, context);
+    try {
+      const outputDir = path__default.default.dirname(filePath);
+      await fs__default$1.default.mkdir(outputDir, {
+        recursive: true
+      });
+      await fs__default$1.default.writeFile(filePath, content);
+    } catch (error) {
+      console.error(`❌ Failed to write catalog: ${error}`);
+    }
+  }
+  async getLastModified(locale) {
+    const filePath = this.getFilePath(locale);
+    try {
+      const stats = await fs__default$1.default.stat(filePath);
+      return stats.mtime;
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+// The codecs read arrays fine (numeric path segments), but the runtime only
+// supports strings — enforced here where the runtime's rules apply.
+function assertNoArrayMessages(messages) {
+  for (const message of messages) {
+    const segments = message.segments;
+    if (!Array.isArray(segments)) continue;
+    const firstIndex = segments.findIndex(segment => typeof segment === 'number');
+    if (firstIndex === -1) continue;
+    const arrayPath = segments.slice(0, firstIndex).join('.');
+    throw new Error(`Message at \`${arrayPath}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages`);
+  }
+}
+
+/**
+ * De-duplicates excessive save invocations,
+ * while keeping a single one instant.
+ */
+class SaveScheduler {
+  isSaving = false;
+  pendingResolvers = [];
+  constructor(delayMs = 50) {
+    this.delayMs = delayMs;
+  }
+  async schedule(saveTask) {
+    return new Promise((resolve, reject) => {
+      this.pendingResolvers.push({
+        resolve,
+        reject
+      });
+      this.nextSaveTask = saveTask;
+      if (!this.isSaving && !this.saveTimeout) {
+        // Not currently saving and no scheduled save, save immediately
+        this.executeSave();
+      } else if (this.saveTimeout) {
+        // A save is already scheduled, reschedule to debounce
+        this.scheduleSave();
+      }
+      // If isSaving is true and no timeout is scheduled, the current save
+      // will check for pending resolvers when it completes and schedule
+      // another save if needed (see finally block in executeSave)
+    });
+  }
+  scheduleSave() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+    }
+    this.saveTimeout = setTimeout(() => {
+      this.saveTimeout = undefined;
+      this.executeSave();
+    }, this.delayMs);
+  }
+  async executeSave() {
+    if (this.isSaving) {
+      return;
+    }
+    const saveTask = this.nextSaveTask;
+    if (!saveTask) {
+      return;
+    }
+
+    // Capture current pending resolvers for this save
+    const resolversForThisSave = this.pendingResolvers;
+    this.pendingResolvers = [];
+    this.nextSaveTask = undefined;
+    this.isSaving = true;
+    try {
+      const result = await saveTask();
+
+      // Resolve only the promises that were pending when this save started
+      resolversForThisSave.forEach(({
+        resolve
+      }) => resolve(result));
+    } catch (error) {
+      // Reject only the promises that were pending when this save started
+      resolversForThisSave.forEach(({
+        reject
+      }) => reject(error));
+    } finally {
+      this.isSaving = false;
+
+      // If new saves were requested during this save, schedule another
+      if (this.pendingResolvers.length > 0) {
+        this.scheduleSave();
+      }
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = undefined;
+    }
+    this.pendingResolvers = [];
+    this.nextSaveTask = undefined;
+    this.isSaving = false;
+  }
+}
+
+class CatalogManager {
+  /**
+   * 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.
+   */
+  sourceMessagesByFile = new Map();
+
+  /**
+   * Reverse index for rebuilding aggregated messages without scanning all files.
+   * Contains the same `SourceExtractedMessage` 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();
+
+  /**
+   * This potentially also includes outdated ones that were initially available,
+   * but are not used anymore. This allows to restore them if they are used again.
+   **/
+  translationsByTargetLocale = new Map();
+  lastWriteByLocale = new Map();
+
+  // Cached instances
+
+  // Resolves when all catalogs are loaded
+
+  // Resolves when the initial project scan and processing is complete
+
+  constructor(config, opts) {
+    this.config = config;
+    this.saveScheduler = new SaveScheduler(opts.saveDebounceMs ?? 50);
+    this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
+    this.isDevelopment = opts.isDevelopment ?? false;
+    this.extractor = opts.extractor;
+    if (this.isDevelopment) {
+      // We kick this off as early as possible, so we get notified about changes
+      // that happen during the initial project scan (while awaiting it to
+      // complete though)
+      this.sourceWatcher = new SourceFileWatcher(this.getSrcPaths(), this.handleFileEvents.bind(this));
+      void this.sourceWatcher.start();
+    }
+  }
+  async getCodec() {
+    if (!this.codec) {
+      this.codec = await resolveCodec(this.config.messages.format, this.projectRoot);
+    }
+    return this.codec;
+  }
+  async getPersister() {
+    if (this.persister) {
+      return this.persister;
+    } else {
+      this.persister = new CatalogPersister({
+        messagesPath: this.config.extract.path,
+        codec: await this.getCodec(),
+        extension: getFormatExtension(this.config.messages.format),
+        sourceLocale: this.config.extract.sourceLocale
+      });
+      return this.persister;
+    }
+  }
+  getCatalogLocales() {
+    if (this.catalogLocales) {
+      return this.catalogLocales;
+    } else {
+      const messagesDir = path__default.default.join(this.projectRoot, this.config.extract.path);
+      this.catalogLocales = new CatalogLocales({
+        messagesDir,
+        extension: getFormatExtension(this.config.messages.format),
+        locales: this.config.extract.locales,
+        sourceLocale: this.config.extract.sourceLocale
+      });
+      return this.catalogLocales;
+    }
+  }
+  async getTargetLocales() {
+    return this.getCatalogLocales().getTargetLocales();
+  }
+  getSrcPaths() {
+    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 = 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;
+    if (this.isDevelopment) {
+      const catalogLocales = this.getCatalogLocales();
+      catalogLocales.subscribeLocalesChange(this.onLocalesChange);
+    }
+  }
+  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.extract.sourceLocale);
+    const byId = new Map();
+    for (const diskMessage of diskMessages) {
+      byId.set(diskMessage.id, diskMessage);
+    }
+    return byId;
+  }
+  async loadLocaleMessages(locale) {
+    const persister = await this.getPersister();
+    const messages = await persister.read(locale);
+    const fileTime = await persister.getLastModified(locale);
+    this.lastWriteByLocale.set(locale, fileTime);
+    return messages;
+  }
+  async loadTargetMessages() {
+    const targetLocales = await this.getTargetLocales();
+    await Promise.all(targetLocales.map(locale => this.reloadLocaleCatalog(locale)));
+  }
+  async reloadLocaleCatalog(locale) {
+    const diskMessages = await this.loadLocaleMessages(locale);
+    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) {
+          for (const key of Object.keys(diskMessage)) {
+            if (!CatalogManager.extractorOwnedAggregatorKeys.has(key)) {
+              // For unknown properties (like flags), disk wins
+              prev[key] = diskMessage[key];
+            }
+          }
+        }
+      }
+    } else {
+      // For target: disk wins completely, BUT preserve existing translations
+      // if we read empty (likely a write in progress by an external tool
+      // that causes the file to temporarily be empty)
+      const existingTranslations = this.translationsByTargetLocale.get(locale);
+      const hasExistingTranslations = existingTranslations && existingTranslations.size > 0;
+      if (diskMessages.length > 0) {
+        // We got content from disk, replace with it
+        const translations = new Map();
+        for (const message of diskMessages) {
+          translations.set(message.id, message);
+        }
+        this.translationsByTargetLocale.set(locale, translations);
+      } else if (hasExistingTranslations) ; else {
+        // We read empty and have no existing translations
+        const translations = new Map();
+        this.translationsByTargetLocale.set(locale, translations);
+      }
+    }
+  }
+  mergeSourceDiskMetadata(diskMessages) {
+    for (const [id, diskMessage] of diskMessages) {
+      const existing = this.messagesById.get(id);
+      if (!existing) continue;
+
+      // Fill unknown metadata from disk without replacing extraction-owned fields.
+      for (const key of Object.keys(diskMessage)) {
+        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');
+      let extraction;
+      try {
+        extraction = await this.extractor.extract(absoluteFilePath, content);
+      } catch {
+        return undefined;
+      }
+      messages = extraction.messages;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw err;
+      }
+      // ENOENT -> treat as no messages
+    }
+    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);
+        }
+      }
+      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.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 {
+        result.set(message.id, [message]);
+      }
+    }
+    return result;
+  }
+  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
+    if (!beforeMessages) {
+      return afterMessages.size > 0;
+    }
+
+    // Different sizes means changes
+    if (beforeMessages.size !== afterMessages.size) {
+      return true;
+    }
+
+    // Check differences in beforeMessages vs afterMessages
+    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;
+  }
+  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 && msg1.reference.column === msg2.reference.column;
+  }
+  async save() {
+    return this.saveScheduler.schedule(() => this.saveImpl());
+  }
+  async saveImpl() {
+    await this.saveLocale(this.config.extract.sourceLocale);
+    const targetLocales = await this.getTargetLocales();
+    await Promise.all(targetLocales.map(locale => this.saveLocale(locale)));
+  }
+  async saveLocale(locale) {
+    await this.loadCatalogsPromise;
+    const messages = Array.from(this.messagesById.values());
+    const persister = await this.getPersister();
+    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)
+    const lastWriteTime = this.lastWriteByLocale.get(locale);
+    const currentFileTime = await persister.getLastModified(locale);
+    if (currentFileTime && lastWriteTime && currentFileTime > lastWriteTime) {
+      await this.reloadLocaleCatalog(locale);
+    }
+    const localeMessages = isSourceLocale ? this.messagesById : this.translationsByTargetLocale.get(locale);
+    const messagesToPersist = messages.map(message => {
+      const localeMessage = localeMessages?.get(message.id);
+      return {
+        ...localeMessage,
+        id: message.id,
+        description: message.description,
+        references: message.references,
+        message: isSourceLocale ? message.message : localeMessage?.message ?? ''
+      };
+    });
+    await persister.write(messagesToPersist, {
+      locale,
+      sourceMessagesById: this.messagesById
+    });
+
+    // Update timestamps
+    const newTime = await persister.getLastModified(locale);
+    this.lastWriteByLocale.set(locale, newTime);
+  }
+  onLocalesChange = async params => {
+    // Chain to existing promise
+    this.loadCatalogsPromise = Promise.all([this.loadCatalogsPromise, ...params.added.map(locale => this.reloadLocaleCatalog(locale))]);
+    for (const locale of params.added) {
+      await this.saveLocale(locale);
+    }
+    for (const locale of params.removed) {
+      this.translationsByTargetLocale.delete(locale);
+      this.lastWriteByLocale.delete(locale);
+    }
+  };
+  async handleFileEvents(events) {
+    if (this.loadCatalogsPromise) {
+      await this.loadCatalogsPromise;
+    }
+
+    // Wait for initial scan to complete to avoid race conditions
+    if (this.scanCompletePromise) {
+      await this.scanCompletePromise;
+    }
+    let changed = false;
+    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;
+    }
+    if (changed) {
+      await this.save();
+    }
+  }
+  [Symbol.dispose]() {
+    this.sourceWatcher?.stop();
+    this.sourceWatcher = undefined;
+    this.saveScheduler[Symbol.dispose]();
+    if (this.catalogLocales && this.isDevelopment) {
+      this.catalogLocales.unsubscribeLocalesChange(this.onLocalesChange);
+    }
+  }
+}
+
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = new Map();
+  }
+  set(key, value) {
+    const isNewKey = !this.cache.has(key);
+    if (isNewKey && this.cache.size >= this.maxSize) {
+      const lruKey = this.cache.keys().next().value;
+      if (lruKey !== undefined) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, {
+      key,
+      value
+    });
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (item) {
+      this.cache.delete(key);
+      this.cache.set(key, item);
+      return item.value;
+    }
+    return undefined;
+  }
+}
+
+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.cjs', document.baseURI).href)));
+class MessageExtractor {
+  compileCache = new LRUCache(750);
+  constructor(opts) {
+    this.isDevelopment = opts.isDevelopment ?? false;
+    this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
+    this.sourceMap = opts.sourceMap ?? false;
+  }
+  async extract(absoluteFilePath, source) {
+    const cacheKey = [source, absoluteFilePath].join('!');
+    const cached = this.compileCache.get(cacheKey);
+    if (cached) return cached;
+
+    // Shortcut parsing if hook is not used. The Turbopack integration already
+    // pre-filters this, but for webpack this feature doesn't exist, so we need
+    // to do it here.
+    if (!source.includes('useExtracted') && !source.includes('getExtracted')) {
+      return {
+        messages: [],
+        code: source
+      };
+    }
+    const filePath = normalizePathToPosix(path__default.default.relative(this.projectRoot, absoluteFilePath));
+    const result = await core.transform(source, {
+      jsc: {
+        target: 'esnext',
+        parser: {
+          syntax: 'typescript',
+          tsx: true,
+          decorators: true
+        },
+        experimental: {
+          cacheRoot: 'node_modules/.cache/swc',
+          disableBuiltinTransformsForInternalTesting: true,
+          disableAllLints: true,
+          plugins: [[require$2.resolve('next-intl-swc-plugin-extractor'), {
+            isDevelopment: this.isDevelopment,
+            filePath
+          }]]
+        }
+      },
+      sourceMaps: this.sourceMap,
+      // Is converted into a relative path by Next.js when
+      // the final source map is generated
+      sourceFileName: absoluteFilePath,
+      filename: filePath
+    });
+
+    // TODO: Improve the typing of @swc/core
+    const output = result.output;
+    // The plugin emits a tagged union of extracted messages and
+    // `useTranslations` usages; this extractor only consumes the former.
+    const messages = JSON.parse(JSON.parse(output).results).filter(item => item.type === 'extracted').map(item => ({
+      id: item.id,
+      message: item.message,
+      description: item.description,
+      reference: item.reference
+    }));
+    const extractionResult = {
+      code: result.code,
+      map: result.map,
+      messages
+    };
+    this.compileCache.set(cacheKey, extractionResult);
+    return extractionResult;
+  }
+}
+
+class ExtractionCompiler {
+  constructor(config, opts = {}) {
+    const extractor = opts.extractor ?? new MessageExtractor(opts);
+    this.manager = new CatalogManager(config, {
+      ...opts,
+      extractor
+    });
+    this[Symbol.dispose] = this[Symbol.dispose].bind(this);
+    this.installExitHandlers();
+  }
+  async extractAll() {
+    // We can't rely on all files being compiled (e.g. due to persistent
+    // caching), so loading the messages initially is necessary.
+    await this.manager.loadMessages();
+    await this.manager.save();
+  }
+  [Symbol.dispose]() {
+    this.uninstallExitHandlers();
+    this.manager[Symbol.dispose]();
+  }
+  installExitHandlers() {
+    const cleanup = this[Symbol.dispose];
+    process.on('exit', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+  }
+  uninstallExitHandlers() {
+    const cleanup = this[Symbol.dispose];
+    process.off('exit', cleanup);
+    process.off('SIGINT', cleanup);
+    process.off('SIGTERM', cleanup);
+  }
+}
+
+// Avoid rollup's `replace` plugin to compile this away
+const nodeEnvKey = 'NODE_ENV'.trim();
+
+// We avoid reading `argv.includes('dev')` related to
+// https://github.com/amannn/next-intl/issues/2006
+const isDevelopment = process.env[nodeEnvKey] === 'development';
+const isNextBuild = process.argv.includes('build');
+const isDevelopmentOrNextBuild = isDevelopment || isNextBuild;
+
+// Single compiler instance, initialized once per process
+let compiler;
+const runOnce = once('_NEXT_INTL_EXTRACT');
+function initExtractionCompiler(extractorConfig) {
+  if (!extractorConfig || !hasLocalesToExtract(extractorConfig)) {
+    return;
+  }
+
+  // Avoid running for:
+  // - info
+  // - start
+  // - typegen
+  //
+  // Doesn't consult Next.js config anyway:
+  // - lint
+  // - telemetry (however, the `detached-flush` DOES - see `createNextIntlPlugin`)
+  //
+  // What remains are:
+  // - dev (NODE_ENV=development)
+  // - build (NODE_ENV=production)
+  const shouldRun = isDevelopment || isNextBuild;
+  if (!shouldRun) return;
+  runOnce(() => {
+    compiler = new ExtractionCompiler(extractorConfig, {
+      isDevelopment,
+      projectRoot: process.cwd()
+    });
+
+    // Fire-and-forget: Start extraction, don't block config return.
+    // In dev mode, this also starts the file watcher.
+    // In prod, ideally we would wait until the extraction is complete,
+    // but we can't `await` anywhere (at least for Turbopack).
+    // The result is ok though, as if we encounter untranslated messages,
+    // we'll simply add empty messages to the catalog. So for actually
+    // running the app, there is no difference.
+    compiler.extractAll();
+    function cleanup() {
+      if (compiler) {
+        compiler[Symbol.dispose]();
+        compiler = undefined;
+      }
+    }
+    process.on('exit', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+  });
+}
+
+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.cjs', document.baseURI).href)));
+    const pkg = require$1('next/package.json');
+    return pkg.version;
+  } catch (error) {
+    throw new Error('Failed to get current Next.js version. This can happen if next-intl/plugin is imported into your app code outside of your next.config.js.', {
+      cause: error
+    });
+  }
+}
+function compareVersions(version1, version2) {
+  const v1Parts = version1.split('.').map(Number);
+  const v2Parts = version2.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const v1 = v1Parts[i] || 0;
+    const v2 = v2Parts[i] || 0;
+    if (v1 > v2) return 1;
+    if (v1 < v2) return -1;
+  }
+  return 0;
+}
+function hasStableTurboConfig() {
+  return compareVersions(getCurrentVersion(), '15.3.0') >= 0;
+}
+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.cjs', document.baseURI).href)));
+function withExtensions(localPath) {
+  return [`${localPath}.ts`, `${localPath}.tsx`, `${localPath}.js`, `${localPath}.jsx`];
+}
+function normalizeTurbopackAliasPath(pathname) {
+  // Turbopack alias targets should use forward slashes; Windows backslashes can
+  // break resolution in dev (see `next-intl/config` alias path style).
+  return pathname.replace(/\\/g, '/');
+}
+
+/**
+ * Turbopack validates loader options by comparing them to their JSON round-trip
+ * (`isDeepStrictEqual(options, JSON.parse(JSON.stringify(options)))`). Since
+ * `JSON.stringify` drops keys with an `undefined` value, such a key would always
+ * fail that check, therefore they're removed here.
+ * https://github.com/amannn/next-intl/issues/2394
+ */
+function pruneUndefined(value) {
+  if (Array.isArray(value)) {
+    return value.map(pruneUndefined);
+  }
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).map(([key, entry]) => [key, pruneUndefined(entry)]));
+  }
+  return value;
+}
+function resolveI18nPath(providedPath, cwd) {
+  function resolvePath(pathname) {
+    const parts = [];
+    if (cwd) parts.push(cwd);
+    parts.push(pathname);
+    return path__default.default.resolve(...parts);
+  }
+  function pathExists(pathname) {
+    return fs__default.default.existsSync(resolvePath(pathname));
+  }
+  if (providedPath) {
+    // We use the `isNextDevOrBuild` condition to avoid throwing errors
+    // if `next.config.ts` is read by a non-Next.js process.
+    // https://github.com/amannn/next-intl/discussions/2209#discussioncomment-15650927
+    if (isDevelopmentOrNextBuild && !pathExists(providedPath)) {
+      throwError(`Could not find i18n config at ${providedPath}, please provide a valid path.`);
+    }
+    return providedPath;
+  } else {
+    for (const candidate of [...withExtensions('./i18n/request'), ...withExtensions('./src/i18n/request')]) {
+      if (pathExists(candidate)) {
+        return candidate;
+      }
+    }
+    if (isDevelopmentOrNextBuild) {
+      throwError(`Could not locate request configuration module.\n\nThis path is supported by default: ./(src/)i18n/request.{js,jsx,ts,tsx}\n\nAlternatively, you can specify a custom location in your Next.js config:\n\nconst withNextIntl = createNextIntlPlugin(\n  './path/to/i18n/request.tsx'\n);`);
+    }
+
+    // Default as fallback
+    if (pathExists('./src')) {
+      return './src/i18n/request.ts';
+    } else {
+      return './i18n/request.ts';
+    }
+  }
+}
+function getNextConfig(pluginConfig, nextConfig, extractorConfig) {
+  const useTurbo = process.env.TURBOPACK != null;
+
+  // `experimental-analyze` doesn’t set the TURBOPACK env param. Since Next.js
+  // 16 doesn't print a warning when we configure both Turbo- and Webpack, just
+  // always configure Turbopack just in case.
+  const shouldConfigureTurbo = useTurbo || isNextJs16OrHigher();
+  const nextIntlConfig = {};
+  let messageLoadPaths = [];
+  if (pluginConfig.experimental?.messages) {
+    messageLoadPaths = normalizeMessagesCatalogPaths(pluginConfig.experimental.messages.path);
+  }
+  function getExtractMessagesLoaderConfig(config) {
+    return {
+      loader: 'next-intl/extractor/extractionLoader',
+      options: pruneUndefined(config)
+    };
+  }
+  function getCatalogLoaderConfig() {
+    const experimental = pluginConfig.experimental;
+    const messages = experimental.messages;
+    // Normalization enforces a source locale before extraction runs.
+    const sourceLocale = messages.sourceLocale ?? (typeof experimental.extract === 'object' ? experimental.extract.sourceLocale : undefined);
+    return {
+      loader: 'next-intl/extractor/catalogLoader',
+      options: pruneUndefined({
+        messages: {
+          format: messages.format,
+          precompile: messages.precompile,
+          sourceLocale
+        }
+      })
+    };
+  }
+  function getTurboRules() {
+    return nextConfig?.turbopack?.rules ||
+    // @ts-expect-error -- For Next.js <16
+    nextConfig?.experimental?.turbo?.rules || {};
+  }
+  function addTurboRule(rules, glob, rule) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (rules[glob]) {
+      if (Array.isArray(rules[glob])) {
+        rules[glob].push(rule);
+      } else {
+        rules[glob] = [rules[glob], rule];
+      }
+    } else {
+      rules[glob] = rule;
+    }
+  }
+  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);
+    }
+
+    // Assign alias for `next-intl/config`
+    const resolveAlias = {
+      // Turbo aliases don't work with absolute
+      // paths (see error handling above)
+      'next-intl/config': resolveI18nPath(pluginConfig.requestConfig)
+    };
+
+    // Add alias for precompiled message formatting
+    if (pluginConfig.experimental?.messages?.precompile) {
+      // Workaround for https://github.com/vercel/next.js/issues/88540
+      let formatOnlyPath = path__default.default.relative(process.cwd(), require$1.resolve('use-intl/format-message/format-only'));
+
+      // Turbopack seems to require this, otherwise `use-intl/format-message` is
+      // still bundled (despite the code correctly calling into `format-only`).
+      // Note that in this monorepo this is not necessary, because we'll end
+      // up with a path like `../…` — but for actual consumers this is required.
+      if (!formatOnlyPath.startsWith('.')) {
+        formatOnlyPath = `./${formatOnlyPath}`;
+      }
+      resolveAlias['use-intl/format-message'] = normalizeTurbopackAliasPath(formatOnlyPath);
+    }
+
+    // Add loaders
+    let rules;
+
+    // Add loader for extractor
+    if (pluginConfig.experimental?.extract) {
+      if (!isNextJs16OrHigher()) {
+        throwError('Message extraction requires Next.js 16 or higher.');
+      }
+      rules ??= getTurboRules();
+      addTurboRule(rules, `*.{${SourceFileFilter.EXTENSIONS.join(',')}}`, {
+        loaders: [getExtractMessagesLoaderConfig(extractorConfig)],
+        condition: {
+          // We don't filter for `path` here to allow transformation
+          // of `useExtracted` calls in external packages (e.g. monorepos)
+          content: /(useExtracted|getExtracted)/
+        }
+      });
+    }
+
+    // Add loader for catalog
+    if (pluginConfig.experimental?.messages) {
+      if (!isNextJs16OrHigher()) {
+        throwError('Message catalog loading requires Next.js 16 or higher.');
+      }
+      rules ??= getTurboRules();
+      const extension = getFormatExtension(pluginConfig.experimental.messages.format);
+      addTurboRule(rules, `*${extension}`, {
+        loaders: [getCatalogLoaderConfig()],
+        condition: {
+          path: `{${messageLoadPaths.join(',')}}/**/*`
+        },
+        as: '*.js'
+      });
+    }
+    if (hasStableTurboConfig() &&
+    // @ts-expect-error -- For Next.js <16
+    !nextConfig?.experimental?.turbo) {
+      nextIntlConfig.turbopack = {
+        ...nextConfig?.turbopack,
+        ...(rules && {
+          rules
+        }),
+        resolveAlias: {
+          ...nextConfig?.turbopack?.resolveAlias,
+          ...resolveAlias
+        }
+      };
+    } else {
+      nextIntlConfig.experimental = {
+        ...nextConfig?.experimental,
+        // @ts-expect-error -- For Next.js <16
+        turbo: {
+          // @ts-expect-error -- For Next.js <16
+          ...nextConfig?.experimental?.turbo,
+          ...(rules && {
+            rules
+          }),
+          resolveAlias: {
+            // @ts-expect-error -- For Next.js <16
+            ...nextConfig?.experimental?.turbo?.resolveAlias,
+            ...resolveAlias
+          }
+        }
+      };
+    }
+  }
+  if (!useTurbo) {
+    nextIntlConfig.webpack = function webpack(config, context) {
+      if (!config.resolve) config.resolve = {};
+      if (!config.resolve.alias) config.resolve.alias = {};
+
+      // Assign alias for `next-intl/config`
+      // (Webpack requires absolute paths)
+      config.resolve.alias['next-intl/config'] = path__default.default.resolve(config.context, resolveI18nPath(pluginConfig.requestConfig, config.context));
+
+      // Add alias for precompiled message formatting
+      if (pluginConfig.experimental?.messages?.precompile) {
+        // Use require.resolve to get the actual file path, since
+        // bundlers don't properly resolve package subpath exports
+        // when used as alias targets
+        config.resolve.alias['use-intl/format-message'] = require$1.resolve('use-intl/format-message/format-only');
+      }
+
+      // Add loader for extractor
+      if (pluginConfig.experimental?.extract) {
+        if (!config.module) config.module = {};
+        if (!config.module.rules) config.module.rules = [];
+        config.module.rules.push({
+          test: new RegExp(`\\.(${SourceFileFilter.EXTENSIONS.join('|')})$`),
+          use: [getExtractMessagesLoaderConfig(extractorConfig)]
+        });
+      }
+
+      // Add loader for catalog
+      if (pluginConfig.experimental?.messages) {
+        if (!config.module) config.module = {};
+        if (!config.module.rules) config.module.rules = [];
+        const extension = getFormatExtension(pluginConfig.experimental.messages.format);
+        config.module.rules.push({
+          test: new RegExp(`${extension.replace(/\./g, '\\.')}$`),
+          include: messageLoadPaths.map(dirPath => path__default.default.resolve(config.context, dirPath)),
+          use: [getCatalogLoaderConfig()],
+          type: 'javascript/auto'
+        });
+      }
+      if (typeof nextConfig?.webpack === 'function') {
+        return nextConfig.webpack(config, context);
+      }
+      return config;
+    };
+  }
+
+  // Forward config
+  const env = {};
+  if (nextConfig?.trailingSlash) {
+    env._next_intl_trailing_slash = 'true';
+  }
+  if (nextConfig?.basePath) {
+    env._next_intl_base_path = nextConfig.basePath;
+  }
+  // Note that `undefined` values are not supported by Turbopack
+  if (Object.keys(env).length > 0) {
+    nextIntlConfig.env = {
+      ...nextConfig?.env,
+      ...env
+    };
+  }
+  return Object.assign({}, nextConfig, nextIntlConfig);
+}
+
+function initPlugin(pluginConfig, nextConfig) {
+  if (nextConfig?.i18n != null) {
+    warn("An `i18n` property was found in your Next.js config. This likely causes conflicts and should therefore be removed if you use the App Router.\n\nIf you're in progress of migrating from the Pages Router, you can refer to this example: https://next-intl.dev/examples#app-router-migration\n");
+  }
+  const skipWatchers = isNextTelemetryDetachedFlushProcess();
+  const messagesPathOrPaths = pluginConfig.experimental?.createMessagesDeclaration;
+  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(extractorConfig);
+  }
+  return getNextConfig(pluginConfig, nextConfig, extractorConfig);
+}
+function createNextIntlPlugin(i18nPathOrConfig = {}) {
+  const config = typeof i18nPathOrConfig === 'string' ? {
+    requestConfig: i18nPathOrConfig
+  } : i18nPathOrConfig;
+  return function withNextIntl(nextConfig) {
+    return initPlugin(config, nextConfig);
+  };
+}
+
+/**
+ * Next runs `telemetry/detached-flush.js` in a detached process to flush telemetry
+ * (often when `next dev` exits). That loads dev `next.config` with inherited
+ * `NODE_ENV=development`, which would otherwise start orphan plugin watchers.
+ */
+function isNextTelemetryDetachedFlushProcess() {
+  const scriptPath = process.argv[1];
+  if (!scriptPath) return false;
+  const normalized = scriptPath.replace(/\\/g, '/');
+  return normalized.includes('/telemetry/detached-flush');
+}
+
+module.exports = createNextIntlPlugin;

e-commerce/node_modules/next-intl/dist/esm/development/config.js

@@ -0,0 +1,5 @@
+function getConfig() {
+  throw new Error("Couldn't find next-intl config file. Please follow the instructions at https://next-intl.dev/docs/getting-started/app-router");
+}
+
+export { getConfig as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor.js

@@ -0,0 +1,2 @@
+export { default as unstable_extractMessages } from './extractor/extractMessages.js';
+export { defineCodec } from './extractor/format/ExtractorCodec.js';

e-commerce/node_modules/next-intl/dist/esm/development/extractor/ExtractionCompiler.js

@@ -0,0 +1,38 @@
+import CatalogManager from './catalog/CatalogManager.js';
+import MessageExtractor from './extractor/MessageExtractor.js';
+
+class ExtractionCompiler {
+  constructor(config, opts = {}) {
+    const extractor = opts.extractor ?? new MessageExtractor(opts);
+    this.manager = new CatalogManager(config, {
+      ...opts,
+      extractor
+    });
+    this[Symbol.dispose] = this[Symbol.dispose].bind(this);
+    this.installExitHandlers();
+  }
+  async extractAll() {
+    // We can't rely on all files being compiled (e.g. due to persistent
+    // caching), so loading the messages initially is necessary.
+    await this.manager.loadMessages();
+    await this.manager.save();
+  }
+  [Symbol.dispose]() {
+    this.uninstallExitHandlers();
+    this.manager[Symbol.dispose]();
+  }
+  installExitHandlers() {
+    const cleanup = this[Symbol.dispose];
+    process.on('exit', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+  }
+  uninstallExitHandlers() {
+    const cleanup = this[Symbol.dispose];
+    process.off('exit', cleanup);
+    process.off('SIGINT', cleanup);
+    process.off('SIGTERM', cleanup);
+  }
+}
+
+export { ExtractionCompiler as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/catalog/CatalogLocales.js

@@ -0,0 +1,84 @@
+import fs$1 from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+
+class CatalogLocales {
+  onChangeCallbacks = new Set();
+  constructor(params) {
+    this.messagesDir = params.messagesDir;
+    this.sourceLocale = params.sourceLocale;
+    this.extension = params.extension;
+    this.locales = params.locales;
+  }
+  async getTargetLocales() {
+    if (this.targetLocales) {
+      return this.targetLocales;
+    }
+    if (this.locales === 'infer') {
+      this.targetLocales = await this.readTargetLocales();
+    } else {
+      this.targetLocales = this.locales.filter(locale => locale !== this.sourceLocale);
+    }
+    return this.targetLocales;
+  }
+  async readTargetLocales() {
+    try {
+      const files = await fs.readdir(this.messagesDir);
+      return files.filter(file => file.endsWith(this.extension)).map(file => path.basename(file, this.extension)).filter(locale => locale !== this.sourceLocale);
+    } catch {
+      return [];
+    }
+  }
+  subscribeLocalesChange(callback) {
+    this.onChangeCallbacks.add(callback);
+    if (this.locales === 'infer' && !this.watcher) {
+      void this.startWatcher();
+    }
+  }
+  unsubscribeLocalesChange(callback) {
+    this.onChangeCallbacks.delete(callback);
+    if (this.onChangeCallbacks.size === 0) {
+      this.stopWatcher();
+    }
+  }
+  async startWatcher() {
+    if (this.watcher) {
+      return;
+    }
+    await fs.mkdir(this.messagesDir, {
+      recursive: true
+    });
+    this.watcher = fs$1.watch(this.messagesDir, {
+      persistent: false,
+      recursive: false
+    }, (event, filename) => {
+      const isCatalogFile = filename != null && filename.endsWith(this.extension) && !filename.includes(path.sep);
+      if (isCatalogFile) {
+        void this.onChange();
+      }
+    });
+  }
+  stopWatcher() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
+    }
+  }
+  async onChange() {
+    const oldLocales = new Set(this.targetLocales || []);
+    this.targetLocales = await this.readTargetLocales();
+    const newLocalesSet = new Set(this.targetLocales);
+    const added = this.targetLocales.filter(locale => !oldLocales.has(locale));
+    const removed = Array.from(oldLocales).filter(locale => !newLocalesSet.has(locale));
+    if (added.length > 0 || removed.length > 0) {
+      for (const callback of this.onChangeCallbacks) {
+        callback({
+          added,
+          removed
+        });
+      }
+    }
+  }
+}
+
+export { CatalogLocales as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/catalog/CatalogManager.js

@@ -0,0 +1,422 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { resolveCodec, getFormatExtension } from '../format/index.js';
+import SourceFileScanner from '../source/SourceFileScanner.js';
+import SourceFileWatcher from '../source/SourceFileWatcher.js';
+import { getDefaultProjectRoot, localeCompare, compareReferences } from '../utils.js';
+import CatalogLocales from './CatalogLocales.js';
+import CatalogPersister from './CatalogPersister.js';
+import SaveScheduler from './SaveScheduler.js';
+
+class CatalogManager {
+  /**
+   * 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.
+   */
+  sourceMessagesByFile = new Map();
+
+  /**
+   * Reverse index for rebuilding aggregated messages without scanning all files.
+   * Contains the same `SourceExtractedMessage` 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();
+
+  /**
+   * This potentially also includes outdated ones that were initially available,
+   * but are not used anymore. This allows to restore them if they are used again.
+   **/
+  translationsByTargetLocale = new Map();
+  lastWriteByLocale = new Map();
+
+  // Cached instances
+
+  // Resolves when all catalogs are loaded
+
+  // Resolves when the initial project scan and processing is complete
+
+  constructor(config, opts) {
+    this.config = config;
+    this.saveScheduler = new SaveScheduler(opts.saveDebounceMs ?? 50);
+    this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
+    this.isDevelopment = opts.isDevelopment ?? false;
+    this.extractor = opts.extractor;
+    if (this.isDevelopment) {
+      // We kick this off as early as possible, so we get notified about changes
+      // that happen during the initial project scan (while awaiting it to
+      // complete though)
+      this.sourceWatcher = new SourceFileWatcher(this.getSrcPaths(), this.handleFileEvents.bind(this));
+      void this.sourceWatcher.start();
+    }
+  }
+  async getCodec() {
+    if (!this.codec) {
+      this.codec = await resolveCodec(this.config.messages.format, this.projectRoot);
+    }
+    return this.codec;
+  }
+  async getPersister() {
+    if (this.persister) {
+      return this.persister;
+    } else {
+      this.persister = new CatalogPersister({
+        messagesPath: this.config.extract.path,
+        codec: await this.getCodec(),
+        extension: getFormatExtension(this.config.messages.format),
+        sourceLocale: this.config.extract.sourceLocale
+      });
+      return this.persister;
+    }
+  }
+  getCatalogLocales() {
+    if (this.catalogLocales) {
+      return this.catalogLocales;
+    } else {
+      const messagesDir = path.join(this.projectRoot, this.config.extract.path);
+      this.catalogLocales = new CatalogLocales({
+        messagesDir,
+        extension: getFormatExtension(this.config.messages.format),
+        locales: this.config.extract.locales,
+        sourceLocale: this.config.extract.sourceLocale
+      });
+      return this.catalogLocales;
+    }
+  }
+  async getTargetLocales() {
+    return this.getCatalogLocales().getTargetLocales();
+  }
+  getSrcPaths() {
+    return (Array.isArray(this.config.extract.srcPath) ? this.config.extract.srcPath : [this.config.extract.srcPath]).map(srcPath => path.join(this.projectRoot, srcPath));
+  }
+  async loadMessages() {
+    const sourceDiskMessages = await this.loadSourceMessages();
+    this.loadCatalogsPromise = this.loadTargetMessages();
+    await this.loadCatalogsPromise;
+    this.scanCompletePromise = (async () => {
+      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;
+    if (this.isDevelopment) {
+      const catalogLocales = this.getCatalogLocales();
+      catalogLocales.subscribeLocalesChange(this.onLocalesChange);
+    }
+  }
+  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.extract.sourceLocale);
+    const byId = new Map();
+    for (const diskMessage of diskMessages) {
+      byId.set(diskMessage.id, diskMessage);
+    }
+    return byId;
+  }
+  async loadLocaleMessages(locale) {
+    const persister = await this.getPersister();
+    const messages = await persister.read(locale);
+    const fileTime = await persister.getLastModified(locale);
+    this.lastWriteByLocale.set(locale, fileTime);
+    return messages;
+  }
+  async loadTargetMessages() {
+    const targetLocales = await this.getTargetLocales();
+    await Promise.all(targetLocales.map(locale => this.reloadLocaleCatalog(locale)));
+  }
+  async reloadLocaleCatalog(locale) {
+    const diskMessages = await this.loadLocaleMessages(locale);
+    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) {
+          for (const key of Object.keys(diskMessage)) {
+            if (!CatalogManager.extractorOwnedAggregatorKeys.has(key)) {
+              // For unknown properties (like flags), disk wins
+              prev[key] = diskMessage[key];
+            }
+          }
+        }
+      }
+    } else {
+      // For target: disk wins completely, BUT preserve existing translations
+      // if we read empty (likely a write in progress by an external tool
+      // that causes the file to temporarily be empty)
+      const existingTranslations = this.translationsByTargetLocale.get(locale);
+      const hasExistingTranslations = existingTranslations && existingTranslations.size > 0;
+      if (diskMessages.length > 0) {
+        // We got content from disk, replace with it
+        const translations = new Map();
+        for (const message of diskMessages) {
+          translations.set(message.id, message);
+        }
+        this.translationsByTargetLocale.set(locale, translations);
+      } else if (hasExistingTranslations) ; else {
+        // We read empty and have no existing translations
+        const translations = new Map();
+        this.translationsByTargetLocale.set(locale, translations);
+      }
+    }
+  }
+  mergeSourceDiskMetadata(diskMessages) {
+    for (const [id, diskMessage] of diskMessages) {
+      const existing = this.messagesById.get(id);
+      if (!existing) continue;
+
+      // Fill unknown metadata from disk without replacing extraction-owned fields.
+      for (const key of Object.keys(diskMessage)) {
+        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.readFile(absoluteFilePath, 'utf8');
+      let extraction;
+      try {
+        extraction = await this.extractor.extract(absoluteFilePath, content);
+      } catch {
+        return undefined;
+      }
+      messages = extraction.messages;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw err;
+      }
+      // ENOENT -> treat as no messages
+    }
+    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);
+        }
+      }
+      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.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 {
+        result.set(message.id, [message]);
+      }
+    }
+    return result;
+  }
+  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
+    if (!beforeMessages) {
+      return afterMessages.size > 0;
+    }
+
+    // Different sizes means changes
+    if (beforeMessages.size !== afterMessages.size) {
+      return true;
+    }
+
+    // Check differences in beforeMessages vs afterMessages
+    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;
+  }
+  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 && msg1.reference.column === msg2.reference.column;
+  }
+  async save() {
+    return this.saveScheduler.schedule(() => this.saveImpl());
+  }
+  async saveImpl() {
+    await this.saveLocale(this.config.extract.sourceLocale);
+    const targetLocales = await this.getTargetLocales();
+    await Promise.all(targetLocales.map(locale => this.saveLocale(locale)));
+  }
+  async saveLocale(locale) {
+    await this.loadCatalogsPromise;
+    const messages = Array.from(this.messagesById.values());
+    const persister = await this.getPersister();
+    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)
+    const lastWriteTime = this.lastWriteByLocale.get(locale);
+    const currentFileTime = await persister.getLastModified(locale);
+    if (currentFileTime && lastWriteTime && currentFileTime > lastWriteTime) {
+      await this.reloadLocaleCatalog(locale);
+    }
+    const localeMessages = isSourceLocale ? this.messagesById : this.translationsByTargetLocale.get(locale);
+    const messagesToPersist = messages.map(message => {
+      const localeMessage = localeMessages?.get(message.id);
+      return {
+        ...localeMessage,
+        id: message.id,
+        description: message.description,
+        references: message.references,
+        message: isSourceLocale ? message.message : localeMessage?.message ?? ''
+      };
+    });
+    await persister.write(messagesToPersist, {
+      locale,
+      sourceMessagesById: this.messagesById
+    });
+
+    // Update timestamps
+    const newTime = await persister.getLastModified(locale);
+    this.lastWriteByLocale.set(locale, newTime);
+  }
+  onLocalesChange = async params => {
+    // Chain to existing promise
+    this.loadCatalogsPromise = Promise.all([this.loadCatalogsPromise, ...params.added.map(locale => this.reloadLocaleCatalog(locale))]);
+    for (const locale of params.added) {
+      await this.saveLocale(locale);
+    }
+    for (const locale of params.removed) {
+      this.translationsByTargetLocale.delete(locale);
+      this.lastWriteByLocale.delete(locale);
+    }
+  };
+  async handleFileEvents(events) {
+    if (this.loadCatalogsPromise) {
+      await this.loadCatalogsPromise;
+    }
+
+    // Wait for initial scan to complete to avoid race conditions
+    if (this.scanCompletePromise) {
+      await this.scanCompletePromise;
+    }
+    let changed = false;
+    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;
+    }
+    if (changed) {
+      await this.save();
+    }
+  }
+  [Symbol.dispose]() {
+    this.sourceWatcher?.stop();
+    this.sourceWatcher = undefined;
+    this.saveScheduler[Symbol.dispose]();
+    if (this.catalogLocales && this.isDevelopment) {
+      this.catalogLocales.unsubscribeLocalesChange(this.onLocalesChange);
+    }
+  }
+}
+
+export { CatalogManager as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/catalog/CatalogPersister.js

@@ -0,0 +1,82 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { warnAboutMissingReferences } from '../utils.js';
+
+class CatalogPersister {
+  constructor(params) {
+    this.messagesPath = params.messagesPath;
+    this.codec = params.codec;
+    this.extension = params.extension;
+    this.sourceLocale = params.sourceLocale;
+  }
+  getFileName(locale) {
+    return locale + this.extension;
+  }
+  getFilePath(locale) {
+    return path.join(this.messagesPath, this.getFileName(locale));
+  }
+  async read(locale) {
+    const filePath = this.getFilePath(locale);
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch (error) {
+      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+        return [];
+      }
+      throw new Error(`Error while reading ${this.getFileName(locale)}:\n> ${error}`, {
+        cause: error
+      });
+    }
+    try {
+      const messages = this.codec.decode(content, {
+        locale,
+        sourceLocale: this.sourceLocale
+      });
+      assertNoArrayMessages(messages);
+      return messages;
+    } catch (error) {
+      throw new Error(`Error while decoding ${this.getFileName(locale)}:\n> ${error}`, {
+        cause: error
+      });
+    }
+  }
+  async write(messages, context) {
+    const filePath = this.getFilePath(context.locale);
+    warnAboutMissingReferences(messages);
+    const content = this.codec.encode(messages, context);
+    try {
+      const outputDir = path.dirname(filePath);
+      await fs.mkdir(outputDir, {
+        recursive: true
+      });
+      await fs.writeFile(filePath, content);
+    } catch (error) {
+      console.error(`❌ Failed to write catalog: ${error}`);
+    }
+  }
+  async getLastModified(locale) {
+    const filePath = this.getFilePath(locale);
+    try {
+      const stats = await fs.stat(filePath);
+      return stats.mtime;
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+// The codecs read arrays fine (numeric path segments), but the runtime only
+// supports strings — enforced here where the runtime's rules apply.
+function assertNoArrayMessages(messages) {
+  for (const message of messages) {
+    const segments = message.segments;
+    if (!Array.isArray(segments)) continue;
+    const firstIndex = segments.findIndex(segment => typeof segment === 'number');
+    if (firstIndex === -1) continue;
+    const arrayPath = segments.slice(0, firstIndex).join('.');
+    throw new Error(`Message at \`${arrayPath}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages`);
+  }
+}
+
+export { CatalogPersister as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/catalog/SaveScheduler.js

@@ -0,0 +1,85 @@
+/**
+ * De-duplicates excessive save invocations,
+ * while keeping a single one instant.
+ */
+class SaveScheduler {
+  isSaving = false;
+  pendingResolvers = [];
+  constructor(delayMs = 50) {
+    this.delayMs = delayMs;
+  }
+  async schedule(saveTask) {
+    return new Promise((resolve, reject) => {
+      this.pendingResolvers.push({
+        resolve,
+        reject
+      });
+      this.nextSaveTask = saveTask;
+      if (!this.isSaving && !this.saveTimeout) {
+        // Not currently saving and no scheduled save, save immediately
+        this.executeSave();
+      } else if (this.saveTimeout) {
+        // A save is already scheduled, reschedule to debounce
+        this.scheduleSave();
+      }
+      // If isSaving is true and no timeout is scheduled, the current save
+      // will check for pending resolvers when it completes and schedule
+      // another save if needed (see finally block in executeSave)
+    });
+  }
+  scheduleSave() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+    }
+    this.saveTimeout = setTimeout(() => {
+      this.saveTimeout = undefined;
+      this.executeSave();
+    }, this.delayMs);
+  }
+  async executeSave() {
+    if (this.isSaving) {
+      return;
+    }
+    const saveTask = this.nextSaveTask;
+    if (!saveTask) {
+      return;
+    }
+
+    // Capture current pending resolvers for this save
+    const resolversForThisSave = this.pendingResolvers;
+    this.pendingResolvers = [];
+    this.nextSaveTask = undefined;
+    this.isSaving = true;
+    try {
+      const result = await saveTask();
+
+      // Resolve only the promises that were pending when this save started
+      resolversForThisSave.forEach(({
+        resolve
+      }) => resolve(result));
+    } catch (error) {
+      // Reject only the promises that were pending when this save started
+      resolversForThisSave.forEach(({
+        reject
+      }) => reject(error));
+    } finally {
+      this.isSaving = false;
+
+      // If new saves were requested during this save, schedule another
+      if (this.pendingResolvers.length > 0) {
+        this.scheduleSave();
+      }
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = undefined;
+    }
+    this.pendingResolvers = [];
+    this.nextSaveTask = undefined;
+    this.isSaving = false;
+  }
+}
+
+export { SaveScheduler as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/catalogLoader.js

@@ -0,0 +1,118 @@
+import path from 'path';
+import compile from 'icu-minify/compile';
+import { getFormatExtension, resolveCodec } from './format/index.js';
+import { setNestedProperty } from './utils.js';
+
+// The module scope is safe for some caching, but Next.js can
+// create multiple loader instances so don't expect a singleton.
+let cachedCodec = null;
+let hasWarnedAboutToJSONString = false;
+const messageCacheByCatalog = new Map();
+function getMessageCache(catalogId) {
+  let cache = messageCacheByCatalog.get(catalogId);
+  if (!cache) {
+    cache = new Map();
+    messageCacheByCatalog.set(catalogId, cache);
+  }
+  return cache;
+}
+async function getCodec(options, projectRoot) {
+  if (!cachedCodec) {
+    cachedCodec = await resolveCodec(options.messages.format, projectRoot);
+  }
+  return cachedCodec;
+}
+
+/**
+ * Parses and optimizes catalog files.
+ *
+ * Note that if we use a dynamic import like `import(`${locale}.json`)`, then
+ * the loader will optimistically run for all candidates in this folder (both
+ * during dev as well as at build time).
+ */
+function catalogLoader(source) {
+  const options = this.getOptions();
+  const callback = this.async();
+  const extension = getFormatExtension(options.messages.format);
+  getCodec(options, this.rootContext).then(codec => {
+    warnIfToJSONStringProvided(codec);
+    const locale = path.basename(this.resourcePath, extension);
+    const decoded = codec.decode(source, {
+      locale,
+      sourceLocale: options.messages.sourceLocale
+    });
+    let messages;
+    if (options.messages.precompile) {
+      const cache = getMessageCache(this.resourcePath);
+      messages = precompileMessages(decoded, cache);
+    } else {
+      messages = buildMessages(decoded);
+    }
+
+    // https://v8.dev/blog/cost-of-javascript-2019#json
+    const result = `export default JSON.parse(${JSON.stringify(JSON.stringify(messages))});`;
+    callback(null, result);
+  }).catch(callback);
+}
+function warnIfToJSONStringProvided(codec) {
+  if (hasWarnedAboutToJSONString || !codec.toJSONString) return;
+  hasWarnedAboutToJSONString = true;
+  console.warn('`toJSONString` is deprecated and no longer needed, please remove it.');
+}
+
+/**
+ * Builds a nested messages object from decoded messages, mirroring the shape
+ * produced by `precompileMessages` but keeping the raw message strings.
+ */
+function buildMessages(messages) {
+  const result = Object.create(null);
+  for (const message of messages) {
+    assertStringMessage(message);
+    setNestedProperty(result, message.id, message.message);
+  }
+  return result;
+}
+function assertStringMessage(message) {
+  const messageValue = message.message;
+  if (Array.isArray(messageValue)) {
+    throw new Error(`Message at \`${message.id}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages`);
+  }
+  if (typeof messageValue === 'object') {
+    throw new Error(`Message at \`${message.id}\` resolved to \`${typeof messageValue}\`, but only strings are supported. Use a \`.\` to retrieve nested messages. See https://next-intl.dev/docs/usage/translations#structuring-messages`);
+  }
+}
+
+/**
+ * Recursively precompiles all ICU message strings in a messages object
+ * using icu-minify/compile for smaller runtime bundles.
+ */
+function precompileMessages(messages, cache) {
+  const result = Object.create(null);
+  const cacheKeysToEvict = new Set(cache.keys());
+  for (const message of messages) {
+    cacheKeysToEvict.delete(message.id);
+    assertStringMessage(message);
+    const messageValue = message.message;
+    const cachedEntry = cache.get(message.id);
+    const hasCacheMatch = cachedEntry?.messageValue === messageValue;
+    let compiledMessage;
+    if (hasCacheMatch) {
+      compiledMessage = cachedEntry.compiledMessage;
+    } else {
+      compiledMessage = compile(messageValue);
+      cache.set(message.id, {
+        compiledMessage,
+        messageValue
+      });
+    }
+    setNestedProperty(result, message.id, compiledMessage);
+  }
+
+  // Evict unused cache entries
+  for (const cachedId of cacheKeysToEvict) {
+    cache.delete(cachedId);
+  }
+  return result;
+}
+
+export { catalogLoader as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/extractMessages.js

@@ -0,0 +1,22 @@
+import { warn } from '../plugin/utils.js';
+import ExtractionCompiler from './ExtractionCompiler.js';
+import MessageExtractor from './extractor/MessageExtractor.js';
+import normalizeExtractorConfig from './normalizeExtractorConfig.js';
+import { hasLocalesToExtract, getDefaultProjectRoot } from './utils.js';
+
+async function extractMessages(params) {
+  const config = normalizeExtractorConfig(params);
+  if (!hasLocalesToExtract(config)) {
+    warn('`messages.locales` is empty, so no messages were updated.');
+    return;
+  }
+  const compiler = new ExtractionCompiler(config, {
+    extractor: new MessageExtractor({
+      isDevelopment: false,
+      projectRoot: getDefaultProjectRoot()
+    })
+  });
+  await compiler.extractAll();
+}
+
+export { extractMessages as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/extractionLoader.js

@@ -0,0 +1,28 @@
+import MessageExtractor from './extractor/MessageExtractor.js';
+
+// Module-level extractor instance for transformation caching.
+// Note: Next.js/Turbopack may create multiple loader instances, but each
+// only handles file transformation. The ExtractionCompiler (which manages
+// catalogs) is initialized separately in createNextIntlPlugin.
+let extractor;
+function extractionLoader(source) {
+  const callback = this.async();
+  const projectRoot = this.rootContext;
+
+  // Avoid rollup's `replace` plugin to compile this away
+  const isDevelopment = process.env['NODE_ENV'.trim()] === 'development';
+  if (!extractor) {
+    extractor = new MessageExtractor({
+      isDevelopment,
+      projectRoot,
+      sourceMap: this.sourceMap
+    });
+  }
+  extractor.extract(this.resourcePath, source).then(result => {
+    // Webpack loaders conventionally pass source maps as objects (e.g.
+    // `next-swc-loader` calls `JSON.stringify` on its input source map)
+    callback(null, result.code, result.map ? JSON.parse(result.map) : undefined);
+  }).catch(callback);
+}
+
+export { extractionLoader as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/extractor/LRUCache.js

@@ -0,0 +1,30 @@
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = new Map();
+  }
+  set(key, value) {
+    const isNewKey = !this.cache.has(key);
+    if (isNewKey && this.cache.size >= this.maxSize) {
+      const lruKey = this.cache.keys().next().value;
+      if (lruKey !== undefined) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, {
+      key,
+      value
+    });
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (item) {
+      this.cache.delete(key);
+      this.cache.set(key, item);
+      return item.value;
+    }
+    return undefined;
+  }
+}
+
+export { LRUCache as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/extractor/MessageExtractor.js

@@ -0,0 +1,75 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { transform } from '@swc/core';
+import { getDefaultProjectRoot, normalizePathToPosix } from '../utils.js';
+import LRUCache from './LRUCache.js';
+
+const require$1 = createRequire(import.meta.url);
+class MessageExtractor {
+  compileCache = new LRUCache(750);
+  constructor(opts) {
+    this.isDevelopment = opts.isDevelopment ?? false;
+    this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
+    this.sourceMap = opts.sourceMap ?? false;
+  }
+  async extract(absoluteFilePath, source) {
+    const cacheKey = [source, absoluteFilePath].join('!');
+    const cached = this.compileCache.get(cacheKey);
+    if (cached) return cached;
+
+    // Shortcut parsing if hook is not used. The Turbopack integration already
+    // pre-filters this, but for webpack this feature doesn't exist, so we need
+    // to do it here.
+    if (!source.includes('useExtracted') && !source.includes('getExtracted')) {
+      return {
+        messages: [],
+        code: source
+      };
+    }
+    const filePath = normalizePathToPosix(path.relative(this.projectRoot, absoluteFilePath));
+    const result = await transform(source, {
+      jsc: {
+        target: 'esnext',
+        parser: {
+          syntax: 'typescript',
+          tsx: true,
+          decorators: true
+        },
+        experimental: {
+          cacheRoot: 'node_modules/.cache/swc',
+          disableBuiltinTransformsForInternalTesting: true,
+          disableAllLints: true,
+          plugins: [[require$1.resolve('next-intl-swc-plugin-extractor'), {
+            isDevelopment: this.isDevelopment,
+            filePath
+          }]]
+        }
+      },
+      sourceMaps: this.sourceMap,
+      // Is converted into a relative path by Next.js when
+      // the final source map is generated
+      sourceFileName: absoluteFilePath,
+      filename: filePath
+    });
+
+    // TODO: Improve the typing of @swc/core
+    const output = result.output;
+    // The plugin emits a tagged union of extracted messages and
+    // `useTranslations` usages; this extractor only consumes the former.
+    const messages = JSON.parse(JSON.parse(output).results).filter(item => item.type === 'extracted').map(item => ({
+      id: item.id,
+      message: item.message,
+      description: item.description,
+      reference: item.reference
+    }));
+    const extractionResult = {
+      code: result.code,
+      map: result.map,
+      messages
+    };
+    this.compileCache.set(cacheKey, extractionResult);
+    return extractionResult;
+  }
+}
+
+export { MessageExtractor as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/format/ExtractorCodec.js

@@ -0,0 +1,8 @@
+// Derived from `@eloqnt/config`, so next-intl and eloqnt pass identical
+// options to codecs.
+
+function defineCodec(factory) {
+  return factory;
+}
+
+export { defineCodec };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/format/codecs/BuiltInPoCodec.js

@@ -0,0 +1,22 @@
+import createPoCodec from '@eloqnt/format-po';
+import { defineCodec } from '../ExtractorCodec.js';
+
+// `@eloqnt/format-po`, guarded so catalogs in the previous key-based layout
+// fail loudly. Custom codecs referencing the package directly opt out.
+var BuiltInPoCodec = defineCodec(() => {
+  const codec = createPoCodec();
+  function assertMigrated(content) {
+    if (content.includes('X-Crowdin-SourceKey: msgstr')) {
+      throw new Error('This catalog uses the previous PO layout of next-intl, which stored message keys in `msgid`. The PO format now follows the gettext convention: the source text in `msgid` and the message key in `msgctxt`. Please migrate your catalogs, or use a custom codec to keep the previous layout: https://github.com/amannn/next-intl/pull/2393');
+    }
+  }
+  return {
+    ...codec,
+    decode(content, context) {
+      assertMigrated(content);
+      return codec.decode(content, context);
+    }
+  };
+});
+
+export { BuiltInPoCodec as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/format/index.js

@@ -0,0 +1,59 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { throwError } from '../../plugin/utils.js';
+
+const formats = {
+  json: {
+    codec: () => import('@eloqnt/format-json'),
+    extension: '.json'
+  },
+  po: {
+    codec: () => import('./codecs/BuiltInPoCodec.js'),
+    extension: '.po'
+  }
+};
+function isBuiltInFormat(format) {
+  return typeof format === 'string' && format in formats;
+}
+function getFormatExtension(format) {
+  if (isBuiltInFormat(format)) {
+    return formats[format].extension;
+  } else {
+    return format.extension;
+  }
+}
+async function resolveCodec(format, projectRoot) {
+  if (isBuiltInFormat(format)) {
+    const factory = (await formats[format].codec()).default;
+    return factory();
+  } else {
+    // A codec that starts with `.` or a filesystem root is a file path;
+    // everything else reads as a package specifier, mirroring how imports
+    // distinguish the two. Packages resolve from the project's dependencies.
+    const isPath = format.codec.startsWith('.') || path.isAbsolute(format.codec);
+    let resolvedPath;
+    if (isPath) {
+      resolvedPath = path.resolve(projectRoot, format.codec);
+    } else {
+      try {
+        resolvedPath = createRequire(path.join(projectRoot, 'noop.js')).resolve(format.codec);
+      } catch (error) {
+        throwError(`Could not resolve the codec package "${format.codec}". Is it installed?\n${error}`);
+      }
+    }
+    let module;
+    try {
+      module = await import(pathToFileURL(resolvedPath).href);
+    } catch (error) {
+      throwError(`Could not load codec from "${resolvedPath}".\n${error}`);
+    }
+    const factory = module.default;
+    if (!factory || typeof factory !== 'function') {
+      throwError(`Codec at "${resolvedPath}" must have a default export returned from \`defineCodec\`.`);
+    }
+    return factory();
+  }
+}
+
+export { formats as default, getFormatExtension, resolveCodec };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/normalizeExtractorConfig.js

@@ -0,0 +1,70 @@
+import { throwError, warn } from '../plugin/utils.js';
+
+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
+    }
+  };
+}
+
+export { normalizeExtractorConfig as default, normalizeMessagesCatalogPaths };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/source/SourceFileFilter.js

@@ -0,0 +1,29 @@
+import path from 'path';
+
+class SourceFileFilter {
+  static EXTENSIONS = ['ts', 'tsx', 'js', 'jsx'];
+
+  // Will not be entered, except if explicitly asked for
+  // TODO: At some point we should infer these from .gitignore
+  static IGNORED_DIRECTORIES = ['node_modules', '.next', '.git'];
+  static isSourceFile(filePath) {
+    const ext = path.extname(filePath);
+    return SourceFileFilter.EXTENSIONS.map(cur => '.' + cur).includes(ext);
+  }
+  static shouldEnterDirectory(dirPath, srcPaths) {
+    const dirName = path.basename(dirPath);
+    if (SourceFileFilter.IGNORED_DIRECTORIES.includes(dirName)) {
+      return SourceFileFilter.isIgnoredDirectoryExplicitlyIncluded(dirPath, srcPaths);
+    }
+    return true;
+  }
+  static isIgnoredDirectoryExplicitlyIncluded(ignoredDirPath, srcPaths) {
+    return srcPaths.some(srcPath => SourceFileFilter.isWithinPath(srcPath, ignoredDirPath));
+  }
+  static isWithinPath(targetPath, basePath) {
+    const relativePath = path.relative(basePath, targetPath);
+    return relativePath === '' || !relativePath.startsWith('..');
+  }
+}
+
+export { SourceFileFilter as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/source/SourceFileScanner.js

@@ -0,0 +1,31 @@
+import fs from 'fs/promises';
+import path from 'path';
+import SourceFileFilter from './SourceFileFilter.js';
+
+class SourceFileScanner {
+  static async walkSourceFiles(dir, srcPaths, acc = []) {
+    const entries = await fs.readdir(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const entryPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SourceFileFilter.shouldEnterDirectory(entryPath, srcPaths)) {
+          continue;
+        }
+        await SourceFileScanner.walkSourceFiles(entryPath, srcPaths, acc);
+      } else {
+        if (SourceFileFilter.isSourceFile(entry.name)) {
+          acc.push(entryPath);
+        }
+      }
+    }
+    return acc;
+  }
+  static async getSourceFiles(srcPaths) {
+    const files = (await Promise.all(srcPaths.map(srcPath => SourceFileScanner.walkSourceFiles(srcPath, srcPaths)))).flat();
+    return new Set(files);
+  }
+}
+
+export { SourceFileScanner as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/source/SourceFileWatcher.js

@@ -0,0 +1,132 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { subscribe } from '@parcel/watcher';
+import SourceFileFilter from './SourceFileFilter.js';
+import SourceFileScanner from './SourceFileScanner.js';
+
+class SourceFileWatcher {
+  subscriptions = [];
+  constructor(roots, onChange) {
+    this.roots = roots;
+    this.onChange = onChange;
+  }
+  async start() {
+    if (this.subscriptions.length > 0) {
+      return;
+    }
+    const ignore = SourceFileFilter.IGNORED_DIRECTORIES.map(dir => `**/${dir}/**`);
+    for (const root of this.roots) {
+      const sub = await subscribe(root, async (err, events) => {
+        if (err) {
+          console.error(err);
+          return;
+        }
+        const filtered = await this.normalizeEvents(events);
+        if (filtered.length > 0) {
+          await this.onChange(filtered);
+        }
+      }, {
+        ignore
+      });
+      this.subscriptions.push(sub);
+    }
+  }
+  async normalizeEvents(events) {
+    const directoryCreatePaths = [];
+    const otherEvents = [];
+
+    // We need to expand directory creates because during rename operations,
+    // @parcel/watcher emits a directory create event but may not emit individual
+    // file events for the moved files
+    await Promise.all(events.map(async event => {
+      if (event.type === 'create') {
+        try {
+          const stats = await fs.stat(event.path);
+          if (stats.isDirectory()) {
+            directoryCreatePaths.push(event.path);
+            return;
+          }
+        } catch {
+          // Path doesn't exist or is inaccessible, treat as file
+        }
+      }
+      otherEvents.push(event);
+    }));
+
+    // Expand directory create events to find source files inside
+    let expandedCreateEvents = [];
+    if (directoryCreatePaths.length > 0) {
+      try {
+        const sourceFiles = await SourceFileScanner.getSourceFiles(directoryCreatePaths);
+        expandedCreateEvents = Array.from(sourceFiles).map(filePath => ({
+          type: 'create',
+          path: filePath
+        }));
+      } catch {
+        // Directories might have been deleted or are inaccessible
+      }
+    }
+
+    // Combine original events with expanded directory creates.
+    // Deduplicate by path to avoid processing the same file twice
+    // in case @parcel/watcher also emitted individual file events.
+    const allEvents = [...otherEvents, ...expandedCreateEvents];
+    const seenPaths = new Set();
+    const deduplicated = [];
+    for (const event of allEvents) {
+      const key = `${event.type}:${event.path}`;
+      if (!seenPaths.has(key)) {
+        seenPaths.add(key);
+        deduplicated.push(event);
+      }
+    }
+    return deduplicated.filter(event => {
+      // Keep all delete events (might be deleted directories that no longer exist)
+      if (event.type === 'delete') {
+        return true;
+      }
+      // Keep source files
+      return SourceFileFilter.isSourceFile(event.path);
+    });
+  }
+  async expandDirectoryDeleteEvents(events, prevKnownFiles) {
+    const expanded = [];
+    for (const event of events) {
+      if (event.type === 'delete' && !SourceFileFilter.isSourceFile(event.path)) {
+        const dirPath = path.resolve(event.path);
+        const filesInDirectory = [];
+        for (const filePath of prevKnownFiles) {
+          if (SourceFileFilter.isWithinPath(filePath, dirPath)) {
+            filesInDirectory.push(filePath);
+          }
+        }
+
+        // If we found files within this path, it was a directory
+        if (filesInDirectory.length > 0) {
+          for (const filePath of filesInDirectory) {
+            expanded.push({
+              type: 'delete',
+              path: filePath
+            });
+          }
+        } else {
+          // Not a directory or no files in it, pass through as-is
+          expanded.push(event);
+        }
+      } else {
+        // Pass through as-is
+        expanded.push(event);
+      }
+    }
+    return expanded;
+  }
+  async stop() {
+    await Promise.all(this.subscriptions.map(sub => sub.unsubscribe()));
+    this.subscriptions = [];
+  }
+  [Symbol.dispose]() {
+    void this.stop();
+  }
+}
+
+export { SourceFileWatcher as default };

e-commerce/node_modules/next-intl/dist/esm/development/extractor/utils.js

@@ -0,0 +1,60 @@
+import path from 'path';
+import { warn } from '../plugin/utils.js';
+
+function normalizePathToPosix(filePath) {
+  // `path.relative` uses OS-specific separators. For stable `.po` references we
+  // always use POSIX separators, regardless of the OS that ran extraction.
+  return path.posix.normalize(filePath.split(path.win32.sep).join(path.posix.sep));
+}
+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) {
+  const keys = keyPath.split('.');
+  for (const key of keys) {
+    if (isForbiddenObjectKey(key)) {
+      throw new Error(`Invalid message id segment: ${key}`);
+    }
+  }
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!Object.prototype.hasOwnProperty.call(current, key) || typeof current[key] !== 'object' || current[key] === null) {
+      current[key] = Object.create(null);
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function warnAboutMissingReferences(messages) {
+  const warnedIds = new Set();
+  for (const message of messages) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (message.references[0] == null && !warnedIds.has(message.id)) {
+      warnedIds.add(message.id);
+      warn(`Missing file reference for extracted message: ${message.id}`);
+    }
+  }
+}
+function localeCompare(a, b) {
+  return a.localeCompare(b, 'en');
+}
+function compareReferences(refA, refB) {
+  const pathCompare = localeCompare(refA.path, refB.path);
+  if (pathCompare !== 0) return pathCompare;
+  return (refA.line ?? 0) - (refB.line ?? 0) || (refA.column ?? 0) - (refB.column ?? 0);
+}
+function getDefaultProjectRoot() {
+  return process.cwd();
+}
+
+export { compareReferences, getDefaultProjectRoot, hasLocalesToExtract, isForbiddenObjectKey, localeCompare, normalizePathToPosix, setNestedProperty, warnAboutMissingReferences };

e-commerce/node_modules/next-intl/dist/esm/development/index.react-client.js

@@ -0,0 +1,4 @@
+export { useFormatter, useTranslations } from './react-client/index.js';
+export { default as NextIntlClientProvider } from './shared/NextIntlClientProvider.js';
+export { IntlProvider, _useExtracted as useExtracted, useLocale, useMessages, useNow, useTimeZone } from 'use-intl/react';
+export * from 'use-intl/core';

e-commerce/node_modules/next-intl/dist/esm/development/index.react-server.js

@@ -0,0 +1,9 @@
+export { default as useLocale } from './react-server/useLocale.js';
+export { default as useTranslations } from './react-server/useTranslations.js';
+export { default as useFormatter } from './react-server/useFormatter.js';
+export { default as useNow } from './react-server/useNow.js';
+export { default as useTimeZone } from './react-server/useTimeZone.js';
+export { default as useMessages } from './react-server/useMessages.js';
+export { default as NextIntlClientProvider } from './react-server/NextIntlClientProviderServer.js';
+export { default as useExtracted } from './react-server/useExtracted.js';
+export * from 'use-intl/core';

e-commerce/node_modules/next-intl/dist/esm/development/middleware.js

@@ -0,0 +1 @@
+export { default } from './middleware/middleware.js';

e-commerce/node_modules/next-intl/dist/esm/development/middleware/getAlternateLinksHeaderValue.js

@@ -0,0 +1,94 @@
+import { normalizeTrailingSlash } from '../shared/utils.js';
+import { getHost, getNormalizedPathname, getLocalePrefixes, isLocaleSupportedOnDomain, applyBasePath, formatTemplatePathname } from './utils.js';
+
+/**
+ * See https://developers.google.com/search/docs/specialty/international/localized-versions
+ */
+function getAlternateLinksHeaderValue({
+  internalTemplateName,
+  localizedPathnames,
+  request,
+  resolvedLocale,
+  routing
+}) {
+  const normalizedUrl = request.nextUrl.clone();
+  const host = getHost(request.headers);
+  if (host) {
+    normalizedUrl.port = '';
+    normalizedUrl.host = host;
+  }
+  normalizedUrl.protocol = request.headers.get('x-forwarded-proto') ?? normalizedUrl.protocol;
+  normalizedUrl.pathname = getNormalizedPathname(normalizedUrl.pathname, routing.locales, routing.localePrefix);
+  function getAlternateEntry(url, locale) {
+    url.pathname = normalizeTrailingSlash(url.pathname);
+    if (request.nextUrl.basePath) {
+      url = new URL(url);
+      url.pathname = applyBasePath(url.pathname, request.nextUrl.basePath);
+    }
+    return `<${url.toString()}>; rel="alternate"; hreflang="${locale}"`;
+  }
+  function getLocalizedPathname(pathname, locale) {
+    if (localizedPathnames && typeof localizedPathnames === 'object') {
+      const sourceTemplate = localizedPathnames[resolvedLocale];
+      return formatTemplatePathname(pathname, sourceTemplate ?? internalTemplateName, localizedPathnames[locale] ?? internalTemplateName);
+    } else {
+      return pathname;
+    }
+  }
+  const links = getLocalePrefixes(routing.locales, routing.localePrefix, false).flatMap(([locale, prefix]) => {
+    function prefixPathname(pathname) {
+      if (pathname === '/') {
+        return prefix;
+      } else {
+        return prefix + pathname;
+      }
+    }
+    let url;
+    if (routing.domains) {
+      const domainConfigs = routing.domains.filter(cur => isLocaleSupportedOnDomain(locale, cur));
+      return domainConfigs.map(domainConfig => {
+        url = new URL(normalizedUrl);
+        url.port = '';
+        url.host = domainConfig.domain;
+
+        // Important: Use `normalizedUrl` here, as `url` potentially uses
+        // a `basePath` that automatically gets applied to the pathname
+        url.pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
+
+        // Use domain-specific localePrefix mode if available
+        const domainMode = domainConfig.localePrefix || routing.localePrefix.mode;
+        if (locale !== domainConfig.defaultLocale || domainMode === 'always') {
+          url.pathname = prefixPathname(url.pathname);
+        }
+        return getAlternateEntry(url, locale);
+      });
+    } else {
+      let pathname;
+      if (localizedPathnames && typeof localizedPathnames === 'object') {
+        pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
+      } else {
+        pathname = normalizedUrl.pathname;
+      }
+      if (locale !== routing.defaultLocale || routing.localePrefix.mode === 'always') {
+        pathname = prefixPathname(pathname);
+      }
+      url = new URL(pathname, normalizedUrl);
+    }
+    return getAlternateEntry(url, locale);
+  });
+
+  // Add x-default entry
+  const shouldAddXDefault =
+  // For domain-based routing there is no reasonable x-default
+  !routing.domains || routing.domains.length === 0;
+  if (shouldAddXDefault) {
+    const localizedPathname = getLocalizedPathname(normalizedUrl.pathname, routing.defaultLocale);
+    if (localizedPathname) {
+      const url = new URL(localizedPathname, normalizedUrl);
+      links.push(getAlternateEntry(url, 'x-default'));
+    }
+  }
+  return links.join(', ');
+}
+
+export { getAlternateLinksHeaderValue as default };

e-commerce/node_modules/next-intl/dist/esm/development/middleware/middleware.js

@@ -0,0 +1,172 @@
+import { NextResponse } from 'next/server';
+import { receiveRoutingConfig } from '../routing/config.js';
+import { HEADER_LOCALE_NAME } from '../shared/constants.js';
+import { matchesPathname, normalizeTrailingSlash, getLocalePrefix, getLocalizedTemplate } from '../shared/utils.js';
+import getAlternateLinksHeaderValue from './getAlternateLinksHeaderValue.js';
+import resolveLocale from './resolveLocale.js';
+import syncCookie from './syncCookie.js';
+import { sanitizePathname, isLocaleSupportedOnDomain, getNormalizedPathname, getPathnameMatch, getInternalTemplate, formatTemplatePathname, formatPathname, getBestMatchingDomain, applyBasePath, getLocaleAsPrefix } from './utils.js';
+
+function createMiddleware(routing) {
+  const resolvedRouting = receiveRoutingConfig(routing);
+  return function middleware(request) {
+    let unsafeExternalPathname;
+    try {
+      // Resolve potential foreign symbols (e.g. /ja/%E7%B4%84 → /ja/約))
+      unsafeExternalPathname = decodeURI(request.nextUrl.pathname);
+    } catch {
+      // In case an invalid pathname is encountered, forward
+      // it to Next.js which in turn responds with a 400
+      return NextResponse.next();
+    }
+
+    // Sanitize malicious URIs to prevent open redirect attacks due to
+    // decodeURI doesn't escape encoded backslashes ('%5C' & '%5c')
+    const externalPathname = sanitizePathname(unsafeExternalPathname);
+    const {
+      domain,
+      locale
+    } = resolveLocale(resolvedRouting, request.headers, request.cookies, externalPathname);
+    const hasMatchedDefaultLocale = domain ? domain.defaultLocale === locale : locale === resolvedRouting.defaultLocale;
+    const domainsConfig = resolvedRouting.domains?.filter(curDomain => isLocaleSupportedOnDomain(locale, curDomain)) || [];
+    const hasUnknownHost = resolvedRouting.domains != null && !domain;
+    function next(url) {
+      const urlObj = new URL(url, request.url);
+      if (request.nextUrl.basePath) {
+        urlObj.pathname = applyBasePath(urlObj.pathname, request.nextUrl.basePath);
+      }
+      const headers = new Headers(request.headers);
+      headers.set(HEADER_LOCALE_NAME, locale);
+      const isRewriteNecessary = normalizeTrailingSlash(request.nextUrl.pathname) !== normalizeTrailingSlash(urlObj.pathname);
+      if (isRewriteNecessary) {
+        return NextResponse.rewrite(urlObj, {
+          request: {
+            headers
+          }
+        });
+      } else {
+        return NextResponse.next({
+          request: {
+            headers
+          }
+        });
+      }
+    }
+    function redirect(url, redirectDomain) {
+      const urlObj = new URL(url, request.url);
+      urlObj.pathname = normalizeTrailingSlash(urlObj.pathname);
+      if (domainsConfig.length > 0 && !redirectDomain && domain) {
+        const bestMatchingDomain = getBestMatchingDomain(domain, locale, domainsConfig);
+        if (bestMatchingDomain) {
+          redirectDomain = bestMatchingDomain.domain;
+          const redirectDomainMode = bestMatchingDomain.localePrefix || resolvedRouting.localePrefix.mode;
+          if (bestMatchingDomain.defaultLocale === locale && redirectDomainMode === 'as-needed') {
+            urlObj.pathname = getNormalizedPathname(urlObj.pathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+          }
+        }
+      }
+      if (redirectDomain) {
+        urlObj.host = redirectDomain;
+        if (request.headers.get('x-forwarded-host')) {
+          urlObj.protocol = request.headers.get('x-forwarded-proto') ?? request.nextUrl.protocol;
+          const redirectDomainPort = redirectDomain.split(':')[1];
+          urlObj.port = redirectDomainPort ?? request.headers.get('x-forwarded-port') ?? '';
+        }
+      }
+      if (request.nextUrl.basePath) {
+        urlObj.pathname = applyBasePath(urlObj.pathname, request.nextUrl.basePath);
+      }
+      hasRedirected = true;
+      return NextResponse.redirect(urlObj.toString());
+    }
+    const unprefixedExternalPathname = getNormalizedPathname(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+    const pathnameMatch = getPathnameMatch(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix, domain);
+    const hasLocalePrefix = pathnameMatch != null;
+
+    // Use domain-specific localePrefix mode if available, otherwise use global mode
+    const effectiveLocalePrefixMode = domain?.localePrefix || resolvedRouting.localePrefix.mode;
+    const isUnprefixedRouting = effectiveLocalePrefixMode === 'never' || hasMatchedDefaultLocale && effectiveLocalePrefixMode === 'as-needed';
+    let response;
+    let internalTemplateName;
+    let hasRedirected;
+    let unprefixedInternalPathname = unprefixedExternalPathname;
+    const pathnames = resolvedRouting.pathnames;
+    if (pathnames) {
+      let resolvedTemplateLocale;
+      [resolvedTemplateLocale, internalTemplateName] = getInternalTemplate(pathnames, unprefixedExternalPathname, locale);
+      if (internalTemplateName) {
+        const pathnameConfig = pathnames[internalTemplateName];
+        const localeTemplate = getLocalizedTemplate(pathnameConfig, locale, internalTemplateName);
+        if (matchesPathname(localeTemplate, unprefixedExternalPathname)) {
+          unprefixedInternalPathname = formatTemplatePathname(unprefixedExternalPathname, localeTemplate, internalTemplateName);
+        } else {
+          let sourceTemplate;
+          if (resolvedTemplateLocale) {
+            // A localized pathname from another locale has matched
+            sourceTemplate = getLocalizedTemplate(pathnameConfig, resolvedTemplateLocale, internalTemplateName);
+          } else {
+            // An internal pathname has matched that
+            // doesn't have a localized pathname
+            sourceTemplate = internalTemplateName;
+          }
+          const localePrefix = isUnprefixedRouting ? undefined : getLocalePrefix(locale, resolvedRouting.localePrefix);
+          const template = formatTemplatePathname(unprefixedExternalPathname, sourceTemplate, localeTemplate);
+          response = redirect(formatPathname(template, localePrefix, request.nextUrl.search));
+        }
+      }
+    }
+    if (!response) {
+      if (unprefixedInternalPathname === '/' && !hasLocalePrefix) {
+        if (isUnprefixedRouting) {
+          response = next(formatPathname(unprefixedInternalPathname, getLocaleAsPrefix(locale), request.nextUrl.search));
+        } else {
+          response = redirect(formatPathname(unprefixedExternalPathname, getLocalePrefix(locale, resolvedRouting.localePrefix), request.nextUrl.search));
+        }
+      } else {
+        const internalHref = formatPathname(unprefixedInternalPathname, getLocaleAsPrefix(locale), request.nextUrl.search);
+        if (hasLocalePrefix) {
+          const externalHref = formatPathname(unprefixedExternalPathname, pathnameMatch.prefix, request.nextUrl.search);
+          if (effectiveLocalePrefixMode === 'never') {
+            response = redirect(formatPathname(unprefixedExternalPathname, undefined, request.nextUrl.search));
+          } else if (pathnameMatch.exact) {
+            if (hasMatchedDefaultLocale && isUnprefixedRouting) {
+              response = redirect(formatPathname(unprefixedExternalPathname, undefined, request.nextUrl.search));
+            } else {
+              if (resolvedRouting.domains) {
+                const pathDomain = getBestMatchingDomain(domain, pathnameMatch.locale, domainsConfig);
+                if (domain?.domain !== pathDomain?.domain && !hasUnknownHost) {
+                  response = redirect(externalHref, pathDomain?.domain);
+                } else {
+                  response = next(internalHref);
+                }
+              } else {
+                response = next(internalHref);
+              }
+            }
+          } else {
+            response = redirect(externalHref);
+          }
+        } else {
+          if (isUnprefixedRouting) {
+            response = next(internalHref);
+          } else {
+            response = redirect(formatPathname(unprefixedExternalPathname, getLocalePrefix(locale, resolvedRouting.localePrefix), request.nextUrl.search));
+          }
+        }
+      }
+    }
+    syncCookie(request, response, locale, resolvedRouting, domain);
+    if (!hasRedirected && effectiveLocalePrefixMode !== 'never' && resolvedRouting.alternateLinks && resolvedRouting.locales.length > 1) {
+      response.headers.set('Link', getAlternateLinksHeaderValue({
+        routing: resolvedRouting,
+        internalTemplateName,
+        localizedPathnames: internalTemplateName != null && pathnames ? pathnames[internalTemplateName] : undefined,
+        request,
+        resolvedLocale: locale
+      }));
+    }
+    return response;
+  };
+}
+
+export { createMiddleware as default };

e-commerce/node_modules/next-intl/dist/esm/development/middleware/resolveLocale.js

@@ -0,0 +1,129 @@
+import { match } from '@formatjs/intl-localematcher';
+import Negotiator from 'negotiator';
+import { getPathnameMatch, isLocaleSupportedOnDomain, getHost } from './utils.js';
+
+function findDomainFromHost(requestHeaders, domains) {
+  const host = getHost(requestHeaders);
+  if (host) {
+    return domains.find(cur => cur.domain === host);
+  }
+  return undefined;
+}
+function orderLocales(locales) {
+  // Workaround for https://github.com/formatjs/formatjs/issues/4469
+  return locales.slice().sort((a, b) => b.length - a.length);
+}
+function mapToProvidedLocale(locales, locale) {
+  return locales.find(cur => cur.toLowerCase() === locale.toLowerCase());
+}
+function getAcceptLanguageLocale(requestHeaders, locales, defaultLocale) {
+  let locale;
+  const languages = new Negotiator({
+    headers: {
+      'accept-language': requestHeaders.get('accept-language') || undefined
+    }
+  }).languages();
+  try {
+    const orderedLocales = orderLocales(locales);
+    locale = mapToProvidedLocale(locales, match(languages, orderedLocales, defaultLocale));
+  } catch {
+    // Invalid language
+  }
+  return locale;
+}
+function getLocaleFromCookie(routing, requestCookies) {
+  if (routing.localeCookie && requestCookies.has(routing.localeCookie.name)) {
+    const value = requestCookies.get(routing.localeCookie.name)?.value;
+    if (value && routing.locales.includes(value)) {
+      return value;
+    }
+  }
+}
+function resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname) {
+  let locale;
+
+  // Prio 1: Use route prefix
+  if (pathname) {
+    locale = getPathnameMatch(pathname, routing.locales, routing.localePrefix)?.locale;
+  }
+
+  // Prio 2: Use existing cookie
+  if (!locale && routing.localeDetection) {
+    locale = getLocaleFromCookie(routing, requestCookies);
+  }
+
+  // Prio 3: Use the `accept-language` header
+  if (!locale && routing.localeDetection) {
+    locale = getAcceptLanguageLocale(requestHeaders, routing.locales, routing.defaultLocale);
+  }
+
+  // Prio 4: Use default locale
+  if (!locale) {
+    locale = routing.defaultLocale;
+  }
+  return locale;
+}
+function resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathname) {
+  const domains = routing.domains;
+  const domain = findDomainFromHost(requestHeaders, domains);
+  if (!domain) {
+    return {
+      locale: resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname)
+    };
+  }
+  let locale;
+
+  // Prio 1: Use route prefix
+  if (pathname) {
+    const prefixLocale = getPathnameMatch(pathname, routing.locales, routing.localePrefix, domain)?.locale;
+    if (prefixLocale) {
+      if (isLocaleSupportedOnDomain(prefixLocale, domain)) {
+        locale = prefixLocale;
+      } else {
+        // Causes a redirect to a domain that supports the locale
+        return {
+          locale: prefixLocale,
+          domain
+        };
+      }
+    }
+  }
+
+  // Prio 2: Use existing cookie
+  if (!locale && routing.localeDetection) {
+    const cookieLocale = getLocaleFromCookie(routing, requestCookies);
+    if (cookieLocale) {
+      if (isLocaleSupportedOnDomain(cookieLocale, domain)) {
+        locale = cookieLocale;
+      }
+    }
+  }
+
+  // Prio 3: Use the `accept-language` header
+  if (!locale && routing.localeDetection) {
+    const headerLocale = getAcceptLanguageLocale(requestHeaders, domain.locales, domain.defaultLocale);
+    if (headerLocale) {
+      locale = headerLocale;
+    }
+  }
+
+  // Prio 4: Use default locale
+  if (!locale) {
+    locale = domain.defaultLocale;
+  }
+  return {
+    locale,
+    domain
+  };
+}
+function resolveLocale(routing, requestHeaders, requestCookies, pathname) {
+  if (routing.domains) {
+    return resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathname);
+  } else {
+    return {
+      locale: resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname)
+    };
+  }
+}
+
+export { resolveLocale as default, getAcceptLanguageLocale };

e-commerce/node_modules/next-intl/dist/esm/development/middleware/syncCookie.js

@@ -0,0 +1,42 @@
+import { getAcceptLanguageLocale } from './resolveLocale.js';
+
+function syncCookie(request, response, locale, routing, domain) {
+  if (!routing.localeCookie) return;
+
+  // Only document requests indicate that the user is actually
+  // navigating to a page—in contrast to background requests of the
+  // client-side router like prefetches and cache revalidations.
+  // E.g. as of Next.js 16.3, the router revalidates previously
+  // visited routes after a navigation, including routes of a locale
+  // the user has just switched away from. Updating the cookie based
+  // on such a request would overwrite the locale that was just set
+  // when switching the locale. Note that Next.js strips router
+  // headers like `Next-Router-Prefetch` before invoking the
+  // middleware, therefore `Sec-Fetch-Dest` is used to detect
+  // background requests. Locale switches via a soft navigation
+  // update the cookie on the client side.
+  const secFetchDest = request.headers.get('sec-fetch-dest');
+  if (secFetchDest != null && secFetchDest !== 'document') return;
+  const {
+    name,
+    ...rest
+  } = routing.localeCookie;
+  const hasLocaleCookie = request.cookies.has(name);
+  const hasOutdatedCookie = hasLocaleCookie && request.cookies.get(name)?.value !== locale;
+  if (hasOutdatedCookie) {
+    response.cookies.set(name, locale, {
+      path: request.nextUrl.basePath || undefined,
+      ...rest
+    });
+  } else if (!hasLocaleCookie) {
+    const acceptLanguageLocale = getAcceptLanguageLocale(request.headers, domain?.locales || routing.locales, routing.defaultLocale);
+    if (acceptLanguageLocale !== locale) {
+      response.cookies.set(name, locale, {
+        path: request.nextUrl.basePath || undefined,
+        ...rest
+      });
+    }
+  }
+}
+
+export { syncCookie as default };

e-commerce/node_modules/next-intl/dist/esm/development/middleware/utils.js

@@ -0,0 +1,202 @@
+import { normalizeTrailingSlash, getSortedPathnames, matchesPathname, prefixPathname, getLocalePrefix, templateToRegex, getLocalizedTemplate } from '../shared/utils.js';
+
+function getInternalTemplate(pathnames, pathname, locale) {
+  const sortedPathnames = getSortedPathnames(Object.keys(pathnames));
+
+  // Try to find a localized pathname that matches
+  for (const internalPathname of sortedPathnames) {
+    const localizedPathnamesOrPathname = pathnames[internalPathname];
+    if (typeof localizedPathnamesOrPathname === 'string') {
+      const localizedPathname = localizedPathnamesOrPathname;
+      if (matchesPathname(localizedPathname, pathname)) {
+        return [undefined, internalPathname];
+      }
+    } else {
+      // Prefer the entry with the current locale in case multiple
+      // localized pathnames match the current pathname
+      const sortedEntries = Object.entries(localizedPathnamesOrPathname);
+      const curLocaleIndex = sortedEntries.findIndex(([entryLocale]) => entryLocale === locale);
+      if (curLocaleIndex > 0) {
+        sortedEntries.unshift(sortedEntries.splice(curLocaleIndex, 1)[0]);
+      }
+      for (const [entryLocale] of sortedEntries) {
+        const localizedTemplate = getLocalizedTemplate(pathnames[internalPathname], entryLocale, internalPathname);
+        if (matchesPathname(localizedTemplate, pathname)) {
+          return [entryLocale, internalPathname];
+        }
+      }
+    }
+  }
+
+  // Try to find an internal pathname that matches (this can be the case
+  // if all localized pathnames are different from the internal pathnames)
+  for (const internalPathname of Object.keys(pathnames)) {
+    if (matchesPathname(internalPathname, pathname)) {
+      return [undefined, internalPathname];
+    }
+  }
+
+  // No match
+  return [undefined, undefined];
+}
+function formatTemplatePathname(sourcePathname, sourceTemplate, targetTemplate, prefix) {
+  const params = getRouteParams(sourceTemplate, sourcePathname);
+  let targetPathname = '';
+  targetPathname += formatPathnameTemplate(targetTemplate, params);
+
+  // A pathname with an optional catchall like `/categories/[[...slug]]`
+  // should be normalized to `/categories` if the catchall is not present
+  // and no trailing slash is configured
+  targetPathname = normalizeTrailingSlash(targetPathname);
+  return targetPathname;
+}
+
+/**
+ * Removes potential prefixes from the pathname.
+ */
+function getNormalizedPathname(pathname, locales, localePrefix) {
+  // Add trailing slash for consistent handling
+  // both for the root as well as nested paths
+  if (!pathname.endsWith('/')) {
+    pathname += '/';
+  }
+  const localePrefixes = getLocalePrefixes(locales, localePrefix);
+  const regex = new RegExp(`^(${localePrefixes.map(([, prefix]) => prefix.replaceAll('/', '\\/')).join('|')})/(.*)`, 'i');
+  const match = pathname.match(regex);
+  let result = match ? '/' + match[2] : pathname;
+  if (result !== '/') {
+    result = normalizeTrailingSlash(result);
+  }
+  return result;
+}
+function getLocalePrefixes(locales, localePrefix, sort = true) {
+  const prefixes = locales.map(locale => [locale, getLocalePrefix(locale, localePrefix)]);
+  if (sort) {
+    // More specific ones first
+    prefixes.sort((a, b) => b[1].length - a[1].length);
+  }
+  return prefixes;
+}
+function getPathnameMatch(pathname, locales, localePrefix, domain) {
+  const localePrefixes = getLocalePrefixes(locales, localePrefix);
+
+  // Sort to prioritize domain locales
+  if (domain) {
+    localePrefixes.sort(([localeA], [localeB]) => {
+      if (localeA === domain.defaultLocale) return -1;
+      if (localeB === domain.defaultLocale) return 1;
+      const isLocaleAInDomain = domain.locales.includes(localeA);
+      const isLocaleBInDomain = domain.locales.includes(localeB);
+      if (isLocaleAInDomain && !isLocaleBInDomain) return -1;
+      if (!isLocaleAInDomain && isLocaleBInDomain) return 1;
+      return 0;
+    });
+  }
+  for (const [locale, prefix] of localePrefixes) {
+    let exact, matches;
+    if (pathname === prefix || pathname.startsWith(prefix + '/')) {
+      exact = matches = true;
+    } else {
+      const normalizedPathname = pathname.toLowerCase();
+      const normalizedPrefix = prefix.toLowerCase();
+      if (normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(normalizedPrefix + '/')) {
+        exact = false;
+        matches = true;
+      }
+    }
+    if (matches) {
+      return {
+        locale,
+        prefix,
+        matchedPrefix: pathname.slice(0, prefix.length),
+        exact
+      };
+    }
+  }
+}
+function getRouteParams(template, pathname) {
+  const normalizedPathname = normalizeTrailingSlash(pathname);
+  const normalizedTemplate = normalizeTrailingSlash(template);
+  const regex = templateToRegex(normalizedTemplate);
+  const match = regex.exec(normalizedPathname);
+  if (!match) return undefined;
+  const params = {};
+  const keys = normalizedTemplate.match(/\[([^\]]+)\]/g) ?? [];
+  for (let i = 1; i < match.length; i++) {
+    const rawKey = keys[i - 1];
+    if (!rawKey) continue;
+    const key = rawKey.replace(/[[\]]/g, '');
+    const value = match[i] ?? '';
+    params[key] = value;
+  }
+  return params;
+}
+function formatPathnameTemplate(template, params) {
+  if (!params) return template;
+
+  // Simplify syntax for optional catchall ('[[...slug]]') so
+  // we can replace the value with simple interpolation
+  template = template.replace(/\[\[/g, '[').replace(/\]\]/g, ']');
+  let result = template;
+  Object.entries(params).forEach(([key, value]) => {
+    result = result.replace(`[${key}]`, () => value);
+  });
+  return result;
+}
+function formatPathname(pathname, prefix, search) {
+  let result = pathname;
+  if (prefix) {
+    result = prefixPathname(prefix, result);
+  }
+  if (search) {
+    result += search;
+  }
+  return result;
+}
+function getHost(requestHeaders) {
+  return requestHeaders.get('x-forwarded-host') ?? requestHeaders.get('host') ?? undefined;
+}
+function isLocaleSupportedOnDomain(locale, domain) {
+  return domain.defaultLocale === locale || domain.locales.includes(locale);
+}
+function getBestMatchingDomain(curHostDomain, locale, domainsConfig) {
+  let domainConfig;
+
+  // Prio 1: Stay on current domain
+  if (curHostDomain && isLocaleSupportedOnDomain(locale, curHostDomain)) {
+    domainConfig = curHostDomain;
+  }
+
+  // Prio 2: Use alternative domain with matching default locale
+  if (!domainConfig) {
+    domainConfig = domainsConfig.find(cur => cur.defaultLocale === locale);
+  }
+
+  // Prio 3: Use alternative domain that supports the locale
+  if (!domainConfig) {
+    domainConfig = domainsConfig.find(cur => cur.locales.includes(locale));
+  }
+  return domainConfig;
+}
+function applyBasePath(pathname, basePath) {
+  return normalizeTrailingSlash(basePath + pathname);
+}
+function getLocaleAsPrefix(locale) {
+  return `/${locale}`;
+}
+function sanitizePathname(pathname) {
+  // Sanitize malicious URIs, e.g.:
+  // '/en/\\example.org'  → '/en/%5Cexample.org'     (backslash → %5C)
+  // '/en/\t/example.org' → '/en/example.org'        (WHATWG-stripped TAB)
+  // '/en/\n/example.org' → '/en/example.org'        (WHATWG-stripped LF)
+  // '/en/\r/example.org' → '/en/example.org'        (WHATWG-stripped CR)
+  // '/en////example.org' → '/en/example.org'        (consecutive slashes)
+  //
+  // U+0009/000A/000D are silently stripped by the WHATWG URL parser
+  // (https://url.spec.whatwg.org/#concept-url-parser). Without removing
+  // them here, a decoded TAB in a segment separator position causes
+  // new URL("/\t/host", base) to collapse to "//host" → open redirect.
+  return pathname.replace(/\\/g, '%5C').replace(/[\t\n\r]/g, '').replace(/\/+/g, '/');
+}
+
+export { applyBasePath, formatPathname, formatPathnameTemplate, formatTemplatePathname, getBestMatchingDomain, getHost, getInternalTemplate, getLocaleAsPrefix, getLocalePrefixes, getNormalizedPathname, getPathnameMatch, getRouteParams, isLocaleSupportedOnDomain, sanitizePathname };

e-commerce/node_modules/next-intl/dist/esm/development/navigation.react-client.js

@@ -0,0 +1 @@
+export { default as createNavigation } from './navigation/react-client/createNavigation.js';

e-commerce/node_modules/next-intl/dist/esm/development/navigation.react-server.js

@@ -0,0 +1 @@
+export { default as createNavigation } from './navigation/react-server/createNavigation.js';

e-commerce/node_modules/next-intl/dist/esm/development/navigation/react-client/createNavigation.js

@@ -0,0 +1,79 @@
+import { useRouter } from 'next/navigation';
+import { useMemo } from 'react';
+import { useLocale } from 'use-intl';
+import createSharedNavigationFns from '../shared/createSharedNavigationFns.js';
+import syncLocaleCookie from '../shared/syncLocaleCookie.js';
+import { getRoute } from '../shared/utils.js';
+import useBasePathname from './useBasePathname.js';
+
+function createNavigation(routing) {
+  const {
+    Link,
+    config,
+    getPathname,
+    ...redirects
+  } = createSharedNavigationFns(useLocale, routing);
+
+  /** @see https://next-intl.dev/docs/routing/navigation#usepathname */
+  function usePathname() {
+    const pathname = useBasePathname(config);
+    const locale = useLocale();
+
+    // @ts-expect-error -- Mirror the behavior from Next.js, where `null` is returned when `usePathname` is used outside of Next, but the types indicate that a string is always returned.
+    return useMemo(() => pathname &&
+    // @ts-expect-error -- This is fine
+    config.pathnames ? getRoute(locale, pathname,
+    // @ts-expect-error -- This is fine
+    config.pathnames) : pathname, [locale, pathname]);
+  }
+  function useRouter$1() {
+    const router = useRouter();
+    const curLocale = useLocale();
+    return useMemo(() => {
+      function createHandler(fn) {
+        return function handler(href, options) {
+          const {
+            locale: nextLocale,
+            ...rest
+          } = options || {};
+          const pathname = getPathname({
+            href,
+            locale: nextLocale || curLocale,
+            // Always include a prefix when changing locales. Theoretically,
+            // this is only necessary for the case described in #2020. However,
+            // the full detection is rather expensive, and this behavior is
+            // consistent with the `Link` component. The downside is an
+            // additional redirect for users in other situations. Locale
+            // changes should be rare though, so this might be fine.
+            forcePrefix: nextLocale != null || undefined
+          });
+          const args = [pathname];
+          if (Object.keys(rest).length > 0) {
+            // @ts-expect-error -- This is fine
+            args.push(rest);
+          }
+          syncLocaleCookie(config.localeCookie, curLocale, nextLocale);
+          fn(...args);
+        };
+      }
+      return {
+        ...router,
+        /** @see https://next-intl.dev/docs/routing/navigation#userouter */
+        push: createHandler(router.push),
+        /** @see https://next-intl.dev/docs/routing/navigation#userouter */
+        replace: createHandler(router.replace),
+        /** @see https://next-intl.dev/docs/routing/navigation#userouter */
+        prefetch: createHandler(router.prefetch)
+      };
+    }, [curLocale, router]);
+  }
+  return {
+    ...redirects,
+    Link,
+    usePathname,
+    useRouter: useRouter$1,
+    getPathname
+  };
+}
+
+export { createNavigation as default };

e-commerce/node_modules/next-intl/dist/esm/development/navigation/react-client/useBasePathname.js

@@ -0,0 +1,36 @@
+import { usePathname } from 'next/navigation';
+import { useMemo } from 'react';
+import { useLocale } from 'use-intl';
+import { hasPathnamePrefixed, unprefixPathname, getLocalePrefix, getLocaleAsPrefix } from '../../shared/utils.js';
+
+function useBasePathname(config) {
+  // The types aren't entirely correct here. Outside of Next.js
+  // `useParams` can be called, but the return type is `null`.
+
+  // Notes on `useNextPathname`:
+  // - Types aren't entirely correct. Outside of Next.js the
+  //   hook will return `null` (e.g. unit tests)
+  // - A base path is stripped from the result
+  // - Rewrites *are* taken into account (i.e. the pathname
+  //   that the user sees in the browser is returned)
+  const pathname = usePathname();
+  const locale = useLocale();
+  return useMemo(() => {
+    if (!pathname) return pathname;
+    let unlocalizedPathname = pathname;
+    const prefix = getLocalePrefix(locale, config.localePrefix);
+    const isPathnamePrefixed = hasPathnamePrefixed(prefix, pathname);
+    if (isPathnamePrefixed) {
+      unlocalizedPathname = unprefixPathname(pathname, prefix);
+    } else if (config.localePrefix.mode !== 'never' && config.localePrefix.prefixes) {
+      // Workaround for https://github.com/vercel/next.js/issues/73085
+      const localeAsPrefix = getLocaleAsPrefix(locale);
+      if (hasPathnamePrefixed(localeAsPrefix, pathname)) {
+        unlocalizedPathname = unprefixPathname(pathname, localeAsPrefix);
+      }
+    }
+    return unlocalizedPathname;
+  }, [config.localePrefix, locale, pathname]);
+}
+
+export { useBasePathname as default };

e-commerce/node_modules/next-intl/dist/esm/development/navigation/react-server/createNavigation.js

@@ -0,0 +1,22 @@
+import createSharedNavigationFns from '../shared/createSharedNavigationFns.js';
+import getServerLocale from './getServerLocale.js';
+
+function createNavigation(routing) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const {
+    config,
+    ...fns
+  } = createSharedNavigationFns(getServerLocale, routing);
+  function notSupported(hookName) {
+    return () => {
+      throw new Error(`\`${hookName}\` is not supported in Server Components. You can use this hook if you convert the calling component to a Client Component.`);
+    };
+  }
+  return {
+    ...fns,
+    usePathname: notSupported('usePathname'),
+    useRouter: notSupported('useRouter')
+  };
+}
+
+export { createNavigation as default };

e-commerce/node_modules/next-intl/dist/esm/development/navigation/react-server/getServerLocale.js

@@ -0,0 +1,12 @@
+import getConfig from '../../server/react-server/getConfig.js';
+
+/**
+ * This is only moved to a separate module for easier mocking in
+ * `../createNavigatoin.test.tsx` in order to avoid suspending.
+ */
+async function getServerLocale() {
+  const config = await getConfig();
+  return config.locale;
+}
+
+export { getServerLocale as default };

e-commerce/node_modules/next-intl/dist/esm/development/navigation/shared/BaseLink.js

@@ -0,0 +1,64 @@
+"use client";
+import NextLink from 'next/link';
+import { forwardRef } from 'react';
+import { useLocale } from 'use-intl';
+import syncLocaleCookie from './syncLocaleCookie.js';
+import { jsx } from 'react/jsx-runtime';
+
+// Somehow the types for `next/link` don't work as expected
+// when `moduleResolution: "nodenext"` is used.
+const Link = NextLink;
+
+// Links that change the locale are handled in a separate component,
+// since they require additional handling for syncing the locale cookie.
+function LocaleChangingLink({
+  curLocale,
+  linkRef,
+  locale,
+  localeCookie,
+  onClick,
+  prefetch,
+  ...rest
+}) {
+  function onLinkClick(event) {
+    // Even though we force a prefix when changing locales,
+    // this could be a cache hit of the client-side router,
+    // therefore we sync the cookie to ensure it's up to date.
+    syncLocaleCookie(localeCookie, curLocale, locale);
+    if (onClick) onClick(event);
+  }
+  if (prefetch && "development" !== 'production') {
+    console.error('The `prefetch` prop is currently not supported when using the `locale` prop on `Link` to switch the locale.`');
+  }
+  return /*#__PURE__*/jsx(Link, {
+    ref: linkRef,
+    hrefLang: locale,
+    onClick: onLinkClick,
+    prefetch: false,
+    ...rest
+  });
+}
+function BaseLink({
+  locale,
+  localeCookie,
+  ...rest
+}, ref) {
+  const curLocale = useLocale();
+  const isChangingLocale = locale != null && locale !== curLocale;
+  if (isChangingLocale) {
+    return /*#__PURE__*/jsx(LocaleChangingLink, {
+      curLocale: curLocale,
+      linkRef: ref,
+      locale: locale,
+      localeCookie: localeCookie,
+      ...rest
+    });
+  }
+  return /*#__PURE__*/jsx(Link, {
+    ref: ref,
+    ...rest
+  });
+}
+var BaseLink$1 = /*#__PURE__*/forwardRef(BaseLink);
+
+export { BaseLink$1 as default };

e-commerce/node_modules/next-intl/dist/esm/development/navigation/shared/createSharedNavigationFns.js

@@ -0,0 +1,105 @@
+import { redirect, permanentRedirect } from 'next/navigation';
+import { forwardRef } from 'react';
+import { receiveRoutingConfig } from '../../routing/config.js';
+import use from '../../shared/use.js';
+import { isLocalizableHref, isPromise } from '../../shared/utils.js';
+import BaseLink from './BaseLink.js';
+import { validateReceivedConfig, serializeSearchParams, compileLocalizedPathname, applyPathnamePrefix, normalizeNameOrNameWithParams } from './utils.js';
+import { jsx } from 'react/jsx-runtime';
+
+/**
+ * Shared implementations for `react-server` and `react-client`
+ */
+function createSharedNavigationFns(getLocale, routing) {
+  const config = receiveRoutingConfig(routing || {});
+  {
+    validateReceivedConfig(config);
+  }
+  const pathnames = config.pathnames;
+  function Link({
+    href,
+    locale,
+    ...rest
+  }, ref) {
+    let pathname, params;
+    if (typeof href === 'object') {
+      pathname = href.pathname;
+      // @ts-expect-error -- This is ok
+      params = href.params;
+    } else {
+      pathname = href;
+    }
+
+    // @ts-expect-error -- This is ok
+    const isLocalizable = isLocalizableHref(href);
+    const localePromiseOrValue = getLocale();
+    const curLocale = isPromise(localePromiseOrValue) ? use(localePromiseOrValue) : localePromiseOrValue;
+    const finalPathname = isLocalizable ? getPathname({
+      locale: locale || curLocale,
+      // @ts-expect-error -- This is ok
+      href: pathnames == null ? pathname : {
+        pathname,
+        params
+      },
+      // Always include a prefix when changing locales
+      forcePrefix: locale != null || undefined
+    }) : pathname;
+    return /*#__PURE__*/jsx(BaseLink, {
+      ref: ref
+      // @ts-expect-error -- This is ok
+      ,
+      href: typeof href === 'object' ? {
+        ...href,
+        pathname: finalPathname
+      } : finalPathname,
+      locale: locale,
+      localeCookie: config.localeCookie,
+      ...rest
+    });
+  }
+  const LinkWithRef = /*#__PURE__*/forwardRef(Link);
+  function getPathname(args) {
+    const {
+      forcePrefix,
+      href,
+      locale
+    } = args;
+    let pathname;
+    if (pathnames == null) {
+      if (typeof href === 'object') {
+        pathname = href.pathname;
+        if (href.query) {
+          pathname += serializeSearchParams(href.query);
+        }
+      } else {
+        pathname = href;
+      }
+    } else {
+      pathname = compileLocalizedPathname({
+        locale,
+        // @ts-expect-error -- This is ok
+        ...normalizeNameOrNameWithParams(href),
+        // @ts-expect-error -- This is ok
+        pathnames: config.pathnames
+      });
+    }
+    return applyPathnamePrefix(pathname, locale, config, forcePrefix);
+  }
+  function getRedirectFn(fn) {
+    /** @see https://next-intl.dev/docs/routing/navigation#redirect */
+    return function redirectFn(args, ...rest) {
+      return fn(getPathname(args), ...rest);
+    };
+  }
+  const redirect$1 = getRedirectFn(redirect);
+  const permanentRedirect$1 = getRedirectFn(permanentRedirect);
+  return {
+    config,
+    Link: LinkWithRef,
+    redirect: redirect$1,
+    permanentRedirect: permanentRedirect$1,
+    getPathname
+  };
+}
+
+export { createSharedNavigationFns as default };

e-commerce/node_modules/next-intl/dist/esm/development/navigation/shared/syncLocaleCookie.js

@@ -0,0 +1,41 @@
+import { getBasePath } from './utils.js';
+
+/**
+ * We have to keep the cookie value in sync as Next.js might
+ * skip a request to the server due to its router cache.
+ * See https://github.com/amannn/next-intl/issues/786.
+ */
+function syncLocaleCookie(localeCookie, locale, nextLocale) {
+  const isSwitchingLocale = nextLocale !== locale && nextLocale != null;
+  if (!localeCookie || !isSwitchingLocale) {
+    return;
+  }
+  const {
+    name,
+    ...rest
+  } = localeCookie;
+  if (!rest.path) {
+    rest.path = getBasePath() || '/';
+  }
+  let localeCookieString = `${name}=${nextLocale};`;
+  for (const [key, value] of Object.entries(rest)) {
+    // Map object properties to cookie properties.
+    // Interestingly, `maxAge` corresponds to `max-age`,
+    // while `sameSite` corresponds to `SameSite`.
+    // Also, keys are case-insensitive.
+    const targetKey = key === 'maxAge' ? 'max-age' : key;
+    localeCookieString += `${targetKey}`;
+    if (typeof value !== 'boolean') {
+      localeCookieString += '=' + value;
+    }
+
+    // A trailing ";" is allowed by browsers
+    localeCookieString += ';';
+  }
+
+  // Note that writing to `document.cookie` doesn't overwrite all
+  // cookies, but only the ones referenced via the name here.
+  document.cookie = localeCookieString;
+}
+
+export { syncLocaleCookie as default };

e-commerce/node_modules/next-intl/dist/esm/development/navigation/shared/utils.js

@@ -0,0 +1,169 @@
+import { getSortedPathnames, matchesPathname, isLocalizableHref, prefixPathname, getLocalizedTemplate, normalizeTrailingSlash, getLocalePrefix } from '../../shared/utils.js';
+
+// Minor false positive: A route that has both optional and
+// required params will allow optional params.
+
+// For `Link`
+
+// For `getPathname` (hence also its consumers: `redirect`, `useRouter`, …)
+
+function normalizeNameOrNameWithParams(href) {
+  return typeof href === 'string' ? {
+    pathname: href
+  } : href;
+}
+function serializeSearchParams(searchParams) {
+  function serializeValue(value) {
+    return String(value);
+  }
+  const urlSearchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(searchParams)) {
+    if (Array.isArray(value)) {
+      value.forEach(cur => {
+        urlSearchParams.append(key, serializeValue(cur));
+      });
+    } else {
+      urlSearchParams.set(key, serializeValue(value));
+    }
+  }
+  return '?' + urlSearchParams.toString();
+}
+function compileLocalizedPathname({
+  pathname,
+  locale,
+  params,
+  pathnames,
+  query
+}) {
+  function compilePath(value) {
+    const pathnameConfig = pathnames[value];
+    let compiled;
+    if (pathnameConfig) {
+      const template = getLocalizedTemplate(pathnameConfig, locale, value);
+      compiled = template;
+      if (params) {
+        Object.entries(params).forEach(([key, paramValue]) => {
+          let regexp, replacer;
+          if (Array.isArray(paramValue)) {
+            regexp = `(\\[)?\\[...${key}\\](\\])?`;
+            replacer = paramValue.map(v => String(v)).join('/');
+          } else {
+            regexp = `\\[${key}\\]`;
+            replacer = String(paramValue);
+          }
+          compiled = compiled.replace(new RegExp(regexp, 'g'), () => replacer);
+        });
+      }
+
+      // Clean up optional catch-all segments that were not replaced
+      compiled = compiled.replace(/\[\[\.\.\..+\]\]/g, '');
+      if (compiled.includes('[')) {
+        // Next.js throws anyway, therefore better provide a more helpful error message
+        throw new Error(`Insufficient params provided for localized pathname.\nTemplate: ${template}\nParams: ${JSON.stringify(params)}`);
+      }
+      compiled = encodePathname(compiled);
+    } else {
+      // Unknown pathnames
+      compiled = value;
+    }
+    compiled = normalizeTrailingSlash(compiled);
+    if (query) {
+      // This also encodes non-ASCII characters by
+      // using `new URLSearchParams()` internally
+      compiled += serializeSearchParams(query);
+    }
+    return compiled;
+  }
+  if (typeof pathname === 'string') {
+    return compilePath(pathname);
+  } else {
+    const {
+      pathname: internalPathname,
+      ...rest
+    } = pathname;
+    const compiled = compilePath(internalPathname);
+    const result = {
+      ...rest,
+      pathname: compiled
+    };
+    return result;
+  }
+}
+function encodePathname(pathname) {
+  // Generally, to comply with RFC 3986 and Google's best practices for URL structures
+  // (https://developers.google.com/search/docs/crawling-indexing/url-structure),
+  // we should always encode non-ASCII characters.
+  //
+  // There are two places where next-intl interacts with potentially non-ASCII URLs:
+  // 1. Middleware: When mapping a localized pathname to a non-localized pathname internally
+  // 2. Navigation APIs: When generating a URLs to be used for <Link /> & friends
+  //
+  // Next.js normalizes incoming pathnames to always be encoded, therefore we can safely
+  // decode them there (see middleware.tsx). On the other hand, Next.js doesn't consistently
+  // encode non-ASCII characters that are passed to navigation APIs:
+  // 1. <Link /> doesn't encode non-ASCII characters
+  // 2. useRouter() uses `new URL()` internally, which will encode—but only if necessary
+  // 3. redirect() uses useRouter() on the client, but on the server side only
+  //    assigns the location header without encoding.
+  //
+  // In addition to this, for getPathname() we need to encode non-ASCII characters.
+  //
+  // Therefore, the bottom line is that next-intl should take care of encoding non-ASCII
+  // characters in all cases, but can rely on `new URL()` to not double-encode characters.
+  return new URL(pathname, 'http://l').pathname;
+}
+function getRoute(locale, pathname, pathnames) {
+  const sortedPathnames = getSortedPathnames(Object.keys(pathnames));
+  const decoded = decodeURI(pathname);
+  for (const internalPathname of sortedPathnames) {
+    const localizedPathnamesOrPathname = pathnames[internalPathname];
+    if (typeof localizedPathnamesOrPathname === 'string') {
+      const localizedPathname = localizedPathnamesOrPathname;
+      if (matchesPathname(localizedPathname, decoded)) {
+        return internalPathname;
+      }
+    } else {
+      if (matchesPathname(getLocalizedTemplate(localizedPathnamesOrPathname, locale, internalPathname), decoded)) {
+        return internalPathname;
+      }
+    }
+  }
+  return pathname;
+}
+function getBasePath() {
+  try {
+    // Provided via `env` setting in `next.config.js` via the plugin
+    return process.env._next_intl_base_path || '';
+  } catch {
+    return '';
+  }
+}
+function applyPathnamePrefix(pathname, locale, routing, force) {
+  const {
+    mode: routingMode
+  } = routing.localePrefix;
+  let shouldPrefix;
+  if (force !== undefined) {
+    shouldPrefix = force;
+  } else if (isLocalizableHref(pathname)) {
+    // Since locales are unique per domain, there should be
+    // only one domain that contains the locale
+    const domain = routing.domains?.find(cur => cur.locales.includes(locale));
+
+    // Domains can override the mode
+    const mode = domain?.localePrefix || routingMode;
+    if (mode === 'always') {
+      shouldPrefix = true;
+    } else if (mode === 'as-needed') {
+      shouldPrefix = domain ? locale !== domain.defaultLocale : locale !== routing.defaultLocale;
+    }
+  }
+  return shouldPrefix ? prefixPathname(getLocalePrefix(locale, routing.localePrefix), pathname) : pathname;
+}
+function validateReceivedConfig(config) {
+  if (config.localePrefix?.mode === 'as-needed' && !('defaultLocale' in config)) {
+    throw new Error("`localePrefix: 'as-needed' requires a `defaultLocale`.");
+  }
+}
+
+export { applyPathnamePrefix, compileLocalizedPathname, getBasePath, getRoute, normalizeNameOrNameWithParams, serializeSearchParams, validateReceivedConfig };

e-commerce/node_modules/next-intl/dist/esm/development/plugin.js

@@ -0,0 +1 @@
+export { default } from './plugin/createNextIntlPlugin.js';

e-commerce/node_modules/next-intl/dist/esm/development/plugin/config.js

@@ -0,0 +1,10 @@
+// Avoid rollup's `replace` plugin to compile this away
+const nodeEnvKey = 'NODE_ENV'.trim();
+
+// We avoid reading `argv.includes('dev')` related to
+// https://github.com/amannn/next-intl/issues/2006
+const isDevelopment = process.env[nodeEnvKey] === 'development';
+const isNextBuild = process.argv.includes('build');
+const isDevelopmentOrNextBuild = isDevelopment || isNextBuild;
+
+export { isDevelopment, isDevelopmentOrNextBuild, isNextBuild };

e-commerce/node_modules/next-intl/dist/esm/development/plugin/createNextIntlPlugin.js

@@ -0,0 +1,52 @@
+import normalizeExtractorConfig from '../extractor/normalizeExtractorConfig.js';
+import initExtractionCompiler from './extractor/initExtractionCompiler.js';
+import getNextConfig from './getNextConfig.js';
+import { warn } from './utils.js';
+import createMessagesDeclaration from './declaration/createMessagesDeclaration.js';
+
+function initPlugin(pluginConfig, nextConfig) {
+  if (nextConfig?.i18n != null) {
+    warn("An `i18n` property was found in your Next.js config. This likely causes conflicts and should therefore be removed if you use the App Router.\n\nIf you're in progress of migrating from the Pages Router, you can refer to this example: https://next-intl.dev/examples#app-router-migration\n");
+  }
+  const skipWatchers = isNextTelemetryDetachedFlushProcess();
+  const messagesPathOrPaths = pluginConfig.experimental?.createMessagesDeclaration;
+  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(extractorConfig);
+  }
+  return getNextConfig(pluginConfig, nextConfig, extractorConfig);
+}
+function createNextIntlPlugin(i18nPathOrConfig = {}) {
+  const config = typeof i18nPathOrConfig === 'string' ? {
+    requestConfig: i18nPathOrConfig
+  } : i18nPathOrConfig;
+  return function withNextIntl(nextConfig) {
+    return initPlugin(config, nextConfig);
+  };
+}
+
+/**
+ * Next runs `telemetry/detached-flush.js` in a detached process to flush telemetry
+ * (often when `next dev` exits). That loads dev `next.config` with inherited
+ * `NODE_ENV=development`, which would otherwise start orphan plugin watchers.
+ */
+function isNextTelemetryDetachedFlushProcess() {
+  const scriptPath = process.argv[1];
+  if (!scriptPath) return false;
+  const normalized = scriptPath.replace(/\\/g, '/');
+  return normalized.includes('/telemetry/detached-flush');
+}
+
+export { createNextIntlPlugin as default };