@common.js/next-intl 4.13.1

package/dist/esm/development/navigation/shared/utils.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    applyPathnamePrefix: function() {
+        return applyPathnamePrefix;
+    },
+    compileLocalizedPathname: function() {
+        return compileLocalizedPathname;
+    },
+    getBasePath: function() {
+        return getBasePath;
+    },
+    getRoute: function() {
+        return getRoute;
+    },
+    normalizeNameOrNameWithParams: function() {
+        return normalizeNameOrNameWithParams;
+    },
+    serializeSearchParams: function() {
+        return serializeSearchParams;
+    },
+    validateReceivedConfig: function() {
+        return validateReceivedConfig;
+    }
+});
+var _utilsJs = require("../../shared/utils.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+// 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) {
+    var serializeValue = function serializeValue(value) {
+        return String(value);
+    };
+    var urlSearchParams = new URLSearchParams();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        var _loop = function() {
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+            if (Array.isArray(value)) {
+                value.forEach(function(cur) {
+                    urlSearchParams.append(key, serializeValue(cur));
+                });
+            } else {
+                urlSearchParams.set(key, serializeValue(value));
+            }
+        };
+        for(var _iterator = Object.entries(searchParams)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return "?" + urlSearchParams.toString();
+}
+function compileLocalizedPathname(param) {
+    var pathname = param.pathname, locale = param.locale, params = param.params, pathnames = param.pathnames, query = param.query;
+    var compilePath = function compilePath(value) {
+        var pathnameConfig = pathnames[value];
+        var compiled;
+        if (pathnameConfig) {
+            var template = (0, _utilsJs.getLocalizedTemplate)(pathnameConfig, locale, value);
+            compiled = template;
+            if (params) {
+                Object.entries(params).forEach(function(param) {
+                    var _param = _slicedToArray(param, 2), key = _param[0], paramValue = _param[1];
+                    var regexp, replacer;
+                    if (Array.isArray(paramValue)) {
+                        regexp = "(\\[)?\\[...".concat(key, "\\](\\])?");
+                        replacer = paramValue.map(function(v) {
+                            return String(v);
+                        }).join("/");
+                    } else {
+                        regexp = "\\[".concat(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: ".concat(template, "\nParams: ").concat(JSON.stringify(params)));
+            }
+            compiled = encodePathname(compiled);
+        } else {
+            // Unknown pathnames
+            compiled = value;
+        }
+        compiled = (0, _utilsJs.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 {
+        var internalPathname = pathname.pathname, rest = _objectWithoutProperties(pathname, [
+            "pathname"
+        ]);
+        var compiled = compilePath(internalPathname);
+        var result = _objectSpreadProps(_objectSpread({}, 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) {
+    var sortedPathnames = (0, _utilsJs.getSortedPathnames)(Object.keys(pathnames));
+    var decoded = decodeURI(pathname);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = sortedPathnames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var internalPathname = _step.value;
+            var localizedPathnamesOrPathname = pathnames[internalPathname];
+            if (typeof localizedPathnamesOrPathname === "string") {
+                var localizedPathname = localizedPathnamesOrPathname;
+                if ((0, _utilsJs.matchesPathname)(localizedPathname, decoded)) {
+                    return internalPathname;
+                }
+            } else {
+                if ((0, _utilsJs.matchesPathname)((0, _utilsJs.getLocalizedTemplate)(localizedPathnamesOrPathname, locale, internalPathname), decoded)) {
+                    return internalPathname;
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return pathname;
+}
+function getBasePath(pathname) {
+    var windowPathname = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : window.location.pathname;
+    if (pathname === "/") {
+        return windowPathname;
+    } else {
+        return windowPathname.replace(pathname, "");
+    }
+}
+function applyPathnamePrefix(pathname, locale, routing, force) {
+    var _localePrefix = routing.localePrefix, routingMode = _localePrefix.mode;
+    var shouldPrefix;
+    if (force !== undefined) {
+        shouldPrefix = force;
+    } else if ((0, _utilsJs.isLocalizableHref)(pathname)) {
+        var ref;
+        // Since locales are unique per domain, there should be
+        // only one domain that contains the locale
+        var domain = (ref = routing.domains) === null || ref === void 0 ? void 0 : ref.find(function(cur) {
+            return cur.locales.includes(locale);
+        });
+        // Domains can override the mode
+        var mode = (domain === null || domain === void 0 ? void 0 : domain.localePrefix) || routingMode;
+        if (mode === "always") {
+            shouldPrefix = true;
+        } else if (mode === "as-needed") {
+            shouldPrefix = domain ? locale !== domain.defaultLocale : locale !== routing.defaultLocale;
+        }
+    }
+    return shouldPrefix ? (0, _utilsJs.prefixPathname)((0, _utilsJs.getLocalePrefix)(locale, routing.localePrefix), pathname) : pathname;
+}
+function validateReceivedConfig(config) {
+    var ref;
+    if (((ref = config.localePrefix) === null || ref === void 0 ? void 0 : ref.mode) === "as-needed" && !("defaultLocale" in config)) {
+        throw new Error("`localePrefix: 'as-needed' requires a `defaultLocale`.");
+    }
+}

package/dist/esm/development/navigation.react-client.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createNavigation", {
+    enumerable: true,
+    get: function() {
+        return _createNavigationJs.default;
+    }
+});
+var _createNavigationJs = /*#__PURE__*/ _interopRequireDefault(require("./navigation/react-client/createNavigation.js"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}

package/dist/esm/development/navigation.react-server.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createNavigation", {
+    enumerable: true,
+    get: function() {
+        return _createNavigationJs.default;
+    }
+});
+var _createNavigationJs = /*#__PURE__*/ _interopRequireDefault(require("./navigation/react-server/createNavigation.js"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}

package/dist/esm/development/plugin/config.js

@@ -0,0 +1,28 @@
+// Avoid rollup's `replace` plugin to compile this away
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isDevelopment: function() {
+        return isDevelopment;
+    },
+    isDevelopmentOrNextBuild: function() {
+        return isDevelopmentOrNextBuild;
+    },
+    isNextBuild: function() {
+        return isNextBuild;
+    }
+});
+var nodeEnvKey = "NODE_ENV".trim();
+// We avoid reading `argv.includes('dev')` related to
+// https://github.com/amannn/next-intl/issues/2006
+var isDevelopment = process.env[nodeEnvKey] === "development";
+var isNextBuild = process.argv.includes("build");
+var isDevelopmentOrNextBuild = isDevelopment || isNextBuild;

package/dist/esm/development/plugin/createNextIntlPlugin.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createNextIntlPlugin;
+    }
+});
+var _normalizeExtractorConfigJs = /*#__PURE__*/ _interopRequireDefault(require("../extractor/normalizeExtractorConfig.js"));
+var _initExtractionCompilerJs = /*#__PURE__*/ _interopRequireDefault(require("./extractor/initExtractionCompiler.js"));
+var _getNextConfigJs = /*#__PURE__*/ _interopRequireDefault(require("./getNextConfig.js"));
+var _utilsJs = require("./utils.js");
+var _createMessagesDeclarationJs = /*#__PURE__*/ _interopRequireDefault(require("./declaration/createMessagesDeclaration.js"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function initPlugin(pluginConfig, nextConfig) {
+    var ref;
+    if ((nextConfig === null || nextConfig === void 0 ? void 0 : nextConfig.i18n) != null) {
+        (0, _utilsJs.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");
+    }
+    var skipWatchers = isNextTelemetryDetachedFlushProcess();
+    var messagesPathOrPaths = (ref = pluginConfig.experimental) === null || ref === void 0 ? void 0 : ref.createMessagesDeclaration;
+    if (messagesPathOrPaths && !skipWatchers) {
+        (0, _createMessagesDeclarationJs.default)(typeof messagesPathOrPaths === "string" ? [
+            messagesPathOrPaths
+        ] : messagesPathOrPaths);
+    }
+    var extractorConfig;
+    var experimental = pluginConfig.experimental;
+    var extract = experimental === null || experimental === void 0 ? void 0 : experimental.extract;
+    if (extract) {
+        extractorConfig = (0, _normalizeExtractorConfigJs.default)({
+            extract: extract,
+            messages: experimental.messages,
+            srcPath: experimental.srcPath
+        });
+    }
+    if (!skipWatchers) {
+        (0, _initExtractionCompilerJs.default)(extractorConfig);
+    }
+    return (0, _getNextConfigJs.default)(pluginConfig, nextConfig, extractorConfig);
+}
+function createNextIntlPlugin() {
+    var i18nPathOrConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var 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() {
+    var scriptPath = process.argv[1];
+    if (!scriptPath) return false;
+    var normalized = scriptPath.replace(/\\/g, "/");
+    return normalized.includes("/telemetry/detached-flush");
+}

package/dist/esm/development/plugin/declaration/createMessagesDeclaration.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createMessagesDeclaration;
+    }
+});
+var _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+var _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+var _utilsJs = require("../utils.js");
+var _watchFileJs = /*#__PURE__*/ _interopRequireDefault(require("../watchFile.js"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var runOnce = (0, _utilsJs.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
+    var shouldBailOut = [
+        "info",
+        "start"
+    ].some(function(arg) {
+        return process.argv.includes(arg);
+    });
+    if (shouldBailOut) {
+        return;
+    }
+    runOnce(function() {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = messagesPaths[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var messagesPath = _step.value;
+                var fullPath = _path.default.resolve(messagesPath);
+                if (!_fs.default.existsSync(fullPath)) {
+                    (0, _utilsJs.throwError)("`createMessagesDeclaration` points to a non-existent file: ".concat(fullPath));
+                }
+                if (!fullPath.endsWith(".json")) {
+                    (0, _utilsJs.throwError)("`createMessagesDeclaration` needs to point to a JSON file. Received: ".concat(fullPath));
+                }
+                // Keep this as a runtime check and don't replace
+                // this with a constant during the build process
+                var env = process.env["NODE_ENV".trim()];
+                compileDeclaration(messagesPath);
+                if (env === "development") {
+                    startWatching(messagesPath);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    });
+}
+function startWatching(messagesPath) {
+    var watcher = (0, _watchFileJs.default)(messagesPath, function() {
+        compileDeclaration(messagesPath, true);
+    });
+    process.on("exit", function() {
+        watcher.close();
+    });
+}
+function compileDeclaration(messagesPath) {
+    var async = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    var createDeclaration = function createDeclaration(content) {
+        return "// This file is auto-generated by next-intl, do not edit directly.\n// See: https://next-intl.dev/docs/workflows/typescript#messages-arguments\n\ndeclare const messages: ".concat(content.trim(), ";\nexport default messages;");
+    };
+    var declarationPath = messagesPath.replace(/\.json$/, ".d.json.ts");
+    if (async) {
+        return _fs.default.promises.readFile(messagesPath, "utf-8").then(function(content) {
+            return _fs.default.promises.writeFile(declarationPath, createDeclaration(content));
+        });
+    }
+    var content = _fs.default.readFileSync(messagesPath, "utf-8");
+    _fs.default.writeFileSync(declarationPath, createDeclaration(content));
+}

package/dist/esm/development/plugin/extractor/initExtractionCompiler.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return initExtractionCompiler;
+    }
+});
+var _extractionCompilerJs = /*#__PURE__*/ _interopRequireDefault(require("../../extractor/ExtractionCompiler.js"));
+var _utilsJs = require("../../extractor/utils.js");
+var _configJs = require("../config.js");
+var _utilsJs1 = require("../utils.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// Single compiler instance, initialized once per process
+var compiler;
+var runOnce = (0, _utilsJs1.once)("_NEXT_INTL_EXTRACT");
+function initExtractionCompiler(extractorConfig) {
+    if (!extractorConfig || !(0, _utilsJs.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)
+    var shouldRun = _configJs.isDevelopment || _configJs.isNextBuild;
+    if (!shouldRun) return;
+    runOnce(function() {
+        var cleanup = function cleanup() {
+            if (compiler) {
+                compiler[Symbol.dispose]();
+                compiler = undefined;
+            }
+        };
+        compiler = new _extractionCompilerJs.default(extractorConfig, {
+            isDevelopment: _configJs.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();
+        process.on("exit", cleanup);
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    });
+}