nuxt-i18n-micro 1.0.1

package/dist/module.mjs

@@ -0,0 +1,170 @@
+import path from 'node:path';
+import * as fs from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { useNuxt, defineNuxtModule, createResolver, addPlugin, extendPages } from '@nuxt/kit';
+import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
+
+const DEVTOOLS_UI_PORT = 3030;
+const DEVTOOLS_UI_ROUTE = "/__nuxt-i18n-micro";
+function setupDevToolsUI(options, resolve) {
+  const nuxt = useNuxt();
+  const clientPath = resolve("./client");
+  const isProductionBuild = fs.existsSync(clientPath);
+  if (isProductionBuild) {
+    nuxt.hook("vite:serverCreated", async (server) => {
+      const sirv = await import('sirv').then((r) => r.default || r);
+      server.middlewares.use(DEVTOOLS_UI_ROUTE, sirv(clientPath, { dev: true, single: true }));
+    });
+  } else {
+    nuxt.hook("vite:extendConfig", (config) => {
+      config.server = config.server || {};
+      config.server.proxy = config.server.proxy || {};
+      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
+        target: `http://localhost:${DEVTOOLS_UI_PORT}${DEVTOOLS_UI_ROUTE}`,
+        changeOrigin: true,
+        followRedirects: true,
+        rewrite: (path2) => path2.replace(DEVTOOLS_UI_ROUTE, "")
+      };
+    });
+  }
+  onDevToolsInitialized(async () => {
+    extendServerRpc("nuxt-i18n-micro", {
+      async getLocalesAndTranslations() {
+        const localesDir = path.join(nuxt.options.rootDir, options.translationDir || "locales");
+        const pagesDir = path.join(nuxt.options.rootDir, options.translationDir || "locales", "pages");
+        const localeFiles = fs.readdirSync(localesDir);
+        const pageFiles = fs.readdirSync(pagesDir);
+        console.log(1111, pageFiles);
+        const locales = options.locales?.map((locale) => locale.code) || [];
+        return locales.map((locale) => {
+          const files = localeFiles.filter((file) => file.startsWith(locale));
+          const content = files.reduce((acc, file) => {
+            const filePath = path.join(localesDir, file);
+            acc[file] = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            return acc;
+          }, {});
+          const pageLocaleFiles = pageFiles.filter((file) => file.endsWith(`_${locale}.json`));
+          pageLocaleFiles.forEach((file) => {
+            const filePath = path.join(pagesDir, file);
+            content[file] = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            files.push(file);
+          });
+          return { locale, files, content };
+        });
+      }
+    });
+    nuxt.hook("devtools:customTabs", (tabs) => {
+      tabs.push({
+        name: "nuxt-i18n-micro",
+        title: "i18n Micro",
+        icon: "carbon:language",
+        view: {
+          type: "iframe",
+          src: DEVTOOLS_UI_ROUTE
+        }
+      });
+    });
+  });
+}
+
+const module = defineNuxtModule({
+  meta: {
+    name: "nuxt-i18n-micro",
+    configKey: "i18n"
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    locales: [],
+    mata: true,
+    defaultLocale: "en",
+    translationDir: "locales",
+    autoDetectLanguage: true,
+    plural: `function (translation, count, _locale) {
+      const forms = translation.toString().split('|')
+      if (count === 0 && forms.length > 2) {
+        return forms[0].trim() // Case for "no apples"
+      }
+      if (count === 1 && forms.length > 1) {
+        return forms[1].trim() // Case for "one apple"
+      }
+      return (forms.length > 2 ? forms[2].trim() : forms[forms.length - 1].trim()).replace('{count}', count.toString())
+    }`
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public.i18nConfig = {
+      rootDir: nuxt.options.rootDir,
+      plural: options.plural,
+      locales: options.locales ?? [],
+      mata: options.mata ?? true,
+      defaultLocale: options.defaultLocale ?? "en",
+      translationDir: options.translationDir ?? "locales",
+      autoDetectLanguage: options.autoDetectLanguage ?? true
+    };
+    addPlugin({
+      src: resolver.resolve("./runtime/01.plugin"),
+      order: 1
+    });
+    addPlugin({
+      src: resolver.resolve("./runtime/02.meta"),
+      order: 2
+    });
+    addPlugin({
+      src: resolver.resolve("./runtime/03.define"),
+      order: 2
+    });
+    if (options.autoDetectLanguage) {
+      addPlugin({
+        src: resolver.resolve("./runtime/04.auto-detect"),
+        mode: "client",
+        order: 3
+      });
+    }
+    const localeRegex = options.locales.filter((locale) => locale.code !== options.defaultLocale).map((locale) => locale.code).join("|");
+    const pagesDir = path.resolve(nuxt.options.rootDir, options.translationDir, "pages");
+    extendPages((pages) => {
+      nuxt.options.generate.routes = Array.isArray(nuxt.options.generate.routes) ? nuxt.options.generate.routes : [];
+      const newRoutes = pages.map((page) => {
+        options.locales.forEach((locale) => {
+          pages.forEach((page2) => {
+            const filePath = path.join(pagesDir, `${page2.name}/${locale.code}.json`);
+            const fileDir = path.dirname(filePath);
+            if (!existsSync(fileDir)) {
+              mkdirSync(fileDir, { recursive: true });
+            }
+            if (!existsSync(filePath)) {
+              writeFileSync(filePath, JSON.stringify({}), "utf-8");
+            }
+          });
+        });
+        return {
+          ...page,
+          path: `/:locale(${localeRegex})${page.path}`,
+          name: `localized-${page.name}`,
+          meta: {
+            ...page.meta
+          }
+        };
+      });
+      pages.push(...newRoutes);
+    });
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      const routes = nitroConfig.prerender?.routes || [];
+      nuxt.options.generate.routes = Array.isArray(nuxt.options.generate.routes) ? nuxt.options.generate.routes : [];
+      const pages = nuxt.options.generate.routes || [];
+      options.locales.forEach((locale) => {
+        if (locale.code !== options.defaultLocale) {
+          pages.forEach((page) => {
+            routes.push(`/${locale}${page}`);
+          });
+        }
+      });
+      nitroConfig.prerender = nitroConfig.prerender || {};
+      nitroConfig.prerender.routes = routes;
+    });
+    if (nuxt.options.dev)
+      setupDevToolsUI(options, resolver.resolve);
+  }
+});
+
+export { module as default };

package/dist/runtime/01.plugin.d.ts

@@ -0,0 +1,26 @@
+import type { RouteLocationRaw } from 'vue-router';
+interface Translations {
+    [key: string]: string | number | boolean | Translations | PluralTranslations | unknown[] | null;
+}
+interface PluralTranslations {
+    singular: string;
+    plural: string;
+}
+declare const _default: import("#app").Plugin<{
+    getLocale: () => string;
+    getLocales: () => import("~/src/module").Locale[];
+    t: <T extends Record<string, string | number | boolean>>(key: string, params?: T, defaultValue?: string) => string | number | boolean | Translations | PluralTranslations | unknown[] | unknown | null;
+    tc: (key: string, count: number, defaultValue?: string) => string;
+    mergeTranslations: (newTranslations: Translations) => void;
+    switchLocale: (locale: string) => void;
+    localeRoute: (to: RouteLocationRaw) => RouteLocationRaw;
+}> & import("#app").ObjectPlugin<{
+    getLocale: () => string;
+    getLocales: () => import("~/src/module").Locale[];
+    t: <T extends Record<string, string | number | boolean>>(key: string, params?: T, defaultValue?: string) => string | number | boolean | Translations | PluralTranslations | unknown[] | unknown | null;
+    tc: (key: string, count: number, defaultValue?: string) => string;
+    mergeTranslations: (newTranslations: Translations) => void;
+    switchLocale: (locale: string) => void;
+    localeRoute: (to: RouteLocationRaw) => RouteLocationRaw;
+}>;
+export default _default;

package/dist/runtime/01.plugin.js

@@ -0,0 +1,151 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { useRoute, useRouter, watch } from "#imports";
+const generalLocaleCache = {};
+const routeLocaleCache = {};
+const dynamicTranslationsCaches = [];
+function deepClone(value) {
+  if (Array.isArray(value)) {
+    return value.slice();
+  } else if (typeof value === "object" && value !== null) {
+    return { ...value };
+  }
+  return value;
+}
+function getTranslation(translations, key) {
+  const value = key.split(".").reduce((acc, part) => {
+    if (typeof acc === "object" && acc !== null && part in acc) {
+      return acc[part];
+    }
+    return void 0;
+  }, translations);
+  if (value && typeof value === "object") {
+    return deepClone(value);
+  }
+  return value ?? null;
+}
+function interpolate(template, params) {
+  return template.replace(/\{(\w+)\}/g, (_, match) => {
+    return params[match] !== void 0 ? String(params[match]) : `{${match}}`;
+  });
+}
+function getPluralTranslation(translations, key) {
+  return getTranslation(translations, key);
+}
+async function loadTranslations(locale, routeName, translationDir) {
+  try {
+    if (!generalLocaleCache[locale]) {
+      const translations = await import(`~/${translationDir}/${locale}.json`);
+      generalLocaleCache[locale] = { ...translations.default };
+    }
+    if (!routeLocaleCache[`${locale}:${routeName}`]) {
+      const translations = await import(`~/${translationDir}/pages/${routeName}/${locale}.json`);
+      routeLocaleCache[`${locale}:${routeName}`] = { ...translations.default };
+    }
+  } catch (error) {
+    console.error(`Error loading translations for ${locale} and ${routeName}:`, error);
+  }
+}
+function mergeTranslations(routeName, locale, newTranslations) {
+  routeLocaleCache[`${locale}:${routeName}`] = {
+    ...generalLocaleCache[locale],
+    ...newTranslations
+  };
+}
+function switchLocale(locale, route, router, i18nConfig) {
+  const checkLocale = i18nConfig.locales?.find((l) => l.code === locale);
+  if (!checkLocale) {
+    console.warn(`Locale ${locale} is not available`);
+    return;
+  }
+  const { defaultLocale } = i18nConfig;
+  const currentLocale = route.params.locale || defaultLocale;
+  let routeName = route.name;
+  if (currentLocale !== defaultLocale) {
+    routeName = routeName.replace(`localized-`, "");
+  }
+  const newRouteName = locale === defaultLocale ? routeName : `localized-${routeName}`;
+  const newParams = { ...route.params };
+  delete newParams.locale;
+  if (locale !== defaultLocale) {
+    newParams.locale = locale;
+  }
+  window.location.href = router.resolve({ name: newRouteName, params: newParams }).fullPath;
+}
+function getLocalizedRoute(to, router, route, i18nConfig) {
+  const { defaultLocale } = i18nConfig;
+  const currentLocale = (route.params.locale || defaultLocale).toString();
+  let resolvedRoute = router.resolve(to);
+  if (typeof to === "object" && "name" in to) {
+    resolvedRoute = router.resolve({ name: to.name, params: to.params, query: to.query, hash: to.hash });
+    delete resolvedRoute.params.locale;
+    if (resolvedRoute.name) {
+      resolvedRoute.name = currentLocale === defaultLocale ? resolvedRoute.name.replace(`localized-`, "") : `localized-${resolvedRoute.name.toString()}`;
+      if (defaultLocale !== currentLocale) {
+        resolvedRoute.params.locale = currentLocale;
+      }
+    }
+  }
+  return resolvedRoute;
+}
+export default defineNuxtPlugin(async (_nuxtApp) => {
+  const router = useRouter();
+  const route = useRoute();
+  const config = useRuntimeConfig();
+  const i18nConfig = config.public.i18nConfig;
+  const initialLocale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
+  const initialRouteName = route.name.replace(`localized-`, "");
+  const plural = new Function("return " + i18nConfig.plural)();
+  await loadTranslations(initialLocale, initialRouteName, i18nConfig.translationDir);
+  let init = false;
+  watch(route, async () => {
+    if (!init) {
+      init = true;
+      return;
+    }
+    const locale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
+    const routeName = route.name.replace(`localized-`, "");
+    await loadTranslations(locale, routeName, i18nConfig.translationDir);
+  }, { immediate: true });
+  return {
+    provide: {
+      getLocale: () => (route.params?.locale ?? i18nConfig.defaultLocale).toString(),
+      getLocales: () => i18nConfig.locales || [],
+      t: (key, params, defaultValue) => {
+        const locale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
+        const routeName = route.name.replace(`localized-`, "");
+        let value = getTranslation(routeLocaleCache[`${locale}:${routeName}`] ?? {}, key) || getTranslation(generalLocaleCache[locale] ?? {}, key) || dynamicTranslationsCaches.reduce((result, cache) => {
+          return result || getTranslation(cache[locale] ?? {}, key);
+        }, null);
+        if (!value) {
+          value = defaultValue || key;
+        }
+        if (typeof value === "string" && params) {
+          value = interpolate(value, params);
+        }
+        return value;
+      },
+      tc: (key, count, defaultValue) => {
+        const locale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
+        const routeName = route.name.replace(`localized-`, "");
+        let translation = getPluralTranslation(routeLocaleCache[`${locale}:${routeName}`] ?? {}, key) || getPluralTranslation(generalLocaleCache[locale] ?? {}, key) || dynamicTranslationsCaches.reduce((result, cache) => {
+          return result || getPluralTranslation(cache[locale] ?? {}, key);
+        }, null);
+        if (!translation) {
+          translation = defaultValue || key;
+        }
+        return plural(translation.toString(), count, locale);
+      },
+      mergeTranslations: (newTranslations) => {
+        const routeName = route.name.replace(`localized-`, "");
+        const locale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
+        mergeTranslations(routeName, locale, newTranslations);
+      },
+      switchLocale: (locale) => {
+        switchLocale(locale, route, router, i18nConfig);
+      },
+      localeRoute: (to) => {
+        return getLocalizedRoute(to, router, route, i18nConfig);
+      }
+    }
+  };
+});

package/dist/runtime/02.meta.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/02.meta.js

@@ -0,0 +1,55 @@
+import { useHead, defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { useRoute } from "#imports";
+export default defineNuxtPlugin((nuxtApp) => {
+  const route = useRoute();
+  const config = useRuntimeConfig();
+  const i18nConfig = config.public.i18nConfig;
+  if (!i18nConfig.mata) {
+    return;
+  }
+  nuxtApp.hook("app:rendered", (_context) => {
+    const locale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
+    const locales = i18nConfig.locales || [];
+    const currentIso = locales.find((l) => l.code === locale)?.iso || locale;
+    const currentDir = locales.find((l) => l.code === locale)?.dir || "ltr";
+    const baseUrl = config.public.baseURL || "http://localhost:3000";
+    const ogUrl = `${baseUrl}${route.fullPath}`;
+    useHead({
+      htmlAttrs: {
+        lang: currentIso,
+        dir: currentDir
+      },
+      meta: [
+        { id: "i18n-og", property: "og:locale", content: currentIso },
+        { id: "i18n-og-url", property: "og:url", content: ogUrl },
+        ...locales.filter((l) => l.code !== locale).map((loc) => ({
+          id: `i18n-og-alt-${loc.iso || loc.code}`,
+          property: "og:locale:alternate",
+          content: loc.iso || loc.code
+        }))
+      ],
+      link: [
+        { id: "i18n-can", rel: "canonical", href: ogUrl },
+        ...locales.flatMap((loc) => {
+          const links = [
+            {
+              id: `i18n-alternate-${loc.code}`,
+              rel: "alternate",
+              href: `${baseUrl}/${loc.code}${route.fullPath}`,
+              hreflang: loc.code
+            }
+          ];
+          if (loc.iso) {
+            links.push({
+              id: `i18n-alternate-${loc.iso}`,
+              rel: "alternate",
+              href: `${baseUrl}/${loc.code}${route.fullPath}`,
+              hreflang: loc.iso
+            });
+          }
+          return links;
+        })
+      ]
+    });
+  });
+});

package/dist/runtime/03.define.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("#app").Plugin<{
+    defineI18nRoute: (routeDefinition: {
+        locales?: string[];
+    }) => Promise<void | import("vue-router").NavigationFailure | undefined> | undefined;
+}> & import("#app").ObjectPlugin<{
+    defineI18nRoute: (routeDefinition: {
+        locales?: string[];
+    }) => Promise<void | import("vue-router").NavigationFailure | undefined> | undefined;
+}>;
+export default _default;

package/dist/runtime/03.define.js

@@ -0,0 +1,23 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { useRoute, useRouter } from "#imports";
+export default defineNuxtPlugin((_nuxtApp) => {
+  const config = useRuntimeConfig();
+  const route = useRoute();
+  const router = useRouter();
+  const i18nConfig = config.public.i18nConfig;
+  const defineI18nRoute = (routeDefinition) => {
+    const currentLocale = (route.params.locale || i18nConfig.defaultLocale).toString();
+    const { locales } = routeDefinition;
+    const { name } = route;
+    if (locales && !locales.includes(currentLocale)) {
+      const defaultRouteName = i18nConfig.defaultLocale !== i18nConfig.defaultLocale ? `localized-${name?.toString}` : name;
+      const resolvedRoute = router.resolve({ name: defaultRouteName });
+      return router.push(resolvedRoute);
+    }
+  };
+  return {
+    provide: {
+      defineI18nRoute
+    }
+  };
+});

package/dist/runtime/04.auto-detect.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/04.auto-detect.js

@@ -0,0 +1,39 @@
+import { defineNuxtPlugin, useCookie } from "#app";
+import { useRoute, useRouter } from "#imports";
+export default defineNuxtPlugin(async ({ $config }) => {
+  const i18nConfig = $config.public.i18nConfig;
+  const userLocaleCookie = useCookie("user-locale");
+  const supportedLocales = i18nConfig.locales?.map((locale) => locale.code) ?? [];
+  const defaultLocale = i18nConfig.defaultLocale || "en";
+  if (userLocaleCookie.value) {
+    return;
+  }
+  const router = useRouter();
+  const route = useRoute();
+  console.log(navigator);
+  const browserLanguages = navigator.languages || [navigator.language];
+  let detectedLocale = defaultLocale;
+  for (const language of browserLanguages) {
+    const primaryLanguage = language.split("-")[0];
+    if (supportedLocales.includes(primaryLanguage)) {
+      detectedLocale = primaryLanguage;
+      break;
+    }
+  }
+  if (supportedLocales.includes(detectedLocale)) {
+    const currentPath = router.currentRoute;
+    const resolvedRoute = router.resolve(currentPath.value);
+    const routeName = resolvedRoute.name.replace(`localized-`, "");
+    const { defaultLocale: defaultLocale2 } = i18nConfig;
+    const newRouteName = detectedLocale === defaultLocale2 ? routeName : `localized-${routeName}`;
+    const newParams = { ...route.params };
+    delete newParams.locale;
+    if (detectedLocale !== defaultLocale2) {
+      newParams.locale = detectedLocale;
+    }
+    userLocaleCookie.value = detectedLocale;
+    location.href = router.resolve({ name: newRouteName, params: newParams }).href;
+  } else {
+    userLocaleCookie.value = defaultLocale;
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/types.d.mts

@@ -0,0 +1,11 @@
+import type { ModuleHooks } from './module.js'
+
+declare module '@nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+export { type Locale, type ModuleHooks, type ModuleOptions, default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+import type { ModuleHooks } from './module'
+
+declare module '@nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+export { type Locale, type ModuleHooks, type ModuleOptions, default } from './module'

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "nuxt-i18n-micro",
+  "version": "1.0.1",
+  "description": "Nuxt I18n Micro is a lightweight, high-performance internationalization module for Nuxt, designed to handle multi-language support with minimal overhead, fast build times, and efficient runtime performance.",
+  "repository": "s00d/nuxt-i18n-micro",
+  "license": "MIT",
+  "type": "module",
+  "author": {
+    "name": "s00d",
+    "email": "Virus191288@gmail.com",
+    "url": "https://s00d.github.io/"
+  },
+  "keywords": [
+    "nuxt",
+    "i18n",
+    "internationalization",
+    "localization",
+    "multi-language",
+    "translation",
+    "nuxt-module",
+    "performance",
+    "seo",
+    "nuxt3"
+  ],
+  "homepage": "https://github.com/s00d/nuxt-i18n-micro",
+  "bugs": {
+    "url": "https://github.com/s00d/nuxt-i18n-micro/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt-module-build build && npm run client:build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "dev:generate": "nuxi generate playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+    "client:build": "nuxi generate client",
+    "client:dev": "nuxi dev client --port 3300",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@nuxt/devtools-kit": "^1.3.9",
+    "@nuxt/kit": "^3.12.4",
+    "sirv": "^2.0.4"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^1.3.9",
+    "@nuxt/devtools-kit": "^1.3.9",
+    "@nuxt/devtools-ui-kit": "^1.3.9",
+    "@nuxt/eslint-config": "^0.5.0",
+    "@nuxt/module-builder": "^0.8.3",
+    "@nuxt/schema": "^3.12.4",
+    "@nuxt/test-utils": "^3.14.1",
+    "@types/node": "^20.14.11",
+    "changelogen": "^0.5.5",
+    "eslint": "^9.7.0",
+    "nuxt": "^3.12.4",
+    "execa": "^9.3.0",
+    "typescript": "latest",
+    "vitest": "^2.0.3",
+    "vue-tsc": "^2.0.26"
+  },
+  "packageManager": "yarn@3.7.0+sha256.7bf0c78a106332886ea4e59641fd819b1af953edcd72c4d93a32b1c71000ee67"
+}