@common.js/next-intl 4.13.1

package/dist/esm/production/shared/utils.js

@@ -0,0 +1,156 @@
+"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, {
+    getLocaleAsPrefix: function() {
+        return f;
+    },
+    getLocalePrefix: function() {
+        return o;
+    },
+    getLocalizedTemplate: function() {
+        return u;
+    },
+    getSortedPathnames: function() {
+        return g;
+    },
+    hasPathnamePrefixed: function() {
+        return r;
+    },
+    isLocalizableHref: function() {
+        return n;
+    },
+    isPromise: function() {
+        return x;
+    },
+    matchesPathname: function() {
+        return c;
+    },
+    normalizeTrailingSlash: function() {
+        return i1;
+    },
+    prefixPathname: function() {
+        return e;
+    },
+    templateToRegex: function() {
+        return s;
+    },
+    unprefixPathname: function() {
+        return t;
+    }
+});
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i1 = 0, arr2 = new Array(len); i1 < len; i1++)arr2[i1] = arr[i1];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _toArray(arr) {
+    return _arrayWithHoles(arr) || _iterableToArray(arr) || _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);
+}
+function n(n) {
+    return function(n) {
+        return "object" == typeof n ? null == n.host && null == n.hostname : !/^[a-z]+:/i.test(n);
+    }(n) && !function(n) {
+        var t = "object" == typeof n ? n.pathname : n;
+        return null != t && !t.startsWith("/");
+    }(n);
+}
+function t(n, t) {
+    return n.replace(new RegExp("^".concat(t)), "") || "/";
+}
+function e(n, t) {
+    var e = n;
+    return /^\/(\?.*)?$/.test(t) && (t = t.slice(1)), e += t, e;
+}
+function r(n, t) {
+    return t === n || t.startsWith("".concat(n, "/"));
+}
+function u(n, t, e) {
+    return "string" == typeof n ? n : n[t] || e;
+}
+function i1(n) {
+    var t = function() {
+        try {
+            return "true" === process.env._next_intl_trailing_slash;
+        } catch (e) {
+            return !1;
+        }
+    }(), ref = _toArray(n.split("#")), e = ref[0], r = ref.slice(1), u = r.join("#");
+    var i1 = e;
+    if ("/" !== i1) {
+        var _$n = i1.endsWith("/");
+        t && !_$n ? i1 += "/" : !t && _$n && (i1 = i1.slice(0, -1));
+    }
+    return u && (i1 += "#" + u), i1;
+}
+function c(n, t) {
+    var e = i1(n), r = i1(t);
+    return s(e).test(r);
+}
+function o(n, t) {
+    var ref;
+    return "never" !== t.mode && ((ref = t.prefixes) === null || ref === void 0 ? void 0 : ref[n]) || f(n);
+}
+function f(n) {
+    return "/" + n;
+}
+function s(n) {
+    var t = n.replace(/\/\[\[(\.\.\.[^\]]+)\]\]/g, "(?:/(.*))?").replace(/\[\[(\.\.\.[^\]]+)\]\]/g, "(?:/(.*))?").replace(/\[(\.\.\.[^\]]+)\]/g, "(.+)").replace(/\[([^\]]+)\]/g, "([^/]+)");
+    return new RegExp("^".concat(t, "$"));
+}
+function l(n) {
+    return n.includes("[[...");
+}
+function p(n) {
+    return n.includes("[...");
+}
+function a(n) {
+    return n.includes("[");
+}
+function h(n, t) {
+    var e = n.split("/"), r = t.split("/"), u = Math.max(e.length, r.length);
+    for(var _$n = 0; _$n < u; _$n++){
+        var _$t = e[_$n], u1 = r[_$n];
+        if (!_$t && u1) return -1;
+        if (_$t && !u1) return 1;
+        if (_$t || u1) {
+            if (!a(_$t) && a(u1)) return -1;
+            if (a(_$t) && !a(u1)) return 1;
+            if (!p(_$t) && p(u1)) return -1;
+            if (p(_$t) && !p(u1)) return 1;
+            if (!l(_$t) && l(u1)) return -1;
+            if (l(_$t) && !l(u1)) return 1;
+        }
+    }
+    return 0;
+}
+function g(n) {
+    return n.sort(h);
+}
+function x(n) {
+    return "function" == typeof n.then;
+}

package/dist/types/config.d.ts

@@ -0,0 +1 @@
+export default function getConfig(): void;

package/dist/types/extractor/ExtractionCompiler.d.ts

@@ -0,0 +1,16 @@
+import MessageExtractor from './extractor/MessageExtractor.js';
+import type { ExtractorConfig } from './types.js';
+export default class ExtractionCompiler implements Disposable {
+    private manager;
+    constructor(config: ExtractorConfig, opts?: {
+        extractor?: MessageExtractor;
+        isDevelopment?: boolean;
+        projectRoot?: string;
+        saveDebounceMs?: number;
+        sourceMap?: boolean;
+    });
+    extractAll(): Promise<void>;
+    [Symbol.dispose](): void;
+    private installExitHandlers;
+    private uninstallExitHandlers;
+}

package/dist/types/extractor/catalog/CatalogLocales.d.ts

@@ -0,0 +1,29 @@
+import type { ExtractorConfig, Locale } from '../types.js';
+type LocaleChangeCallback = (params: {
+    added: Array<Locale>;
+    removed: Array<Locale>;
+}) => unknown;
+type CatalogLocalesParams = {
+    messagesDir: string;
+    sourceLocale: Locale;
+    extension: string;
+    locales: ExtractorConfig['extract']['locales'];
+};
+export default class CatalogLocales {
+    private messagesDir;
+    private extension;
+    private sourceLocale;
+    private locales;
+    private watcher?;
+    private targetLocales?;
+    private onChangeCallbacks;
+    constructor(params: CatalogLocalesParams);
+    getTargetLocales(): Promise<Array<Locale>>;
+    private readTargetLocales;
+    subscribeLocalesChange(callback: LocaleChangeCallback): void;
+    unsubscribeLocalesChange(callback: LocaleChangeCallback): void;
+    private startWatcher;
+    private stopWatcher;
+    private onChange;
+}
+export {};

package/dist/types/extractor/catalog/CatalogManager.d.ts

@@ -0,0 +1,76 @@
+import type MessageExtractor from '../extractor/MessageExtractor.js';
+import type { ExtractorConfig } from '../types.js';
+export default class CatalogManager implements Disposable {
+    /**
+     * 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).
+     */
+    private static readonly extractorOwnedAggregatorKeys;
+    private config;
+    /**
+     * Source of truth for statically extracted source messages,
+     * grouped by file and message ID.
+     */
+    private sourceMessagesByFile;
+    /**
+     * Reverse index for rebuilding aggregated messages without scanning all files.
+     * Contains the same `SourceMessage` arrays as `sourceMessagesByFile` and is
+     * kept in sync with it.
+     */
+    private sourceMessagesById;
+    /**
+     * Fast lookup for messages by ID, aggregated across all files. This combines
+     * metadata from `sourceMessagesById`, e.g. references and descriptions.
+     */
+    private messagesById;
+    /**
+     * 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.
+     **/
+    private translationsByTargetLocale;
+    private lastWriteByLocale;
+    private saveScheduler;
+    private projectRoot;
+    private isDevelopment;
+    private persister?;
+    private codec?;
+    private catalogLocales?;
+    private extractor;
+    private sourceWatcher?;
+    private loadCatalogsPromise?;
+    private scanCompletePromise?;
+    constructor(config: ExtractorConfig, opts: {
+        extractor: MessageExtractor;
+        isDevelopment?: boolean;
+        projectRoot?: string;
+        saveDebounceMs?: number;
+        sourceMap?: boolean;
+    });
+    private getCodec;
+    private getPersister;
+    private getCatalogLocales;
+    private getTargetLocales;
+    private getSrcPaths;
+    loadMessages(): Promise<void>;
+    private loadSourceMessages;
+    private loadLocaleMessages;
+    private loadTargetMessages;
+    private reloadLocaleCatalog;
+    private mergeSourceDiskMetadata;
+    private processFile;
+    private extractFile;
+    private applyFileMessages;
+    private groupSourceMessagesById;
+    private rebuildMessageById;
+    private mergeDescriptions;
+    private haveMessagesChangedForFile;
+    private areSourceMessageArraysEqual;
+    private areSourceMessagesEqual;
+    save(): Promise<void>;
+    private saveImpl;
+    private saveLocale;
+    private onLocalesChange;
+    private handleFileEvents;
+    [Symbol.dispose](): void;
+}

package/dist/types/extractor/catalog/CatalogPersister.d.ts

@@ -0,0 +1,20 @@
+import type ExtractorCodec from '../format/ExtractorCodec.js';
+import type { ExtractorMessage, Locale } from '../types.js';
+export default class CatalogPersister {
+    private messagesPath;
+    private codec;
+    private extension;
+    constructor(params: {
+        messagesPath: string;
+        codec: ExtractorCodec;
+        extension: string;
+    });
+    private getFileName;
+    private getFilePath;
+    read(locale: Locale): Promise<Array<ExtractorMessage>>;
+    write(messages: Array<ExtractorMessage>, context: {
+        locale: Locale;
+        sourceMessagesById: Map<string, ExtractorMessage>;
+    }): Promise<void>;
+    getLastModified(locale: Locale): Promise<Date | undefined>;
+}

package/dist/types/extractor/catalog/SaveScheduler.d.ts

@@ -0,0 +1,18 @@
+type SaveTask<T> = () => Promise<T>;
+/**
+ * De-duplicates excessive save invocations,
+ * while keeping a single one instant.
+ */
+export default class SaveScheduler<Value> implements Disposable {
+    private saveTimeout?;
+    private isSaving;
+    private delayMs;
+    private pendingResolvers;
+    private nextSaveTask?;
+    constructor(delayMs?: number);
+    schedule(saveTask: SaveTask<Value>): Promise<Value>;
+    private scheduleSave;
+    private executeSave;
+    [Symbol.dispose](): void;
+}
+export {};

package/dist/types/extractor/extractMessages.d.ts

@@ -0,0 +1,2 @@
+import type { ExtractorConfigInput } from './types.js';
+export default function extractMessages(params: ExtractorConfigInput): Promise<void>;

package/dist/types/extractor/extractor/LRUCache.d.ts

@@ -0,0 +1,7 @@
+export default class LRUCache<Value> {
+    private readonly maxSize;
+    private cache;
+    constructor(maxSize: number);
+    set(key: string, value: Value): void;
+    get(key: string): Value | undefined;
+}

package/dist/types/extractor/extractor/MessageExtractor.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/extractor/extractor/MessageExtractor.d.ts

@@ -0,0 +1,17 @@
+import type { SourceMessage } from '../types.js';
+export default class MessageExtractor {
+    private isDevelopment;
+    private projectRoot;
+    private sourceMap;
+    private compileCache;
+    constructor(opts: {
+        isDevelopment?: boolean;
+        projectRoot?: string;
+        sourceMap?: boolean;
+    });
+    extract(absoluteFilePath: string, source: string): Promise<{
+        messages: Array<SourceMessage>;
+        code: string;
+        map?: string;
+    }>;
+}

package/dist/types/extractor/format/ExtractorCodec.d.ts

@@ -0,0 +1,33 @@
+import type { ExtractorMessage, Locale } from '../types.js';
+type ExtractorCodecContext = {
+    locale: Locale;
+};
+export default interface ExtractorCodec {
+    /**
+     * Decode the content of a file into a list of extracted messages. This is used
+     * to load existing messages from disk.
+     */
+    decode(content: string, context: ExtractorCodecContext): Array<ExtractorMessage>;
+    /**
+     * Encode a list of extracted messages into a string that can be written as
+     * file content to the disk.
+     */
+    encode(messages: Array<ExtractorMessage>, context: ExtractorCodecContext & {
+        sourceMessagesById: Map</* ID */ string, ExtractorMessage>;
+    }): string;
+    /**
+     * Turns the content of a file into a JSON string that represents extracted
+     * messages. The returned value will be passed to `JSON.parse`.
+     *
+     * @return E.g. `[{"id":"-YJVTi","message":"Hey!"}]`
+     *
+     * This is used when loading messages into your application, typically via a
+     * dynamic import (e.g. `import(`../messages/${locale}.json`)`).
+     *
+     * If your file content is JSON and should be used as-is, you can set this to
+     * an identity function.
+     */
+    toJSONString(content: string, context: ExtractorCodecContext): string;
+}
+export declare function defineCodec(factory: () => ExtractorCodec): () => ExtractorCodec;
+export {};

package/dist/types/extractor/format/codecs/JSONCodec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("../ExtractorCodec.js").default;
+export default _default;

package/dist/types/extractor/format/codecs/POCodec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("../ExtractorCodec.js").default;
+export default _default;

package/dist/types/extractor/format/codecs/fixtures/JSONCodecStructured.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("../../ExtractorCodec.js").default;
+export default _default;

package/dist/types/extractor/format/codecs/fixtures/POCodecSourceMessageKey.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("../../ExtractorCodec.js").default;
+export default _default;

package/dist/types/extractor/format/index.d.ts

@@ -0,0 +1,15 @@
+import type ExtractorCodec from './ExtractorCodec.js';
+import type { MessagesFormat } from './types.js';
+declare const formats: {
+    json: {
+        codec: () => Promise<typeof import("./codecs/JSONCodec.js")>;
+        extension: ".json";
+    };
+    po: {
+        codec: () => Promise<typeof import("./codecs/POCodec.js")>;
+        extension: ".po";
+    };
+};
+export default formats;
+export declare function getFormatExtension(format: MessagesFormat): string;
+export declare function resolveCodec(format: MessagesFormat, projectRoot: string): Promise<ExtractorCodec>;

package/dist/types/extractor/format/types.d.ts

@@ -0,0 +1,8 @@
+import type formats from './index.js';
+export type BuiltInMessagesFormat = keyof typeof formats;
+type CustomMessagesFormat = {
+    codec: string;
+    extension: `.${string}`;
+};
+export type MessagesFormat = BuiltInMessagesFormat | CustomMessagesFormat;
+export {};

package/dist/types/extractor/index.d.ts

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

package/dist/types/extractor/normalizeExtractorConfig.d.ts

@@ -0,0 +1,5 @@
+import type { ExtractorConfig, ExtractorConfigInput } from './types.js';
+export declare function normalizeMessagesCatalogPaths(messagesPath: string | Array<string>): Array<string>;
+export default function normalizeExtractorConfig(input: Omit<ExtractorConfigInput, 'messages'> & {
+    messages?: ExtractorConfigInput['messages'];
+}): ExtractorConfig;

package/dist/types/extractor/source/SourceFileFilter.d.ts

@@ -0,0 +1,8 @@
+export default class SourceFileFilter {
+    static readonly EXTENSIONS: string[];
+    static readonly IGNORED_DIRECTORIES: string[];
+    static isSourceFile(filePath: string): boolean;
+    static shouldEnterDirectory(dirPath: string, srcPaths: Array<string>): boolean;
+    private static isIgnoredDirectoryExplicitlyIncluded;
+    static isWithinPath(targetPath: string, basePath: string): boolean;
+}

package/dist/types/extractor/source/SourceFileScanner.d.ts

@@ -0,0 +1,4 @@
+export default class SourceFileScanner {
+    private static walkSourceFiles;
+    static getSourceFiles(srcPaths: Array<string>): Promise<Set<string>>;
+}

package/dist/types/extractor/source/SourceFileWatcher.d.ts

@@ -0,0 +1,15 @@
+import { type Event } from '@parcel/watcher';
+type OnChange = (events: Array<Event>) => Promise<void>;
+export type SourceFileWatcherEvent = Event;
+export default class SourceFileWatcher implements Disposable {
+    private subscriptions;
+    private roots;
+    private onChange;
+    constructor(roots: Array<string>, onChange: OnChange);
+    start(): Promise<void>;
+    private normalizeEvents;
+    expandDirectoryDeleteEvents(events: Array<Event>, prevKnownFiles: Array<string>): Promise<Array<Event>>;
+    stop(): Promise<void>;
+    [Symbol.dispose](): void;
+}
+export {};

package/dist/types/extractor/types.d.ts

@@ -0,0 +1,79 @@
+import type { MessagesFormat } from './format/types.js';
+export type Locale = string;
+export type ExtractorMessageReference = {
+    path: string;
+    line?: number;
+};
+/** A single statically extracted source-code usage before any aggregation. */
+export type SourceMessage = {
+    id: string;
+    message: string;
+    description: string | null;
+    reference: ExtractorMessageReference;
+};
+/** An aggregated message that can be read from or written to a catalog. */
+export type ExtractorMessage = {
+    id: string;
+    message: string;
+    /**
+     * All unique descriptions attached to messages (e.g. multiple `#.` lines in PO).
+     * Ordered by source reference (path, then line).
+     */
+    description: Array<string>;
+    /**
+     * Source locations for this message (e.g. `#:` lines in PO). Ordered by path, then line.
+     * Empty when the catalog format does not store references or none are known.
+     */
+    references: Array<ExtractorMessageReference>;
+    /** Allows for additional properties like .po flags to be read and later written. */
+    [key: string]: unknown;
+};
+/**
+ * External extractor configuration (Next.js plugin, `extractMessages`).
+ */
+export type ExtractorConfigInput = {
+    /**
+     * Relative path(s) to your source code files.
+     */
+    srcPath?: string | Array<string>;
+    messages: {
+        /** The format of your messages files. */
+        format: MessagesFormat;
+        /** Relative path(s) to your messages files. */
+        path: string | Array<string>;
+        /**
+         * Locales kept in sync with [`messages.sourceLocale`](https://next-intl.dev/docs/usage/plugin#messages-source-locale).
+         */
+        locales: 'infer' | ReadonlyArray<Locale>;
+        /** Locale to which extracted source strings are written. */
+        sourceLocale?: string;
+    };
+    /**
+     * Enables the usage of `useExtracted`.
+     */
+    extract?: true | {
+        /** Defaults to `messages.path` when it is a single path. */
+        path?: string;
+        /** @deprecated Prefer `messages.sourceLocale`. */
+        sourceLocale?: string;
+    };
+};
+/** Normalized config used internally after `normalizeExtractorConfig`. */
+export type ExtractorConfig = {
+    extract: {
+        locales: 'infer' | ReadonlyArray<Locale>;
+        path: string;
+        sourceLocale: string;
+        srcPath: string | Array<string>;
+    };
+    messages: {
+        format: MessagesFormat;
+        path: Array<string>;
+    };
+};
+export type CatalogLoaderConfig = {
+    messages: {
+        format: MessagesFormat;
+        precompile?: boolean;
+    };
+};

package/dist/types/extractor/utils.d.ts

@@ -0,0 +1,9 @@
+import type { ExtractorConfig, ExtractorMessage, ExtractorMessageReference } from './types.js';
+export declare function normalizePathToPosix(filePath: string): string;
+export declare function isForbiddenObjectKey(key: string): boolean;
+export declare function hasLocalesToExtract(config: Pick<ExtractorConfig, 'extract'>): boolean;
+export declare function setNestedProperty(obj: Record<string, any>, keyPath: string, value: any): void;
+export declare function getSortedMessages(messages: Array<ExtractorMessage>): Array<ExtractorMessage>;
+export declare function localeCompare(a: string, b: string): number;
+export declare function compareReferences(refA: ExtractorMessageReference, refB: ExtractorMessageReference): number;
+export declare function getDefaultProjectRoot(): string;

package/dist/types/extractor.d.ts

@@ -0,0 +1 @@
+export * from './extractor/index.js';

package/dist/types/index.react-client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is the default entry file when consumers import from
+ * 'next-intl'. We use the client APIs in this case.
+ *
+ * Note that the `react-server` environment (i.e. RSC) imports
+ * from `./react-server` instead.
+ */
+export * from './react-client/index.js';

package/dist/types/index.react-server.d.ts

@@ -0,0 +1 @@
+export * from './react-server/index.js';

package/dist/types/middleware/getAlternateLinksHeaderValue.d.ts

@@ -0,0 +1,13 @@
+import type { NextRequest } from 'next/server.js';
+import type { ResolvedRoutingConfig } from '../routing/config.js';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../routing/types.js';
+/**
+ * See https://developers.google.com/search/docs/specialty/international/localized-versions
+ */
+export default function getAlternateLinksHeaderValue<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined>({ internalTemplateName, localizedPathnames, request, resolvedLocale, routing }: {
+    routing: Omit<ResolvedRoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'pathnames'>;
+    request: NextRequest;
+    resolvedLocale: AppLocales[number];
+    localizedPathnames?: Pathnames<AppLocales>[string];
+    internalTemplateName?: string;
+}): string;

package/dist/types/middleware/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The middleware, available as `next-intl/middleware`.
+ */
+export { default } from './middleware.js';

package/dist/types/middleware/middleware.d.ts

@@ -0,0 +1,4 @@
+import { type NextRequest, NextResponse } from 'next/server.js';
+import { type RoutingConfig } from '../routing/config.js';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../routing/types.js';
+export default function createMiddleware<const AppLocales extends Locales, const AppLocalePrefixMode extends LocalePrefixMode = 'always', const AppPathnames extends Pathnames<AppLocales> = never, const AppDomains extends DomainsConfig<AppLocales> = never>(routing: RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>): (request: NextRequest) => NextResponse<unknown>;

package/dist/types/middleware/resolveLocale.d.ts

@@ -0,0 +1,9 @@
+import type { RequestCookies } from 'next/dist/server/web/spec-extension/cookies.js';
+import type { Locale } from 'use-intl';
+import type { ResolvedRoutingConfig } from '../routing/config.js';
+import type { DomainConfig, DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../routing/types.js';
+export declare function getAcceptLanguageLocale<AppLocales extends Locales>(requestHeaders: Headers, locales: AppLocales, defaultLocale: Locale): string | undefined;
+export default function resolveLocale<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined>(routing: Omit<ResolvedRoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'pathnames'>, requestHeaders: Headers, requestCookies: RequestCookies, pathname: string): {
+    locale: AppLocales[number];
+    domain?: DomainConfig<AppLocales>;
+};

package/dist/types/middleware/syncCookie.d.ts

@@ -0,0 +1,7 @@
+import type { NextRequest, NextResponse } from 'next/server.js';
+import type { Locale } from 'use-intl';
+import type { InitializedLocaleCookieConfig, ResolvedRoutingConfig } from '../routing/config.js';
+import type { DomainConfig, DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../routing/types.js';
+export default function syncCookie<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined>(request: NextRequest, response: NextResponse, locale: Locale, routing: Pick<ResolvedRoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'locales' | 'defaultLocale'> & {
+    localeCookie: InitializedLocaleCookieConfig;
+}, domain?: DomainConfig<AppLocales>): void;