@i18n-micro/core 1.0.27

package/dist/translation.d.ts

@@ -0,0 +1,24 @@
+import { Translations } from '@i18n-micro/types';
+export interface RefLike<T> {
+    value: T;
+}
+export interface TranslationCache {
+    generalLocaleCache: RefLike<Record<string, Translations>> | Record<string, Translations>;
+    routeLocaleCache: RefLike<Record<string, Translations>> | Record<string, Translations>;
+    dynamicTranslationsCaches: RefLike<Record<string, Translations>[]> | Record<string, Translations>[];
+    serverTranslationCache: RefLike<Record<string, Map<string, Translations | unknown>>> | Record<string, Map<string, Translations | unknown>>;
+}
+export declare function useTranslationHelper(caches?: TranslationCache): {
+    hasCache(locale: string, page: string): boolean;
+    getCache(locale: string, routeName: string): Map<string, unknown> | undefined;
+    setCache(locale: string, routeName: string, cache: Map<string, Translations | unknown>): void;
+    mergeTranslation(locale: string, routeName: string, newTranslations: Translations, force?: boolean): void;
+    mergeGlobalTranslation(locale: string, newTranslations: Translations, force?: boolean): void;
+    hasGeneralTranslation(locale: string): boolean;
+    hasPageTranslation(locale: string, routeName: string): boolean;
+    hasTranslation: (locale: string, key: import('@i18n-micro/types').TranslationKey) => boolean;
+    getTranslation: <T = unknown>(locale: string, routeName: string, key: import('@i18n-micro/types').TranslationKey) => T | null;
+    loadPageTranslations(locale: string, routeName: string, translations: Translations): Promise<void>;
+    loadTranslations(locale: string, translations: Translations): Promise<void>;
+    clearCache(): void;
+};

package/fix.ts

@@ -0,0 +1 @@
+import '@types/jest'

package/jest.config.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  roots: ['<rootDir>/tests'],
+  testMatch: ['**/?(*.)+(spec|test).[tj]s?(x)'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@i18n-micro/core",
+  "version": "1.0.27",
+  "description": "",
+  "repository": "s00d/nuxt-i18n-micro",
+  "license": "MIT",
+  "type": "module",
+  "author": {
+    "name": "s00d",
+    "email": "Virus191288@gmail.com",
+    "url": "https://s00d.github.io/"
+  },
+  "homepage": "https://github.com/s00d/nuxt-i18n-micro",
+  "bugs": {
+    "url": "https://github.com/s00d/nuxt-i18n-micro/issues"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "dependencies": {
+    "@i18n-micro/types": "1.0.15"
+  },
+  "devDependencies": {
+    "vite": "^5.0.0",
+    "vite-plugin-dts": "^4.3.0"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "jest"
+  }
+}

package/src/format-service.ts

@@ -0,0 +1,41 @@
+export class FormatService {
+  formatNumber(value: number, locale: string, options?: Intl.NumberFormatOptions): string {
+    return new Intl.NumberFormat(locale, options).format(value)
+  }
+
+  formatDate(value: Date | number | string, locale: string, options?: Intl.DateTimeFormatOptions): string {
+    const date = new Date(value)
+    if (Number.isNaN(date.getTime())) {
+      return 'Invalid Date'
+    }
+    return new Intl.DateTimeFormat(locale, options).format(date)
+  }
+
+  formatRelativeTime(value: Date | number | string, locale: string, options?: Intl.RelativeTimeFormatOptions): string {
+    const date = new Date(value)
+    if (Number.isNaN(date.getTime())) {
+      // Return "0 seconds ago" for invalid dates
+      return new Intl.RelativeTimeFormat(locale, options).format(0, 'second')
+    }
+    const now = new Date()
+    const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000)
+
+    const units: { unit: Intl.RelativeTimeFormatUnit, seconds: number }[] = [
+      { unit: 'year', seconds: 31536000 },
+      { unit: 'month', seconds: 2592000 },
+      { unit: 'day', seconds: 86400 },
+      { unit: 'hour', seconds: 3600 },
+      { unit: 'minute', seconds: 60 },
+      { unit: 'second', seconds: 1 },
+    ]
+
+    for (const { unit, seconds } of units) {
+      const diff = Math.floor(diffInSeconds / seconds)
+      if (diff >= 1) {
+        return new Intl.RelativeTimeFormat(locale, options).format(-diff, unit)
+      }
+    }
+
+    return new Intl.RelativeTimeFormat(locale, options).format(0, 'second')
+  }
+}

package/src/helpers.ts

@@ -0,0 +1,53 @@
+import type { Params, Strategies, PluralFunc, Getter, TranslationKey } from '@i18n-micro/types'
+
+export function interpolate(template: string, params: Params): string {
+  let result = template
+
+  for (const key in params) {
+    result = result.split(`{${key}}`).join(String(params[key]))
+  }
+
+  return result
+}
+
+export function withPrefixStrategy(strategy: Strategies) {
+  return strategy === 'prefix' || strategy === 'prefix_and_default'
+}
+
+export function isNoPrefixStrategy(strategy: Strategies) {
+  return strategy === 'no_prefix'
+}
+
+export function isPrefixStrategy(strategy: Strategies) {
+  return strategy === 'prefix'
+}
+
+export function isPrefixExceptDefaultStrategy(strategy: Strategies) {
+  return strategy === 'prefix_except_default'
+}
+
+export function isPrefixAndDefaultStrategy(strategy: Strategies) {
+  return strategy === 'prefix_and_default'
+}
+
+/**
+ * Default pluralization function
+ * Splits translation by '|' and selects form based on count
+ * @param key - Translation key
+ * @param count - Count for pluralization
+ * @param params - Parameters for translation
+ * @param _locale - Current locale (unused in default implementation)
+ * @param getTranslation - Function to get translation value
+ * @returns Selected plural form or null if not found
+ */
+export const defaultPlural: PluralFunc = (key: TranslationKey, count: number, params: Params, _locale: string, getTranslation: Getter) => {
+  const translation = getTranslation(key, params)
+  if (!translation) {
+    return null
+  }
+  const forms = translation.toString().split('|')
+  if (forms.length === 0) return null
+  const selectedForm = count < forms.length ? forms[count] : forms[forms.length - 1]
+  if (!selectedForm) return null
+  return selectedForm.trim().replace('{count}', count.toString())
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import { useTranslationHelper, type TranslationCache } from './translation'
+import { RouteService } from './route-service'
+import { FormatService } from './format-service'
+import { interpolate, withPrefixStrategy, isNoPrefixStrategy, isPrefixStrategy, isPrefixExceptDefaultStrategy, isPrefixAndDefaultStrategy, defaultPlural } from './helpers'
+
+export {
+  useTranslationHelper,
+  interpolate,
+  withPrefixStrategy,
+  isNoPrefixStrategy,
+  isPrefixStrategy,
+  isPrefixExceptDefaultStrategy,
+  isPrefixAndDefaultStrategy,
+  defaultPlural,
+  RouteService,
+  FormatService,
+  type TranslationCache,
+}

package/src/route-service.ts

@@ -0,0 +1,473 @@
+import type {
+  NavigationFailure,
+  RouteLocationAsPath, RouteLocationAsPathGeneric,
+  RouteLocationAsRelative,
+  RouteLocationAsString,
+  RouteLocationNamedRaw,
+  RouteLocationNormalizedLoaded,
+  RouteLocationOptions,
+  RouteLocationRaw,
+  RouteLocationResolved,
+  RouteLocationResolvedGeneric,
+  RouteParamsRawGeneric,
+  Router,
+} from 'vue-router'
+import type { I18nRouteParams, Locale, ModuleOptionsExtend } from '@i18n-micro/types'
+import { isNoPrefixStrategy, withPrefixStrategy } from './helpers'
+
+interface NavigateToInterface {
+  replace?: boolean
+  redirectCode?: number
+  external?: boolean
+}
+
+export class RouteService {
+  constructor(
+    private i18nConfig: ModuleOptionsExtend,
+    private router: Router,
+    private hashLocaleDefault: string | null | undefined,
+    private noPrefixDefault: string | null | undefined,
+    private navigateTo: (to: RouteLocationRaw | undefined | null, options?: NavigateToInterface) => Promise<void | NavigationFailure | false> | false | void | RouteLocationRaw,
+    private setCookie: (name: string, value: string) => void,
+    private cookieLocaleDefault: string | null | undefined = null,
+    private cookieLocaleName: string | null | undefined = null,
+  ) {}
+
+  /**
+   * Extracts locale from URL path by checking the first path segment
+   * @param path - URL path (e.g., '/ru/sdfsdf' or '/en/about')
+   * @returns Locale code or null if not found
+   */
+  private extractLocaleFromPath(path: string): string | null {
+    if (!path) {
+      return null
+    }
+
+    // Remove query params and hash to ensure clean path comparison
+    // This is important when falling back to fullPath which might contain these
+    const querySplit = path.split('?')
+    const cleanPath = querySplit[0]?.split('#')[0]
+
+    if (!cleanPath || cleanPath === '/') {
+      return null
+    }
+
+    const pathSegments = cleanPath.split('/').filter(Boolean)
+    if (pathSegments.length === 0) {
+      return null
+    }
+
+    const firstSegment = pathSegments[0]
+    if (!firstSegment) {
+      return null
+    }
+
+    const availableLocales = this.i18nConfig.locales?.map(l => l.code) || []
+
+    // Check if the first segment is a valid locale
+    if (availableLocales.includes(firstSegment)) {
+      return firstSegment
+    }
+
+    return null
+  }
+
+  getCurrentLocale(route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric): string {
+    route = route ?? this.router.currentRoute.value
+
+    // 1. Check hashMode
+    if (this.i18nConfig.hashMode && this.hashLocaleDefault) {
+      return this.hashLocaleDefault
+    }
+
+    // 2. Check noPrefix strategy
+    if (isNoPrefixStrategy(this.i18nConfig.strategy!) && this.noPrefixDefault) {
+      return this.noPrefixDefault
+    }
+
+    // 3. Check route.params.locale (for existing routes)
+    if (route.params?.locale) {
+      return route.params.locale.toString()
+    }
+
+    // 4. Extract locale from URL path (for non-existent routes)
+    const path = route.path || route.fullPath || ''
+    const localeFromPath = this.extractLocaleFromPath(path)
+    if (localeFromPath) {
+      return localeFromPath
+    }
+
+    // 5. Check cookie (if provided)
+    if (this.cookieLocaleDefault) {
+      return this.cookieLocaleDefault
+    }
+
+    // 6. Return defaultLocale as fallback
+    return (this.i18nConfig.defaultLocale || 'en').toString()
+  }
+
+  getCurrentName(route: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric): string | null {
+    const currentLocaleCode = this.getCurrentLocale(route)
+    const checkLocale = this.i18nConfig.locales?.find(l => l.code === currentLocaleCode)
+    return checkLocale?.displayName ?? null
+  }
+
+  getRouteName(route: RouteLocationResolvedGeneric | RouteLocationNamedRaw, locale: string): string {
+    const name = (route.name ?? '').toString()
+    return name
+      .toString()
+      .replace('localized-', '')
+      .replace(new RegExp(`-${locale}$`), '')
+  }
+
+  getPluginRouteName(route: RouteLocationResolvedGeneric | RouteLocationNamedRaw, locale: string): string {
+    if (this.i18nConfig.disablePageLocales) {
+      return 'general'
+    }
+    return this.getRouteName(route, locale)
+  }
+
+  getFullPathWithBaseUrl(currentLocale: Locale, route: RouteLocationRaw): string {
+    const resolvedRoute = this.router.resolve(route)
+    let fullPath = resolvedRoute.fullPath
+
+    if (currentLocale?.baseDefault) {
+      fullPath = fullPath.replace(new RegExp(`^/${currentLocale!.code}`), '')
+    }
+
+    let baseUrl = currentLocale!.baseUrl
+    if (!baseUrl) baseUrl = ''
+    if (baseUrl?.endsWith('/')) {
+      baseUrl = baseUrl.slice(0, -1)
+    }
+
+    return baseUrl + fullPath
+  }
+
+  switchLocaleRoute(
+    fromLocale: string,
+    toLocale: string,
+    route: RouteLocationResolvedGeneric | RouteLocationNamedRaw,
+    i18nRouteParams: I18nRouteParams,
+  ): RouteLocationRaw {
+    const currentLocale = this.i18nConfig.locales?.find(l => l.code === toLocale)
+
+    const routeName = this.getRouteName(route, fromLocale)
+    if (this.router.hasRoute(`localized-${routeName}-${toLocale}`)) {
+      // If i18nRouteParams exist for target locale, use them as base, otherwise use route.params
+      const baseParams = i18nRouteParams?.[toLocale]
+        ? { ...i18nRouteParams[toLocale] }
+        : { ...route.params ?? {} }
+      // Merge remaining route.params that are not in i18nRouteParams
+      const newParams = { ...baseParams }
+      // Remove locale from params if it exists, we'll add it explicitly
+      delete newParams.locale
+      if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) newParams.locale = toLocale
+
+      const newRoute = {
+        name: `localized-${routeName}-${toLocale}`,
+        params: newParams,
+        query: route.query,
+        hash: route.hash,
+      }
+
+      if (currentLocale?.baseUrl) {
+        return this.getFullPathWithBaseUrl(currentLocale, newRoute)
+      }
+
+      return newRoute
+    }
+
+    let newRouteName = routeName
+    // If i18nRouteParams exist for target locale, use them as base, otherwise use route.params
+    const baseParams = i18nRouteParams?.[toLocale]
+      ? { ...i18nRouteParams[toLocale] }
+      : { ...route.params ?? {} }
+    // Merge remaining route.params that are not in i18nRouteParams
+    const newParams = { ...baseParams }
+    delete newParams.locale
+
+    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      if (routeName === 'custom-fallback-route') {
+        newRouteName = routeName
+      }
+      else {
+        newRouteName
+          = toLocale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)
+            ? `localized-${routeName}`
+            : routeName
+      }
+
+      if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+        if (toLocale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
+          newParams.locale = toLocale
+        }
+      }
+    }
+
+    const newRoute = {
+      name: newRouteName,
+      params: newParams,
+      query: route.query,
+      hash: route.hash,
+    }
+
+    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      this.i18nConfig.locales?.forEach((locale, _index) => {
+        if (newRoute.name.endsWith(`-${locale.code}`)) {
+          newRoute.name = newRoute.name.slice(0, -locale.code - 1)
+        }
+      })
+    }
+
+    if (currentLocale?.baseUrl) {
+      return this.getFullPathWithBaseUrl(currentLocale, newRoute)
+    }
+
+    return newRoute
+  }
+
+  private resolveParams(to: RouteLocationAsString | RouteLocationAsRelative | RouteLocationAsPath): RouteParamsRawGeneric {
+    const params
+      = typeof to === 'object' && 'params' in to && typeof to.params === 'object'
+        ? { ...to.params }
+        : {}
+
+    if (typeof to === 'string') {
+      const resolved = this.router.resolve(to)
+      if (resolved && resolved.params) {
+        Object.assign(params, resolved.params)
+      }
+    }
+
+    return params
+  }
+
+  private handlePrefixStrategy(
+    to: RouteLocationResolvedGeneric | RouteLocationAsPathGeneric | RouteLocationNamedRaw | string,
+  ): RouteLocationResolvedGeneric | RouteLocationAsPathGeneric | RouteLocationNamedRaw | string {
+    if (!withPrefixStrategy(this.i18nConfig.strategy!)) {
+      return to
+    }
+
+    const defaultLocale = this.i18nConfig.defaultLocale!
+    let resolvedTo = to
+
+    if (typeof to === 'string') {
+      resolvedTo = this.router.resolve('/' + defaultLocale + to)
+    }
+
+    const defaultRouteName = this.getRouteName(resolvedTo as RouteLocationResolvedGeneric, defaultLocale)
+    const newParams = this.resolveParams(resolvedTo)
+
+    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      newParams.locale = defaultLocale
+    }
+
+    if (this.router.hasRoute(`localized-${defaultRouteName}`)) {
+      return this.router.resolve({
+        name: `localized-${defaultRouteName}`,
+        query: (resolvedTo as RouteLocationNormalizedLoaded).query,
+        hash: (resolvedTo as RouteLocationNormalizedLoaded).hash,
+        params: newParams,
+      })
+    }
+    else if (this.router.hasRoute(`localized-${defaultRouteName}-${defaultLocale}`)) {
+      return this.router.resolve({
+        name: `localized-${defaultRouteName}-${defaultLocale}`,
+        query: (resolvedTo as RouteLocationNormalizedLoaded).query,
+        hash: (resolvedTo as RouteLocationNormalizedLoaded).hash,
+        params: newParams,
+      })
+    }
+
+    return to
+  }
+
+  private createLocalizedRoute(
+    to: RouteLocationAsString | RouteLocationAsRelative | RouteLocationAsPath,
+    route: RouteLocationNormalizedLoaded,
+    locale: string,
+  ): RouteLocationResolved {
+    const selectRoute = this.router.resolve(to)
+    const routeName = this.getRouteName(selectRoute, locale)
+      .replace(new RegExp(`-${this.i18nConfig.defaultLocale!}$`), '')
+
+    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      if (!routeName || routeName === '') {
+        const resolved = this.router.resolve(to)
+        let url = resolved.path.replace(new RegExp(`^/${locale}/`), '/')
+        if (locale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
+          url = '/' + locale + '' + url
+        }
+
+        return this.router.resolve({
+          path: url,
+          query: selectRoute.query,
+          hash: selectRoute.hash,
+        })
+      }
+    }
+
+    if (this.router.hasRoute(`localized-${routeName}-${locale}`)) {
+      const newParams = this.resolveParams(selectRoute)
+      if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) newParams.locale = locale
+
+      return this.router.resolve({
+        name: `localized-${routeName}-${locale}`,
+        params: newParams,
+        query: selectRoute.query,
+        hash: selectRoute.hash,
+      })
+    }
+
+    const newRouteName
+      = locale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)
+        ? `localized-${routeName}`
+        : routeName
+
+    if (!this.router.hasRoute(newRouteName)) {
+      const newParams = this.resolveParams(to)
+      delete newParams.locale
+
+      if (!this.router.hasRoute(routeName)) {
+        return this.router.resolve('/')
+      }
+
+      return this.router.resolve({
+        name: routeName,
+        params: newParams,
+        query: selectRoute.query,
+        hash: selectRoute.hash,
+      })
+    }
+
+    const newParams = this.resolveParams(to)
+    delete newParams.locale
+
+    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      if (locale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
+        newParams.locale = locale
+      }
+    }
+
+    return this.router.resolve({
+      name: newRouteName,
+      params: newParams,
+      query: selectRoute.query,
+      hash: selectRoute.hash,
+    })
+  }
+
+  getLocalizedRoute(
+    to: RouteLocationResolvedGeneric | RouteLocationAsPathGeneric | RouteLocationNamedRaw | string,
+    route: RouteLocationNormalizedLoaded,
+    locale?: string,
+  ): RouteLocationResolved {
+    const currentLocale = locale || this.getCurrentLocale(route)
+
+    // Handle prefix strategy
+    const processedTo = this.handlePrefixStrategy(to)
+
+    // Create localized route
+    return this.createLocalizedRoute(processedTo, route, currentLocale)
+  }
+
+  updateCookies(toLocale: string): void {
+    if (this.i18nConfig.hashMode) {
+      this.setCookie('hash-locale', toLocale)
+      // useCookie('hash-locale').value = toLocale
+      this.hashLocaleDefault = toLocale
+    }
+    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      this.setCookie('no-prefix-locale', toLocale)
+      // useCookie('no-prefix-locale').value = toLocale
+      this.noPrefixDefault = toLocale
+    }
+    // Update cookie for regular strategy (prefix or prefix_except_default)
+    if (!this.i18nConfig.hashMode && !isNoPrefixStrategy(this.i18nConfig.strategy!) && this.cookieLocaleName) {
+      this.setCookie(this.cookieLocaleName, toLocale)
+      this.cookieLocaleDefault = toLocale
+    }
+  }
+
+  getCurrentRoute(): RouteLocationNormalizedLoaded {
+    return this.router.currentRoute.value
+  }
+
+  private resolveRouteWithStrategy(
+    route: string,
+    currentLocale: string,
+    fromLocale: string,
+  ): RouteLocationResolved {
+    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      return this.router.resolve(route)
+    }
+    else if (currentLocale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
+      return this.router.resolve(`/${fromLocale}${route}`)
+    }
+    else {
+      return this.router.resolve(route)
+    }
+  }
+
+  switchLocaleLogic(toLocale: string, i18nRouteParams: I18nRouteParams, to?: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string) {
+    const fromLocale = this.getCurrentLocale()
+
+    let current: RouteLocationResolved | RouteLocationNamedRaw
+    if (typeof to === 'string') {
+      current = this.resolveRouteWithStrategy(to, toLocale, fromLocale)
+    }
+    else {
+      current = to ?? this.getCurrentRoute() as RouteLocationResolved
+    }
+
+    this.updateCookies(toLocale)
+    const switchedRoute = this.switchLocaleRoute(fromLocale, toLocale, current, i18nRouteParams)
+
+    if (typeof switchedRoute === 'string' && switchedRoute.startsWith('http')) {
+      return this.navigateTo(switchedRoute, { redirectCode: 200, external: true })
+    }
+
+    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      (switchedRoute as RouteLocationRaw & RouteLocationOptions).force = true
+    }
+
+    return this.router.push(switchedRoute)
+  }
+
+  resolveLocalizedRoute(
+    to: RouteLocationNamedRaw | RouteLocationAsPathGeneric | string,
+    locale?: string,
+  ): RouteLocationResolved {
+    const currentRoute = this.getCurrentRoute()
+    const fromLocale = this.getCurrentLocale()
+    const currentLocale = locale ?? fromLocale
+
+    let current: RouteLocationResolved | RouteLocationNamedRaw | RouteLocationAsPathGeneric
+    if (typeof to === 'string') {
+      // Try to resolve as route name first (if it doesn't start with / and exists as route name)
+      if (!to.startsWith('/')) {
+        const routeName = to
+        // Check if this is a route name (not a path)
+        if (this.router.hasRoute(routeName)) {
+          // Resolve by name to get the correct route object
+          current = this.router.resolve({ name: routeName })
+        }
+        else {
+          // Treat as path
+          to = `/${to}`
+          current = this.resolveRouteWithStrategy(to, currentLocale, fromLocale)
+        }
+      }
+      else {
+        current = this.resolveRouteWithStrategy(to, currentLocale, fromLocale)
+      }
+    }
+    else {
+      current = to
+    }
+
+    return this.getLocalizedRoute(current, currentRoute, currentLocale)
+  }
+}