@depup/use-intl 4.13.3-depup.0

package/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.

package/README.md

@@ -0,0 +1,33 @@
+# @depup/use-intl
+
+> Dependency-bumped version of [use-intl](https://www.npmjs.com/package/use-intl)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/use-intl
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [use-intl](https://www.npmjs.com/package/use-intl) @ 4.13.3 |
+| Processed | 2026-07-21 |
+| Smoke test | failed |
+| Deps updated | 3 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @formatjs/fast-memoize | ^3.1.0 | ^3.1.7 |
+| @schummar/icu-type-parser | 1.21.5 | ^1.26.1 |
+| intl-messageformat | ^11.1.0 | ^11.2.12 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/use-intl
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,18 @@
+{
+  "bumped": {
+    "@formatjs/fast-memoize": {
+      "from": "^3.1.0",
+      "to": "^3.1.7"
+    },
+    "@schummar/icu-type-parser": {
+      "from": "1.21.5",
+      "to": "^1.26.1"
+    },
+    "intl-messageformat": {
+      "from": "^11.1.0",
+      "to": "^11.2.12"
+    }
+  },
+  "timestamp": "2026-07-21T16:26:01.866Z",
+  "totalUpdated": 3
+}

package/core.d.ts

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

package/dist/esm/development/core.js

@@ -0,0 +1,76 @@
+import { c as createIntlFormatters, b as createCache } from './formatters-r4aAmsMP.js';
+export { I as IntlError, a as IntlErrorCode } from './formatters-r4aAmsMP.js';
+import { r as resolveNamespace, a as createBaseTranslator, d as defaultGetMessageFallback, b as defaultOnError } from './initializeConfig-CUsOI8u2.js';
+export { c as createFormatter, i as initializeConfig } from './initializeConfig-CUsOI8u2.js';
+
+
+
+
+function createTranslatorImpl({
+  messages,
+  namespace,
+  ...rest
+}, namespacePrefix) {
+  // The `namespacePrefix` is part of the type system.
+  // See the comment in the function invocation.
+  messages = messages[namespacePrefix];
+  namespace = resolveNamespace(namespace, namespacePrefix);
+  return createBaseTranslator({
+    ...rest,
+    messages,
+    namespace
+  });
+}
+
+// This type is slightly more loose than `AbstractIntlMessages`
+// in order to avoid a type error.
+
+/**
+ * @private Not intended for direct use.
+ */
+
+/**
+ * Translates messages from the given namespace by using the ICU syntax.
+ * See https://formatjs.io/docs/core-concepts/icu-syntax.
+ *
+ * If no namespace is provided, all available messages are returned.
+ * The namespace can also indicate nesting by using a dot
+ * (e.g. `namespace.Component`).
+ */
+function createTranslator({
+  _cache = createCache(),
+  _formatters = createIntlFormatters(_cache),
+  getMessageFallback = defaultGetMessageFallback,
+  messages,
+  namespace,
+  onError = defaultOnError,
+  ...rest
+}) {
+  // We have to wrap the actual function so the type inference for the optional
+  // namespace works correctly. See https://stackoverflow.com/a/71529575/343045
+  // The prefix ("!") is arbitrary.
+  // @ts-expect-error Use the explicit annotation instead
+  return createTranslatorImpl({
+    ...rest,
+    onError,
+    cache: _cache,
+    formatters: _formatters,
+    getMessageFallback,
+    // @ts-expect-error `messages` is allowed to be `undefined` here and will be handled internally
+    messages: {
+      '!': messages
+    },
+    namespace: namespace ? `!.${namespace}` : '!'
+  }, '!');
+}
+
+/**
+ * Checks if a locale exists in a list of locales.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale
+ */
+function hasLocale(locales, candidate) {
+  return locales.includes(candidate);
+}
+
+export { createCache as _createCache, createIntlFormatters as _createIntlFormatters, createTranslator, hasLocale };

package/dist/esm/development/format-message/format-only.js

@@ -0,0 +1,145 @@
+const a$1 = 0,
+  s = 1,
+  c$1 = 2,
+  e = 3,
+  o = 4,
+  t = 5,
+  b = 6;
+
+function f(t, r, n = {}, e) {
+  if ("string" == typeof t) return t;
+  return g(i(t, r, n, e, void 0));
+}
+function i(t, r, n, e, o) {
+  const u = [];
+  for (const s of t) {
+    const t = a(s, r, n, e, o);
+    Array.isArray(t) ? u.push(...t) : u.push(t);
+  }
+  return u;
+}
+function a(f, a, y, d, h) {
+  if ("string" == typeof f) return f;
+  if (f === a$1) {
+    const t = h;
+    return d.formatters.getNumberFormat(t.locale).format(t.value);
+  }
+  const [b$1, v, ...A] = f;
+  if (void 0 === v) {
+    const t = c(y, b$1);
+    return String(t);
+  }
+  if ("number" != typeof v || v === a$1) return function (t, r, n, e, o, u) {
+    const s = c(e, t),
+      f = s,
+      a = i(r, n, e, o, u),
+      m = g(a),
+      l = Array.isArray(m) ? m : [m];
+    return f(l);
+  }(b$1, [v, ...A], a, y, d, h);
+  switch (v) {
+    case s:
+      return function (t, r, n, e, o, u) {
+        const s = String(c(e, t)),
+          f = r[s] ?? r.other;
+        return l(f, n, e, o, u);
+      }(b$1, A[0], a, y, d, h);
+    case c$1:
+      return m(b$1, A[0], a, y, d, "cardinal");
+    case e:
+      return m(b$1, A[0], a, y, d, "ordinal");
+    case o:
+      return function (t, r, n, e, o) {
+        const u = c(e, t),
+          s = u,
+          f = function (t, r) {
+            if (!t) return;
+            if ("string" == typeof t) return r.formats?.number?.[t] ? r.formats.number[t] : void 0;
+            return t;
+          }(r, o);
+        return o.formatters.getNumberFormat(n, f).format(s);
+      }(b$1, A[0], a, y, d);
+    case t:
+      return p(b$1, A[0], a, y, d);
+    case b:
+      return p(b$1, A[0], a, y, d);
+    default:
+      return "";
+  }
+}
+function c(t, r) {
+  return t[r];
+}
+function m(t, r, n, e, o, u) {
+  const s = c(e, t),
+    f = `=${s}`;
+  if (f in r) return l(r[f], n, e, o, {
+    value: s,
+    locale: n
+  });
+  return l(r[o.formatters.getPluralRules(n, {
+    type: u
+  }).select(s)] ?? r.other, n, e, o, {
+    value: s,
+    locale: n
+  });
+}
+function l(r, n, e, o, u) {
+  return "string" == typeof r ? r : r === a$1 ? a(r, n, e, o, u) : i(r, n, e, o, u);
+}
+function p(t, r, n, e, o, u) {
+  const s = c(e, t),
+    f = function (t, r, n) {
+      if (!t) return;
+      if ("string" == typeof t) {
+        const r = n.formats?.dateTime?.[t];
+        return r;
+      }
+      return t;
+    }(r, 0, o),
+    i = {
+      ...f,
+      timeZone: f?.timeZone ?? o.timeZone
+    };
+  return o.formatters.getDateTimeFormat(n, i).format(s);
+}
+function g(t) {
+  if (0 === t.length) return "";
+  const r = [];
+  let n = "";
+  for (const e of t) "string" == typeof e ? n += e : (n && (r.push(n), n = ""), r.push(e));
+  return n && r.push(n), 1 === r.length ? r[0] : r;
+}
+
+/**
+ * Formats a precompiled ICU message using icu-minify/format.
+ * This implementation requires messages to be precompiled at build time.
+ */
+function formatMessage(/** The precompiled ICU message (CompiledMessage from icu-minify) */
+...[, message, values, options]) {
+  const {
+    formats,
+    globalFormats,
+    locale,
+    ...rest
+  } = options;
+  const result = f(message, locale, values, {
+    formats: {
+      dateTime: {
+        ...globalFormats?.dateTime,
+        ...formats?.dateTime
+      },
+      number: {
+        ...globalFormats?.number,
+        ...formats?.number
+      }
+    },
+    ...rest
+  });
+  return result;
+}
+
+// `t.raw` is not supported
+formatMessage.raw = false;
+
+export { formatMessage as default };

package/dist/esm/development/format-message/index.js

@@ -0,0 +1,138 @@
+import { IntlMessageFormat } from 'intl-messageformat';
+import { isValidElement } from 'react';
+import { I as IntlError, a as IntlErrorCode, m as memoFn } from '../formatters-r4aAmsMP.js';
+
+
+/**
+ * `intl-messageformat` uses separate keys for `date` and `time`, but there's
+ * only one native API: `Intl.DateTimeFormat`. Additionally you might want to
+ * include both a time and a date in a value, therefore the separation doesn't
+ * seem so useful. We offer a single `dateTime` namespace instead, but we have
+ * to convert the format before `intl-messageformat` can be used.
+ */
+function convertFormatsToIntlMessageFormat(globalFormats, inlineFormats, timeZone) {
+  const mfDateDefaults = IntlMessageFormat.formats.date;
+  const mfTimeDefaults = IntlMessageFormat.formats.time;
+  const dateTimeFormats = {
+    ...globalFormats?.dateTime,
+    ...inlineFormats?.dateTime
+  };
+  const allFormats = {
+    date: {
+      ...mfDateDefaults,
+      ...dateTimeFormats
+    },
+    time: {
+      ...mfTimeDefaults,
+      ...dateTimeFormats
+    },
+    number: {
+      ...globalFormats?.number,
+      ...inlineFormats?.number
+    }
+    // (list is not supported in ICU messages)
+  };
+  if (timeZone) {
+    // The only way to set a time zone with `intl-messageformat` is to merge it into the formats
+    // https://github.com/formatjs/formatjs/blob/8256c5271505cf2606e48e3c97ecdd16ede4f1b5/packages/intl/src/message.ts#L15
+    ['date', 'time'].forEach(property => {
+      const formats = allFormats[property];
+      for (const [key, value] of Object.entries(formats)) {
+        formats[key] = {
+          timeZone,
+          ...value
+        };
+      }
+    });
+  }
+  return allFormats;
+}
+
+// Placed here for improved tree shaking. Somehow when this is placed in
+// `formatters.tsx`, then it can't be shaken off from `next-intl`.
+function createMessageFormatter(cache, intlFormatters) {
+  const getMessageFormat = memoFn((...args) => new IntlMessageFormat(args[0], args[1], args[2], {
+    formatters: intlFormatters,
+    ...args[3]
+  }), cache.message);
+  return getMessageFormat;
+}
+function getPlainMessage(candidate, values) {
+  // To improve runtime performance, only compile message if:
+  return (
+    // 1. Values are provided
+    values ||
+    // 2. There are ICU escape sequences (e.g. "'{name'}")
+    /'[{}<#|']/.test(candidate) ||
+    // 3. There are missing arguments or tags (dev-only error handling)
+    /<|{/.test(candidate) ? undefined // Compile
+    : candidate // Don't compile
+  );
+}
+
+/**
+ * Compiles and formats an ICU message at runtime using intl-messageformat.
+ * This is the default implementation used when messages are not precompiled.
+ */
+function formatMessage(/** The raw ICU message string (or precompiled message, though this implementation ignores precompilation) */
+...[key, message, values, options]) {
+  if (Array.isArray(message)) {
+    throw new IntlError(IntlErrorCode.INVALID_MESSAGE, `Message at \`${key}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages` );
+  }
+  if (typeof message === 'object') {
+    throw new IntlError(IntlErrorCode.INSUFFICIENT_PATH, `Message at \`${key}\` resolved to \`${typeof message}\`, but only strings are supported. Use a \`.\` to retrieve nested messages. See https://next-intl.dev/docs/usage/translations#structuring-messages` );
+  }
+
+  // Hot path that avoids creating an `IntlMessageFormat` instance
+  if (typeof message === 'string') {
+    const plainMessage = getPlainMessage(message, values);
+    if (plainMessage) return plainMessage;
+  }
+  const {
+    cache,
+    formats,
+    formatters,
+    globalFormats,
+    locale,
+    timeZone
+  } = options;
+
+  // Lazy init the message formatter for better tree
+  // shaking in case message formatting is not used.
+  if (!formatters.getMessageFormat) {
+    formatters.getMessageFormat = createMessageFormatter(cache, formatters);
+  }
+  let messageFormat;
+  try {
+    messageFormat = formatters.getMessageFormat(message, locale, convertFormatsToIntlMessageFormat(globalFormats, formats, timeZone), {
+      formatters: {
+        ...formatters,
+        getDateTimeFormat(locales, dateTimeOptions) {
+          // Workaround for https://github.com/formatjs/formatjs/issues/4279
+          return formatters.getDateTimeFormat(locales, {
+            ...dateTimeOptions,
+            timeZone: dateTimeOptions?.timeZone ?? timeZone
+          });
+        }
+      }
+    });
+  } catch (error) {
+    throw new IntlError(IntlErrorCode.INVALID_MESSAGE, `${error.message} (${error.originalMessage})` );
+  }
+  const formattedMessage = messageFormat.format(
+  // @ts-expect-error `intl-messageformat` expects a different format
+  // for rich text elements since a recent minor update. This
+  // needs to be evaluated in detail, possibly also in regard
+  // to be able to format to parts.
+  values);
+
+  // Limit the function signature to return strings or React elements
+  return /*#__PURE__*/isValidElement(formattedMessage) ||
+  // Arrays of React elements
+  Array.isArray(formattedMessage) || typeof formattedMessage === 'string' ? formattedMessage : String(formattedMessage);
+}
+
+// `t.raw` is supported
+formatMessage.raw = true;
+
+export { formatMessage as default };

package/dist/esm/development/formatters-r4aAmsMP.js

@@ -0,0 +1,79 @@
+import { memoize, strategies } from '@formatjs/fast-memoize';
+
+class IntlError extends Error {
+  constructor(code, originalMessage) {
+    let message = code;
+    if (originalMessage) {
+      message += ': ' + originalMessage;
+    }
+    super(message);
+    this.code = code;
+    if (originalMessage) {
+      this.originalMessage = originalMessage;
+    }
+  }
+}
+
+var IntlErrorCode = /*#__PURE__*/function (IntlErrorCode) {
+  IntlErrorCode["MISSING_MESSAGE"] = "MISSING_MESSAGE";
+  IntlErrorCode["MISSING_FORMAT"] = "MISSING_FORMAT";
+  IntlErrorCode["ENVIRONMENT_FALLBACK"] = "ENVIRONMENT_FALLBACK";
+  IntlErrorCode["INSUFFICIENT_PATH"] = "INSUFFICIENT_PATH";
+  IntlErrorCode["INVALID_MESSAGE"] = "INVALID_MESSAGE";
+  IntlErrorCode["INVALID_KEY"] = "INVALID_KEY";
+  IntlErrorCode["FORMATTING_ERROR"] = "FORMATTING_ERROR";
+  return IntlErrorCode;
+}(IntlErrorCode || {});
+
+function createCache() {
+  return {
+    dateTime: {},
+    number: {},
+    message: {},
+    relativeTime: {},
+    pluralRules: {},
+    list: {},
+    displayNames: {}
+  };
+}
+function createMemoCache(store) {
+  return {
+    create() {
+      return {
+        get(key) {
+          return store[key];
+        },
+        set(key, value) {
+          store[key] = value;
+        }
+      };
+    }
+  };
+}
+function memoFn(fn, cache) {
+  return memoize(fn, {
+    cache: createMemoCache(cache),
+    strategy: strategies.variadic
+  });
+}
+function memoConstructor(ConstructorFn, cache) {
+  return memoFn((...args) => new ConstructorFn(...args), cache);
+}
+function createIntlFormatters(cache) {
+  const getDateTimeFormat = memoConstructor(Intl.DateTimeFormat, cache.dateTime);
+  const getNumberFormat = memoConstructor(Intl.NumberFormat, cache.number);
+  const getPluralRules = memoConstructor(Intl.PluralRules, cache.pluralRules);
+  const getRelativeTimeFormat = memoConstructor(Intl.RelativeTimeFormat, cache.relativeTime);
+  const getListFormat = memoConstructor(Intl.ListFormat, cache.list);
+  const getDisplayNames = memoConstructor(Intl.DisplayNames, cache.displayNames);
+  return {
+    getDateTimeFormat,
+    getNumberFormat,
+    getPluralRules,
+    getRelativeTimeFormat,
+    getListFormat,
+    getDisplayNames
+  };
+}
+
+export { IntlError as I, IntlErrorCode as a, createCache as b, createIntlFormatters as c, memoFn as m };

package/dist/esm/development/index.js

@@ -0,0 +1,8 @@
+export { I as IntlError, a as IntlErrorCode, b as _createCache, c as _createIntlFormatters } from './formatters-r4aAmsMP.js';
+export { createTranslator, hasLocale } from './core.js';
+export { c as createFormatter, i as initializeConfig } from './initializeConfig-CUsOI8u2.js';
+export { IntlProvider, _useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations } from './react.js';
+
+
+
+