@common.js/next-intl 4.13.1

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

@@ -0,0 +1,2 @@
+import type { useTimeZone as useTimeZoneType } from 'use-intl';
+export default function useTimeZone(): ReturnType<typeof useTimeZoneType>;

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

@@ -0,0 +1,2 @@
+import type { useTranslations as useTranslationsType } from 'use-intl';
+export default function useTranslations(...[namespace]: Parameters<typeof useTranslationsType>): ReturnType<typeof useTranslationsType>;

package/dist/types/routing/config.d.ts

@@ -0,0 +1,73 @@
+import type { NextResponse } from 'next/server.js';
+import type { DomainsConfig, LocalePrefix, LocalePrefixConfigVerbose, LocalePrefixMode, Locales, Pathnames } from './types.js';
+type CookieAttributes = Pick<NonNullable<Parameters<typeof NextResponse.prototype.cookies.set>['2']>, 'maxAge' | 'domain' | 'partitioned' | 'path' | 'priority' | 'sameSite' | 'secure' | 'name'>;
+export type RoutingConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined> = {
+    /**
+     * All available locales.
+     * @see https://next-intl.dev/docs/routing
+     */
+    locales: AppLocales;
+    /**
+     * Used when no locale matches.
+     * @see https://next-intl.dev/docs/routing
+     */
+    defaultLocale: AppLocales[number];
+    /**
+     * Configures whether and which prefix is shown for a given locale.
+     * @see https://next-intl.dev/docs/routing/configuration#locale-prefix
+     **/
+    localePrefix?: LocalePrefix<AppLocales, AppLocalePrefixMode>;
+    /**
+     * Can be used to change the locale handling per domain.
+     * @see https://next-intl.dev/docs/routing/configuration#domains
+     **/
+    domains?: AppDomains;
+    /**
+     * Can be used to disable the locale cookie or to customize it.
+     * @see https://next-intl.dev/docs/routing/middleware#locale-cookie
+     */
+    localeCookie?: boolean | CookieAttributes;
+    /**
+     * Sets the `Link` response header to notify search engines about content in other languages (defaults to `true`). See https://developers.google.com/search/docs/specialty/international/localized-versions#http
+     * @see https://next-intl.dev/docs/routing/middleware#alternate-links
+     **/
+    alternateLinks?: boolean;
+    /**
+     * By setting this to `false`, the cookie as well as the `accept-language` header will no longer be used for locale detection.
+     * @see https://next-intl.dev/docs/routing/middleware#locale-detection
+     **/
+    localeDetection?: boolean;
+} & ([AppPathnames] extends [never] ? {} : {
+    /**
+     * A map of localized pathnames per locale.
+     * @see https://next-intl.dev/docs/routing/configuration#pathnames
+     **/
+    pathnames: AppPathnames;
+});
+export type RoutingConfigSharedNavigation<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppDomains extends DomainsConfig<AppLocales> = never> = Omit<RoutingConfig<AppLocales, AppLocalePrefixMode, never, AppDomains>, 'defaultLocale' | 'locales' | 'pathnames'> & Partial<Pick<RoutingConfig<AppLocales, never, never, AppDomains>, 'defaultLocale' | 'locales'>>;
+export type RoutingConfigLocalizedNavigation<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales>, AppDomains extends DomainsConfig<AppLocales> = never> = Omit<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'defaultLocale' | 'pathnames'> & Partial<Pick<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'defaultLocale'>> & {
+    pathnames: AppPathnames;
+};
+export type ResolvedRoutingConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined> = Omit<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'localePrefix' | 'localeCookie' | 'alternateLinks' | 'localeDetection'> & {
+    localePrefix: LocalePrefixConfigVerbose<AppLocales, AppLocalePrefixMode>;
+    localeCookie: InitializedLocaleCookieConfig;
+    alternateLinks: boolean;
+    localeDetection: boolean;
+};
+export declare function receiveRoutingConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined, Config extends Partial<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>>>(input: Config): Omit<Config, "localePrefix" | "localeCookie" | "alternateLinks" | "localeDetection"> & {
+    localePrefix: {
+        mode: "never";
+    } | {
+        mode: "always";
+        prefixes?: Partial<Record<AppLocales[number], string>> | undefined;
+    } | {
+        mode: "as-needed";
+        prefixes?: Partial<Record<AppLocales[number], string>> | undefined;
+    };
+    localeCookie: InitializedLocaleCookieConfig;
+    localeDetection: boolean | NonNullable<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>["localeDetection"]>;
+    alternateLinks: boolean | NonNullable<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>["alternateLinks"]>;
+};
+export type InitializedLocaleCookieConfig = false | LocaleCookieConfig;
+export type LocaleCookieConfig = Omit<CookieAttributes, 'name' | 'maxAge' | 'sameSite'> & Required<Pick<CookieAttributes, 'name' | 'sameSite'>>;
+export {};

package/dist/types/routing/defineRouting.d.ts

@@ -0,0 +1,3 @@
+import type { RoutingConfig } from './config.js';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from './types.js';
+export default function defineRouting<const AppLocales extends Locales, const AppLocalePrefixMode extends LocalePrefixMode = 'always', const AppPathnames extends Pathnames<AppLocales> = never, const AppDomains extends DomainsConfig<AppLocales> = never>(config: RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>): RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>;

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

@@ -0,0 +1,3 @@
+export type { Pathnames, LocalePrefix, DomainsConfig, LocalePrefixMode } from './types.js';
+export { default as defineRouting } from './defineRouting.js';
+export type { RoutingConfig } from './config.js';

package/dist/types/routing/types.d.ts

@@ -0,0 +1,25 @@
+export type Locales = ReadonlyArray<string>;
+export type LocalePrefixMode = 'always' | 'as-needed' | 'never';
+type Pathname = string;
+export type LocalePrefixes<AppLocales extends Locales> = Partial<Record<AppLocales[number], Pathname>>;
+export type LocalePrefixConfigVerbose<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode> = AppLocalePrefixMode extends 'always' ? {
+    mode: 'always';
+    prefixes?: LocalePrefixes<AppLocales>;
+} : AppLocalePrefixMode extends 'as-needed' ? {
+    mode: 'as-needed';
+    prefixes?: LocalePrefixes<AppLocales>;
+} : {
+    mode: 'never';
+};
+export type LocalePrefix<AppLocales extends Locales = [], AppLocalePrefixMode extends LocalePrefixMode = 'always'> = AppLocalePrefixMode | LocalePrefixConfigVerbose<AppLocales, AppLocalePrefixMode>;
+export type Pathnames<AppLocales extends Locales> = Record<Pathname, Partial<Record<AppLocales[number], Pathname>> | Pathname>;
+export type DomainConfig<AppLocales extends Locales> = {
+    localePrefix?: LocalePrefixMode;
+    defaultLocale: AppLocales[number];
+    /** The domain name (e.g. "example.com", "www.example.com" or "fr.example.com"). Note that the `x-forwarded-host` or alternatively the `host` header will be used to determine the requested domain. */
+    domain: string;
+    /** The locales that are available on this domain. */
+    locales: Array<AppLocales[number]>;
+};
+export type DomainsConfig<AppLocales extends Locales> = Array<DomainConfig<AppLocales>>;
+export {};

package/dist/types/routing.d.ts

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

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

@@ -0,0 +1,10 @@
+import type { getExtracted as getExtracted_type, getFormatter as getFormatter_type, getLocale as getLocale_type, getMessages as getMessages_type, getNow as getNow_type, getRequestConfig as getRequestConfig_type, getTimeZone as getTimeZone_type, setRequestLocale as setRequestLocale_type } from '../react-server/index.js';
+export declare function getRequestConfig(...args: Parameters<typeof getRequestConfig_type>): ReturnType<typeof getRequestConfig_type>;
+export declare const getFormatter: typeof getFormatter_type;
+export declare const getNow: typeof getNow_type;
+export declare const getTimeZone: typeof getTimeZone_type;
+export declare const getMessages: typeof getMessages_type;
+export declare const getLocale: typeof getLocale_type;
+export declare const getExtracted: typeof getExtracted_type;
+export declare const getTranslations: () => never;
+export declare const setRequestLocale: typeof setRequestLocale_type;

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

@@ -0,0 +1 @@
+export declare function getRequestLocale(): Promise<string | undefined>;

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

@@ -0,0 +1,3 @@
+import type { Locale } from 'use-intl';
+export declare function getCachedRequestLocale(): string | undefined;
+export declare function setCachedRequestLocale(locale: Locale): void;

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

@@ -0,0 +1,3 @@
+import type { GetRequestConfigParams, RequestConfig } from './getRequestConfig.js';
+declare const _default: (params: GetRequestConfigParams) => RequestConfig | Promise<RequestConfig>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import { type IntlConfig, type Locale, _createIntlFormatters } from 'use-intl/core';
+declare function getConfigImpl(localeOverride?: Locale): Promise<{
+    locale: IntlConfig['locale'];
+    formats?: NonNullable<IntlConfig['formats']>;
+    timeZone: NonNullable<IntlConfig['timeZone']>;
+    onError: NonNullable<IntlConfig['onError']>;
+    getMessageFallback: NonNullable<IntlConfig['getMessageFallback']>;
+    messages?: NonNullable<IntlConfig['messages']>;
+    now?: NonNullable<IntlConfig['now']>;
+    _formatters: ReturnType<typeof _createIntlFormatters>;
+}>;
+declare const getConfig: typeof getConfigImpl;
+export default getConfig;

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

@@ -0,0 +1,4 @@
+import type { Locale } from 'use-intl';
+declare function getConfigNowImpl(locale?: Locale): Promise<Date | undefined>;
+declare const getConfigNow: typeof getConfigNowImpl;
+export default getConfigNow;

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

@@ -0,0 +1,3 @@
+declare function defaultNow(): Date;
+declare const getDefaultNow: typeof defaultNow;
+export default getDefaultNow;

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

@@ -0,0 +1,10 @@
+import type { Locale } from 'use-intl/core';
+import getServerExtractor from './getServerExtractor.js';
+type Return = ReturnType<typeof getServerExtractor>;
+declare function getExtractedImpl(namespace?: string): Promise<Return>;
+declare function getExtractedImpl(opts?: {
+    locale: Locale;
+    namespace?: string;
+}): Promise<Return>;
+declare const getExtracted: typeof getExtractedImpl;
+export default getExtracted;

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

@@ -0,0 +1,3 @@
+declare function getFormatsCachedImpl(): Promise<import("use-intl").Formats | undefined>;
+declare const getFormats: typeof getFormatsCachedImpl;
+export default getFormats;

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

@@ -0,0 +1,10 @@
+import type { Locale, createFormatter } from 'use-intl/core';
+/**
+ * Returns a formatter based on the given locale.
+ *
+ * The formatter automatically receives the request config, but
+ * you can override it by passing in additional options.
+ */
+export default function getFormatter(opts?: {
+    locale?: Locale;
+}): Promise<ReturnType<typeof createFormatter>>;

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

@@ -0,0 +1,4 @@
+import type { Locale } from 'use-intl';
+declare function getLocaleCachedImpl(): Promise<Locale>;
+declare const getLocaleCached: typeof getLocaleCachedImpl;
+export default getLocaleCached;

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

@@ -0,0 +1,6 @@
+import type { Locale, useMessages as useMessagesType } from 'use-intl';
+import getConfig from './getConfig.js';
+export declare function getMessagesFromConfig(config: Awaited<ReturnType<typeof getConfig>>): ReturnType<typeof useMessagesType>;
+export default function getMessages(opts?: {
+    locale?: Locale;
+}): Promise<ReturnType<typeof useMessagesType>>;

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

@@ -0,0 +1,4 @@
+import type { Locale } from 'use-intl';
+export default function getNow(opts?: {
+    locale?: Locale;
+}): Promise<Date>;

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

@@ -0,0 +1,35 @@
+import type { IntlConfig, Locale } from 'use-intl/core';
+export type RequestConfig = Omit<IntlConfig, 'locale'> & {
+    /**
+     * @see https://next-intl.dev/docs/usage/configuration#i18n-request
+     **/
+    locale: IntlConfig['locale'];
+};
+export type GetRequestConfigParams = {
+    /**
+     * If you provide an explicit locale to an async server-side function like
+     * `getTranslations({locale: 'en'})`, it will be passed via `locale` to
+     * `getRequestConfig` so you can use it instead of the segment value.
+     */
+    locale?: Locale;
+    /**
+     * Typically corresponds to the `[locale]` segment that was matched by the middleware.
+     *
+     * However, there are three special cases to consider:
+     * 1. **Overrides**: When an explicit `locale` is passed to awaitable functions
+     *    like `getTranslations({locale: 'en'})`, then this value will be used
+     *    instead of the segment.
+     * 2. **`undefined`**: The value can be `undefined` when a page outside of the
+     *    `[locale]` segment renders (e.g. a language selection page at `app/page.tsx`).
+     * 3. **Invalid values**: Since the `[locale]` segment effectively acts like a
+     *    catch-all for unknown routes (e.g. `/unknown.txt`), invalid values should
+     *    be replaced with a valid locale.
+     *
+     * @see https://next-intl.dev/docs/usage/configuration#i18n-request
+     */
+    requestLocale: Promise<string | undefined>;
+};
+/**
+ * Should be called in `i18n/request.ts` to create the configuration for the current request.
+ */
+export default function getRequestConfig(createRequestConfig: (params: GetRequestConfigParams) => RequestConfig | Promise<RequestConfig>): (params: GetRequestConfigParams) => RequestConfig | Promise<RequestConfig>;

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

@@ -0,0 +1,5 @@
+import type { createTranslator } from 'use-intl/core';
+import type { _useExtracted as useExtractedType } from 'use-intl/react';
+declare function getServerExtractorImpl(config: Parameters<typeof createTranslator>[0], namespace?: string): ReturnType<typeof useExtractedType>;
+declare const _default: typeof getServerExtractorImpl;
+export default _default;

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

@@ -0,0 +1,29 @@
+import { createFormatter } from 'use-intl/core';
+declare function getFormatterCachedImpl(config: Parameters<typeof createFormatter>[0]): {
+    dateTime: {
+        (value: Date | number, options?: import("use-intl/core").DateTimeFormatOptions): string;
+        (value: Date | number, format?: string, options?: import("use-intl/core").DateTimeFormatOptions): string;
+    };
+    number: {
+        (value: number | bigint, options?: import("use-intl/core").NumberFormatOptions): string;
+        (value: number | bigint, format?: string, options?: import("use-intl/core").NumberFormatOptions): string;
+    };
+    relativeTime: {
+        (date: number | Date, now?: import("use-intl/core").RelativeTimeFormatOptions["now"]): string;
+        (date: number | Date, options?: import("use-intl/core").RelativeTimeFormatOptions): string;
+    };
+    list: {
+        <Value extends string | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>(value: Iterable<Value>, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<import("react").ReactElement>;
+        <Value extends string | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>(value: Iterable<Value>, format?: string, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<import("react").ReactElement>;
+    };
+    dateTimeRange: {
+        (start: Date | number, end: Date | number, options?: import("use-intl/core").DateTimeFormatOptions): string;
+        (start: Date | number, end: Date | number, format?: string, options?: import("use-intl/core").DateTimeFormatOptions): string;
+    };
+    displayName: {
+        (value: string, options: Intl.DisplayNamesOptions): string;
+        (value: string, format: string, options?: Intl.DisplayNamesOptions): string;
+    };
+};
+declare const getFormatterCached: typeof getFormatterCachedImpl;
+export default getFormatterCached;

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

@@ -0,0 +1,4 @@
+import { type Messages, type NamespaceKeys, type NestedKeyOf, createTranslator } from 'use-intl/core';
+declare function getServerTranslatorImpl<NestedKey extends NamespaceKeys<Messages, NestedKeyOf<Messages>> = never>(config: Parameters<typeof createTranslator>[0], namespace?: NestedKey): ReturnType<typeof createTranslator<Messages, NestedKey>>;
+declare const _default: typeof getServerTranslatorImpl;
+export default _default;

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

@@ -0,0 +1,4 @@
+import type { Locale, Timezone } from 'use-intl';
+export default function getTimeZone(opts?: {
+    locale?: Locale;
+}): Promise<Timezone>;

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

@@ -0,0 +1,8 @@
+import type { Locale, Messages, NamespaceKeys, NestedKeyOf, createTranslator } from 'use-intl/core';
+declare function getTranslations<NestedKey extends NamespaceKeys<Messages, NestedKeyOf<Messages>> = never>(namespace?: NestedKey): Promise<ReturnType<typeof createTranslator<Messages, NestedKey>>>;
+declare function getTranslations<NestedKey extends NamespaceKeys<Messages, NestedKeyOf<Messages>> = never>(opts?: {
+    locale: Locale;
+    namespace?: NestedKey;
+}): Promise<ReturnType<typeof createTranslator<Messages, NestedKey>>>;
+declare const _default: typeof getTranslations;
+export default _default;

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

@@ -0,0 +1,12 @@
+/**
+ * Server-only APIs available via `next-intl/server`.
+ */
+export { default as getRequestConfig, type GetRequestConfigParams, type RequestConfig } from './getRequestConfig.js';
+export { default as getFormatter } from './getFormatter.js';
+export { default as getNow } from './getNow.js';
+export { default as getTimeZone } from './getTimeZone.js';
+export { default as getTranslations } from './getTranslations.js';
+export { default as getExtracted } from './getExtracted.js';
+export { default as getMessages } from './getMessages.js';
+export { default as getLocale } from './getLocale.js';
+export { setCachedRequestLocale as setRequestLocale } from './RequestLocaleCache.js';

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

@@ -0,0 +1 @@
+export default function validateLocale(locale: string): void;

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

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

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

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

package/dist/types/shared/NextIntlClientProvider.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentProps } from 'react';
+import type { Locale } from 'use-intl';
+import { IntlProvider } from 'use-intl/react';
+type Props = Omit<ComponentProps<typeof IntlProvider>, 'locale'> & {
+    /** This is automatically received when being rendered from a Server Component. In all other cases, e.g. when rendered from a Client Component, a unit test or with the Pages Router, you can pass this prop explicitly. */
+    locale?: Locale;
+};
+export default function NextIntlClientProvider({ locale, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/shared/constants.d.ts

@@ -0,0 +1 @@
+export declare const HEADER_LOCALE_NAME = "X-NEXT-INTL-LOCALE";

package/dist/types/shared/types.d.ts

@@ -0,0 +1,5 @@
+export type ParametersExceptFirst<Fn> = Fn extends (arg0: any, ...rest: infer R) => any ? R : never;
+export type ParametersExceptFirstTwo<Fn> = Fn extends (arg0: any, arg1: any, ...rest: infer R) => any ? R : never;
+export type Prettify<Type> = {
+    [Key in keyof Type]: Type[Key];
+} & {};

package/dist/types/shared/use.d.ts

@@ -0,0 +1,3 @@
+import * as react from 'react';
+declare const _default: typeof react.use;
+export default _default;

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

@@ -0,0 +1,20 @@
+import type { LinkProps } from 'next/link.js';
+import type { LocalePrefixConfigVerbose, LocalePrefixMode, Locales, Pathnames } from '../routing/types.js';
+type Href = LinkProps['href'];
+export declare function isLocalizableHref(href: Href): boolean;
+export declare function unprefixPathname(pathname: string, prefix: string): string;
+export declare function prefixPathname(prefix: string, pathname: string): string;
+export declare function hasPathnamePrefixed(prefix: string | undefined, pathname: string): boolean;
+export declare function getLocalizedTemplate<AppLocales extends Locales>(pathnameConfig: Pathnames<AppLocales>[keyof Pathnames<AppLocales>], locale: AppLocales[number], internalTemplate: string): string;
+export declare function normalizeTrailingSlash(pathname: string): string;
+export declare function matchesPathname(
+/** E.g. `/users/[userId]-[userName]` */
+template: string, 
+/** E.g. `/users/23-jane` */
+pathname: string): boolean;
+export declare function getLocalePrefix<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode>(locale: AppLocales[number], localePrefix: LocalePrefixConfigVerbose<AppLocales, AppLocalePrefixMode>): string;
+export declare function getLocaleAsPrefix(locale: string): string;
+export declare function templateToRegex(template: string): RegExp;
+export declare function getSortedPathnames(pathnames: Array<string>): string[];
+export declare function isPromise<Value>(value: Value | Promise<Value>): value is Promise<Value>;
+export {};

package/extractor/catalogLoader.d.ts

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

package/extractor/extractionLoader.d.ts

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

package/extractor.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export * from './dist/types/extractor';

package/middleware.d.ts

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

package/navigation.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export * from './dist/types/navigation.react-client';

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@common.js/next-intl",
+  "version": "4.13.1",
+  "sideEffects": false,
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://github.com/sponsors/amannn"
+    }
+  ],
+  "description": "next-intl package exported as CommonJS modules",
+  "license": "MIT",
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "repository": "etienne-martin/common.js",
+  "scripts": {
+    "build": "rm -rf dist && rollup -c",
+    "test": "TZ=Europe/Berlin vitest",
+    "lint": "pnpm run lint:source && pnpm run lint:package",
+    "lint:source": "eslint src test && tsc --noEmit && pnpm run lint:prettier",
+    "lint:package": "publint && attw --pack --ignore-rules=cjs-resolves-to-esm",
+    "lint:prettier": "prettier src --check",
+    "size": "size-limit"
+  },
+  "type": "commonjs",
+  "main": "./dist/esm/production/index.react-client.js",
+  "typings": "./dist/types/index.react-client.d.ts",
+  "files": [
+    "dist",
+    "extractor",
+    "server.d.ts",
+    "navigation.d.ts",
+    "middleware.d.ts",
+    "plugin.d.ts",
+    "plugin.d.cts",
+    "routing.d.ts",
+    "config.d.ts",
+    "extractor.d.ts"
+  ],
+  "dependencies": {
+    "@common.js/formatjs__intl-localematcher": "^0.8.1",
+    "@parcel/watcher": "^2.4.1",
+    "@swc/core": "^1.15.2",
+    "@common.js/icu-minify": "^4.13.1",
+    "negotiator": "^1.0.0",
+    "next-intl-swc-plugin-extractor": "^4.13.1",
+    "@common.js/po-parser": "^2.1.1",
+    "@common.js/use-intl": "^4.13.1"
+  },
+  "peerDependencies": {
+    "next": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0",
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || >=19.0.0-rc <19.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "gitHead": "976ca1f83a6e06b5646865b87c4fb461cbf84374",
+  "types": "./dist/types/index.react-client.d.ts"
+}

package/plugin.d.cts

@@ -0,0 +1,3 @@
+import createNextIntlPlugin from './dist/types/plugin.ts';
+
+export = createNextIntlPlugin;

package/plugin.d.ts

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

package/routing.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export * from './dist/types/routing';

package/server.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export * from './dist/types/server/react-server';