astro-intlayer 9.5.4 → 9.5.5

package/dist/cjs/integration.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_emitRewrittenPages = require('./emitRewrittenPages.cjs');
+let node_path = require("node:path");
+let _intlayer_config_node = require("@intlayer/config/node");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_engine_build = require("@intlayer/engine/build");
+let vite_intlayer = require("vite-intlayer");
+
+//#region src/integration.ts
+/**
+* Keeps the intlayer packages out of Node's native module loader in *every*
+* Vite environment Astro renders from.
+*
+* A static dev server renders from `ssr`, but other setups render from Astro's
+* `astro` or `prerender` environments, and a top-level `ssr.noExternal` only
+* seeds the `ssr` one. Declaring it per environment covers the rest.
+*/
+const intlayerNoExternalEnvironments = () => ({
+	name: "astro-intlayer-no-external",
+	configEnvironment: () => ({ resolve: { noExternal: [vite_intlayer.INTLAYER_NO_EXTERNAL_PATTERN] } })
+});
+/**
+* `astro:config:setup`:
+* 1. Prepares the Intlayer resources (dictionaries).
+* 2. Injects the Vite plugins for aliases, locale-based routing and build
+*    optimizations (prune).
+* 3. Configures the Vite aliases for dictionary access.
+* 4. Registers the `astro-intlayer/middleware`, which resolves the request
+*    locale into `Astro.locals.intlayer` for the hooks.
+*
+* The dev-time content watcher is not started here: the bundled
+* `vite-intlayer` plugin already starts one from `configureServer`, and
+* `watch()` subscribes anew on every call, so doing both would rebuild each
+* content edit twice.
+*/
+const configSetup = async ({ updateConfig, addMiddleware }) => {
+	const configuration = (0, _intlayer_config_node.getConfiguration)();
+	await (0, _intlayer_engine_build.prepareIntlayer)(configuration);
+	addMiddleware({
+		entrypoint: "astro-intlayer/middleware",
+		order: "pre"
+	});
+	updateConfig({ vite: {
+		plugins: [(0, vite_intlayer.intlayer)(), intlayerNoExternalEnvironments()],
+		resolve: { alias: { ...(0, _intlayer_config_utils.getAlias)({
+			configuration,
+			formatter: (value) => (0, node_path.resolve)(value)
+		}) } },
+		ssr: { noExternal: [vite_intlayer.INTLAYER_NO_EXTERNAL_PATTERN] }
+	} });
+};
+/**
+* `astro:build:done`: Astro renders each page from its canonical file-system
+* route, so a static build has no file for the localized paths declared in
+* `routing.rewrite`. Mirror them here, otherwise the URLs produced by
+* `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.
+*/
+const buildDone = async ({ dir, logger }) => {
+	const configuration = (0, _intlayer_config_node.getConfiguration)();
+	const emittedPages = await require_emitRewrittenPages.emitRewrittenPages(configuration, dir);
+	if (emittedPages.length > 0) logger.info(`Emitted ${emittedPages.length} rewritten page(s): ${emittedPages.map(([from, to]) => `${from} \u2192 ${to}`).join(", ")}`);
+};
+
+//#endregion
+exports.buildDone = buildDone;
+exports.configSetup = configSetup;
+//# sourceMappingURL=integration.cjs.map

package/dist/cjs/integration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.cjs","names":["INTLAYER_NO_EXTERNAL_PATTERN","getConfiguration","prepareIntlayer","viteIntlayerPlugin","getAlias","resolve","emitRewrittenPages"],"sources":["../../src/integration.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getAlias } from '@intlayer/config/utils';\nimport { prepareIntlayer } from '@intlayer/engine/build';\nimport type { AstroIntegration } from 'astro';\nimport type { PluginOption } from 'vite';\nimport {\n  INTLAYER_NO_EXTERNAL_PATTERN,\n  intlayer as viteIntlayerPlugin,\n} from 'vite-intlayer';\nimport { emitRewrittenPages } from './emitRewrittenPages';\n\n/**\n * Keeps the intlayer packages out of Node's native module loader in *every*\n * Vite environment Astro renders from.\n *\n * A static dev server renders from `ssr`, but other setups render from Astro's\n * `astro` or `prerender` environments, and a top-level `ssr.noExternal` only\n * seeds the `ssr` one. Declaring it per environment covers the rest.\n */\nconst intlayerNoExternalEnvironments = (): PluginOption => ({\n  name: 'astro-intlayer-no-external',\n  configEnvironment: () => ({\n    resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] },\n  }),\n});\n\n/**\n * Node-only half of the integration, loaded lazily by the `astro-intlayer`\n * entry when a hook runs.\n *\n * Pages import their hooks from that same entry, and Astro bundles the whole\n * package into the server build (`ssr.noExternal`), so the config loader,\n * `@intlayer/engine` and `vite-intlayer` must stay behind a dynamic import:\n * a static one would put them in the module graph of every page.\n */\n\ntype ConfigSetupOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:config:setup']>\n>[0];\n\ntype BuildDoneOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:build:done']>\n>[0];\n\n/**\n * `astro:config:setup`:\n * 1. Prepares the Intlayer resources (dictionaries).\n * 2. Injects the Vite plugins for aliases, locale-based routing and build\n *    optimizations (prune).\n * 3. Configures the Vite aliases for dictionary access.\n * 4. Registers the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the hooks.\n *\n * The dev-time content watcher is not started here: the bundled\n * `vite-intlayer` plugin already starts one from `configureServer`, and\n * `watch()` subscribes anew on every call, so doing both would rebuild each\n * content edit twice.\n */\nexport const configSetup = async ({\n  updateConfig,\n  addMiddleware,\n}: ConfigSetupOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  // Prepare once per process start to ensure generated entries exist\n  await prepareIntlayer(configuration);\n\n  // Runs before the user middleware so `Astro.locals.intlayer` is set\n  // everywhere, including in a hand-written `src/middleware.ts`.\n  addMiddleware({\n    entrypoint: 'astro-intlayer/middleware',\n    order: 'pre',\n  });\n\n  updateConfig({\n    vite: {\n      plugins: [\n        viteIntlayerPlugin(),\n        intlayerNoExternalEnvironments(),\n      ] as PluginOption[],\n      resolve: {\n        alias: {\n          ...getAlias({\n            configuration,\n            formatter: (value) => resolve(value),\n          }),\n        },\n      },\n      // `astro-intlayer` is tagged with the `astro` keyword, so Astro\n      // treats it as an Astro package and crawls its dependency tree\n      // (`vitefu`), force-externalizing every dependency it finds —\n      // `@intlayer/core`, `@intlayer/config`, … — into\n      // `resolve.external`. Vite checks `external` before `noExternal`,\n      // so the `ssr.noExternal` that `vite-intlayer` returns from its\n      // Vite `config` hook loses that race and the packages are loaded\n      // natively by Node, stranding dictionary edits behind Node's\n      // require cache. Declaring it here instead runs before the crawl,\n      // which drops explicitly no-externalized packages from its result.\n      ssr: {\n        noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n      },\n    },\n  });\n};\n\n/**\n * `astro:build:done`: Astro renders each page from its canonical file-system\n * route, so a static build has no file for the localized paths declared in\n * `routing.rewrite`. Mirror them here, otherwise the URLs produced by\n * `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.\n */\nexport const buildDone = async ({\n  dir,\n  logger,\n}: BuildDoneOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  const emittedPages = await emitRewrittenPages(configuration, dir);\n\n  if (emittedPages.length > 0) {\n    logger.info(\n      `Emitted ${emittedPages.length} rewritten page(s): ${emittedPages\n        .map(([from, to]) => `${from} \\u2192 ${to}`)\n        .join(', ')}`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAACA,0CAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;AAkCA,MAAa,cAAc,OAAO,EAChC,cACA,oBACuC;CACvC,MAAM,oBAAgBC,wCAAiB;CAGvC,UAAMC,wCAAgB,aAAa;CAInC,cAAc;EACZ,YAAY;EACZ,OAAO;CACT,CAAC;CAED,aAAa,EACX,MAAM;EACJ,SAAS,KACPC,wBAAmB,GACnB,+BAA+B,CACjC;EACA,SAAS,EACP,OAAO,EACL,OAAGC,iCAAS;GACV;GACA,YAAY,cAAUC,mBAAQ,KAAK;EACrC,CAAC,EACH,EACF;EAWA,KAAK,EACH,YAAY,CAACL,0CAA4B,EAC3C;CACF,EACF,CAAC;AACH;;;;;;;AAQA,MAAa,YAAY,OAAO,EAC9B,KACA,aACqC;CACrC,MAAM,oBAAgBC,wCAAiB;CAEvC,MAAM,eAAe,MAAMK,8CAAmB,eAAe,GAAG;CAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;AAEJ"}

package/dist/cjs/markdown/index.cjs

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let vanilla_intlayer_markdown = require("vanilla-intlayer/markdown");
+
+Object.defineProperty(exports, 'compileMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.compileMarkdown;
+  }
+});
+Object.defineProperty(exports, 'installIntlayerMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.installIntlayerMarkdown;
+  }
+});
+Object.defineProperty(exports, 'installIntlayerMarkdownDynamic', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.installIntlayerMarkdownDynamic;
+  }
+});
+Object.defineProperty(exports, 'parseMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.parseMarkdown;
+  }
+});
+Object.defineProperty(exports, 'renderMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.renderMarkdown;
+  }
+});
+Object.defineProperty(exports, 'useMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.useMarkdown;
+  }
+});
+Object.defineProperty(exports, 'useMarkdownRenderer', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.useMarkdownRenderer;
+  }
+});

package/dist/cjs/middleware.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_requestStorage = require('./requestStorage.cjs');
+let _intlayer_core_localization = require("@intlayer/core/localization");
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/middleware.ts
+/**
+* Astro middleware resolving the request locale into `Astro.locals.intlayer`.
+*
+* Priority: the URL (path prefix or `?locale=` search param, in every routing
+* mode but `no-prefix`), then the locale persisted by the client (cookie or
+* custom header), then `Accept-Language` negotiation.
+*
+* The `intlayer()` integration registers it automatically, before the user
+* middleware, so `Astro.locals.intlayer` is available in every page, endpoint
+* and middleware. The rest of the request renders inside an
+* `AsyncLocalStorage` scope bound to those locals, which is how the hooks of
+* `astro-intlayer/server` read the locale with no argument.
+*
+* @example
+* ```ts
+* // src/middleware.ts — only needed when composing it by hand
+* import { onRequest as intlayer } from 'astro-intlayer/middleware';
+* import { sequence } from 'astro:middleware';
+*
+* export const onRequest = sequence(intlayer, myMiddleware);
+* ```
+*/
+const onRequest = async (context, next) => {
+	context.locals.intlayer = {
+		locale: await (0, _intlayer_core_localization.getLocaleFromRequest)({
+			url: context.url,
+			headers: context.isPrerendered ? new Headers() : context.request.headers
+		}),
+		defaultLocale: _intlayer_config_built.internationalization.defaultLocale,
+		availableLocales: _intlayer_config_built.internationalization.locales
+	};
+	return require_requestStorage.requestStorage.run(context.locals, next);
+};
+
+//#endregion
+exports.onRequest = onRequest;
+//# sourceMappingURL=middleware.cjs.map

package/dist/cjs/middleware.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.cjs","names":["getLocaleFromRequest","internationalization","requestStorage"],"sources":["../../src/middleware.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { getLocaleFromRequest } from '@intlayer/core/localization';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { MiddlewareHandler } from 'astro';\nimport { requestStorage } from './requestStorage';\n\n/**\n * Intlayer state stored in `Astro.locals.intlayer` by the {@link onRequest} middleware.\n */\nexport type IntlayerLocals = {\n  /** Locale resolved for the current request. */\n  locale: DeclaredLocales;\n  /** Locale configured as fallback in `intlayer.config.ts`. */\n  defaultLocale: DeclaredLocales;\n  /** Every locale declared in `intlayer.config.ts`. */\n  availableLocales: DeclaredLocales[];\n};\n\ndeclare global {\n  namespace App {\n    interface Locals {\n      intlayer: IntlayerLocals;\n    }\n  }\n}\n\n/**\n * Astro middleware resolving the request locale into `Astro.locals.intlayer`.\n *\n * Priority: the URL (path prefix or `?locale=` search param, in every routing\n * mode but `no-prefix`), then the locale persisted by the client (cookie or\n * custom header), then `Accept-Language` negotiation.\n *\n * The `intlayer()` integration registers it automatically, before the user\n * middleware, so `Astro.locals.intlayer` is available in every page, endpoint\n * and middleware. The rest of the request renders inside an\n * `AsyncLocalStorage` scope bound to those locals, which is how the hooks of\n * `astro-intlayer/server` read the locale with no argument.\n *\n * @example\n * ```ts\n * // src/middleware.ts — only needed when composing it by hand\n * import { onRequest as intlayer } from 'astro-intlayer/middleware';\n * import { sequence } from 'astro:middleware';\n *\n * export const onRequest = sequence(intlayer, myMiddleware);\n * ```\n */\nexport const onRequest: MiddlewareHandler = async (context, next) => {\n  context.locals.intlayer = {\n    locale: await getLocaleFromRequest({\n      url: context.url,\n      // A prerendered page is rendered once and served to every visitor, so\n      // its locale can only come from the URL. Reading the request headers\n      // there would also make Astro warn on every page of the build.\n      headers: context.isPrerendered ? new Headers() : context.request.headers,\n    }),\n    defaultLocale: internationalization.defaultLocale as DeclaredLocales,\n    availableLocales: internationalization.locales as DeclaredLocales[],\n  };\n\n  return requestStorage.run(context.locals, next);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,YAA+B,OAAO,SAAS,SAAS;CACnE,QAAQ,OAAO,WAAW;EACxB,QAAQ,UAAMA,kDAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAeC,4CAAqB;EACpC,kBAAkBA,4CAAqB;CACzC;CAEA,OAAOC,sCAAe,IAAI,QAAQ,QAAQ,IAAI;AAChD"}

package/dist/cjs/requestStorage.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let node_async_hooks = require("node:async_hooks");
+
+//#region src/requestStorage.ts
+/**
+* `Astro.locals` of the request being rendered, made available to every
+* function running inside the middleware scope — page and component
+* frontmatter, endpoints, nested middleware — without passing `Astro` around.
+*/
+const requestStorage = new node_async_hooks.AsyncLocalStorage();
+/**
+* Returns the Intlayer locals of the request being rendered, if any.
+*/
+const getIntlayerLocals = () => requestStorage.getStore()?.intlayer;
+/**
+* Returns the locale of the request being rendered, if any.
+*/
+const getRequestLocale = () => getIntlayerLocals()?.locale;
+
+//#endregion
+exports.getIntlayerLocals = getIntlayerLocals;
+exports.getRequestLocale = getRequestLocale;
+exports.requestStorage = requestStorage;
+//# sourceMappingURL=requestStorage.cjs.map

package/dist/cjs/requestStorage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestStorage.cjs","names":["AsyncLocalStorage"],"sources":["../../src/requestStorage.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { IntlayerLocals } from './middleware';\n\n/**\n * `Astro.locals` of the request being rendered, made available to every\n * function running inside the middleware scope — page and component\n * frontmatter, endpoints, nested middleware — without passing `Astro` around.\n */\nexport const requestStorage = new AsyncLocalStorage<{\n  intlayer?: IntlayerLocals;\n}>();\n\n/**\n * Returns the Intlayer locals of the request being rendered, if any.\n */\nexport const getIntlayerLocals = (): IntlayerLocals | undefined =>\n  requestStorage.getStore()?.intlayer;\n\n/**\n * Returns the locale of the request being rendered, if any.\n */\nexport const getRequestLocale = (): DeclaredLocales | undefined =>\n  getIntlayerLocals()?.locale;\n"],"mappings":";;;;;;;;;AASA,MAAa,iBAAiB,IAAIA,mCAE/B;;;;AAKH,MAAa,0BACX,eAAe,SAAS,CAAC,EAAE;;;;AAK7B,MAAa,yBACX,kBAAkB,CAAC,EAAE"}

package/dist/cjs/useDictionary.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_requestStorage = require('./requestStorage.cjs');
+const require_withInertOnChange = require('./withInertOnChange.cjs');
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+let vanilla_intlayer = require("vanilla-intlayer");
+
+//#region src/useDictionary.ts
+/**
+* Transforms an imported dictionary (or qualified dictionary group) and returns
+* its content for the locale of the request being rendered, read from
+* `Astro.locals.intlayer`.
+*
+* The second argument is either a locale or a selector object
+* (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence
+* over the request locale.
+*
+* Same signature and content shape as the client-side hook this entry resolves
+* to in the browser (`vanilla-intlayer`).
+*
+* @example
+* ```astro
+* ---
+* import { useDictionary } from 'astro-intlayer';
+* import homeContent from '../content/home.content';
+*
+* const { title } = useDictionary(homeContent);
+* ---
+* ```
+*/
+const useDictionary = (dictionary, localeOrSelector) => require_withInertOnChange.withInertOnChange((0, vanilla_intlayer.getDictionary)(dictionary, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
+	localeOrSelector,
+	contextLocale: require_requestStorage.getRequestLocale(),
+	dictionaryKey: dictionary.key
+})));
+
+//#endregion
+exports.useDictionary = useDictionary;
+//# sourceMappingURL=useDictionary.cjs.map

package/dist/cjs/useDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.cjs","names":["withInertOnChange","getDictionary","resolveDictionaryArgument","getRequestLocale"],"sources":["../../src/useDictionary.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n  ResolveQualifiedDictionaryContent,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  type DeepTransformContent,\n  getDictionary,\n  type WithOnChange,\n} from 'vanilla-intlayer';\nimport { getRequestLocale } from './requestStorage';\nimport { withInertOnChange } from './withInertOnChange';\n\n/**\n * Transforms an imported dictionary (or qualified dictionary group) and returns\n * its content for the locale of the request being rendered, read from\n * `Astro.locals.intlayer`.\n *\n * The second argument is either a locale or a selector object\n * (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence\n * over the request locale.\n *\n * Same signature and content shape as the client-side hook this entry resolves\n * to in the browser (`vanilla-intlayer`).\n *\n * @example\n * ```astro\n * ---\n * import { useDictionary } from 'astro-intlayer';\n * import homeContent from '../content/home.content';\n *\n * const { title } = useDictionary(homeContent);\n * ---\n * ```\n */\nexport const useDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends\n    | LocalesValues\n    | DictionarySelectorForGroup<T> = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A\n): WithOnChange<\n  DeepTransformContent<\n    ResolveQualifiedDictionaryContent<T, A>,\n    ExtractSelectorLocale<A>\n  >\n> =>\n  withInertOnChange(\n    getDictionary<T, A>(\n      dictionary,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale: getRequestLocale(),\n        dictionaryKey: dictionary.key,\n      }) as A\n    )\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,iBAMX,YACA,qBAOAA,gDACEC,gCACE,gBACAC,gEAA0B;CACxB;CACA,eAAeC,wCAAiB;CAChC,eAAe,WAAW;AAC5B,CAAC,CACH,CACF"}

package/dist/cjs/useIntlayer.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_requestStorage = require('./requestStorage.cjs');
+const require_withInertOnChange = require('./withInertOnChange.cjs');
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+let vanilla_intlayer = require("vanilla-intlayer");
+
+//#region src/useIntlayer.ts
+/**
+* Picks one dictionary by its key and returns its content for the locale of
+* the request being rendered, read from `Astro.locals.intlayer`.
+*
+* The second argument is either a locale or a selector object
+* (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence
+* over the request locale.
+*
+* Same signature and content shape as the client-side hook this entry resolves
+* to in the browser (`vanilla-intlayer`), so a call moves between the
+* frontmatter and a `<script>` unchanged.
+*
+* @example
+* ```astro
+* ---
+* import { useIntlayer } from 'astro-intlayer';
+*
+* const { title, description } = useIntlayer('home');
+* ---
+* <h1>{title}</h1>
+* ```
+*/
+const useIntlayer = (key, localeOrSelector) => require_withInertOnChange.withInertOnChange((0, vanilla_intlayer.getIntlayer)(key, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
+	localeOrSelector,
+	contextLocale: require_requestStorage.getRequestLocale(),
+	dictionaryKey: key
+})));
+
+//#endregion
+exports.useIntlayer = useIntlayer;
+//# sourceMappingURL=useIntlayer.cjs.map

package/dist/cjs/useIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.cjs","names":["withInertOnChange","getIntlayer","resolveDictionaryArgument","getRequestLocale"],"sources":["../../src/useIntlayer.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  DictionarySelectorForKey,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  type DeepTransformContent,\n  getIntlayer,\n  type WithOnChange,\n} from 'vanilla-intlayer';\nimport { getRequestLocale } from './requestStorage';\nimport { withInertOnChange } from './withInertOnChange';\n\n/**\n * Picks one dictionary by its key and returns its content for the locale of\n * the request being rendered, read from `Astro.locals.intlayer`.\n *\n * The second argument is either a locale or a selector object\n * (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence\n * over the request locale.\n *\n * Same signature and content shape as the client-side hook this entry resolves\n * to in the browser (`vanilla-intlayer`), so a call moves between the\n * frontmatter and a `<script>` unchanged.\n *\n * @example\n * ```astro\n * ---\n * import { useIntlayer } from 'astro-intlayer';\n *\n * const { title, description } = useIntlayer('home');\n * ---\n * <h1>{title}</h1>\n * ```\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A\n): WithOnChange<\n  DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>\n> =>\n  withInertOnChange(\n    getIntlayer<T, A>(\n      key,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale: getRequestLocale(),\n        dictionaryKey: key as string,\n      }) as A\n    )\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,eAIX,KACA,qBAIAA,gDACEC,8BACE,SACAC,gEAA0B;CACxB;CACA,eAAeC,wCAAiB;CAChC,eAAe;AACjB,CAAC,CACH,CACF"}

package/dist/cjs/useLocale.cjs

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_requestStorage = require('./requestStorage.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/useLocale.ts
+const { defaultLocale, locales: availableLocales } = _intlayer_config_built.internationalization;
+/**
+* Returns the locale of the request being rendered, read from
+* `Astro.locals.intlayer`, with the configured default and available locales.
+*
+* Falls back to the default locale outside of a request, i.e. when the
+* `astro-intlayer/middleware` did not run.
+*
+* Same shape as the client-side hook this entry resolves to in the browser
+* (`vanilla-intlayer`). A request has no locale to switch, so `setLocale` and
+* `subscribe` are inert here: switch the locale from a `<script>`, where the
+* same import gives the client implementation.
+*
+* @example
+* ```astro
+* ---
+* import { useLocale } from 'astro-intlayer';
+*
+* const { locale, availableLocales } = useLocale();
+* ---
+* <html lang={locale}>
+* ```
+*/
+const useLocale = (_props = {}) => ({
+	locale: require_requestStorage.getRequestLocale() ?? defaultLocale,
+	defaultLocale,
+	availableLocales,
+	setLocale: () => {
+		console.warn("[astro-intlayer] setLocale() has no effect during a server render. Call it from a client <script> instead.");
+	},
+	subscribe: () => () => {}
+});
+
+//#endregion
+exports.useLocale = useLocale;
+//# sourceMappingURL=useLocale.cjs.map

package/dist/cjs/useLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.cjs","names":["internationalization","getRequestLocale"],"sources":["../../src/useLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type {\n  UseLocaleProps,\n  UseLocaleResult as VanillaUseLocaleResult,\n} from 'vanilla-intlayer';\nimport { getRequestLocale } from './requestStorage';\n\nexport type { UseLocaleProps } from 'vanilla-intlayer';\n\nexport type UseLocaleResult = VanillaUseLocaleResult;\n\nconst { defaultLocale, locales: availableLocales } = internationalization;\n\n/**\n * Returns the locale of the request being rendered, read from\n * `Astro.locals.intlayer`, with the configured default and available locales.\n *\n * Falls back to the default locale outside of a request, i.e. when the\n * `astro-intlayer/middleware` did not run.\n *\n * Same shape as the client-side hook this entry resolves to in the browser\n * (`vanilla-intlayer`). A request has no locale to switch, so `setLocale` and\n * `subscribe` are inert here: switch the locale from a `<script>`, where the\n * same import gives the client implementation.\n *\n * @example\n * ```astro\n * ---\n * import { useLocale } from 'astro-intlayer';\n *\n * const { locale, availableLocales } = useLocale();\n * ---\n * <html lang={locale}>\n * ```\n */\nexport const useLocale = (_props: UseLocaleProps = {}): UseLocaleResult => ({\n  locale: getRequestLocale() ?? (defaultLocale as DeclaredLocales),\n  defaultLocale: defaultLocale as DeclaredLocales,\n  availableLocales: availableLocales as DeclaredLocales[],\n  setLocale: () => {\n    console.warn(\n      '[astro-intlayer] setLocale() has no effect during a server render. Call it from a client <script> instead.'\n    );\n  },\n  subscribe: () => () => {},\n});\n"],"mappings":";;;;;AAYA,MAAM,EAAE,eAAe,SAAS,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;AAwBrD,MAAa,aAAa,SAAyB,CAAC,OAAwB;CAC1E,QAAQC,wCAAiB,KAAM;CAChB;CACG;CAClB,iBAAiB;EACf,QAAQ,KACN,4GACF;CACF;CACA,uBAAuB,CAAC;AAC1B"}

package/dist/cjs/withInertOnChange.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region src/withInertOnChange.ts
+/**
+* Gives server-rendered content the `.onChange()` of its client counterpart.
+*
+* The locale cannot change during a server render, so the subscription never
+* fires; it only keeps the content shape identical on both sides of the
+* `astro-intlayer` entry.
+*/
+const withInertOnChange = (content) => {
+	if (content !== null && typeof content === "object") content.onChange = () => content;
+	return content;
+};
+
+//#endregion
+exports.withInertOnChange = withInertOnChange;
+//# sourceMappingURL=withInertOnChange.cjs.map

package/dist/cjs/withInertOnChange.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withInertOnChange.cjs","names":[],"sources":["../../src/withInertOnChange.ts"],"sourcesContent":["import type { WithOnChange } from 'vanilla-intlayer';\n\n/**\n * Gives server-rendered content the `.onChange()` of its client counterpart.\n *\n * The locale cannot change during a server render, so the subscription never\n * fires; it only keeps the content shape identical on both sides of the\n * `astro-intlayer` entry.\n */\nexport const withInertOnChange = <T>(content: T): WithOnChange<T> => {\n  // A selector can resolve to null or a primitive; only objects carry `.onChange`.\n  if (content !== null && typeof content === 'object') {\n    (content as WithOnChange<T>).onChange = () => content as WithOnChange<T>;\n  }\n\n  return content as WithOnChange<T>;\n};\n"],"mappings":";;;;;;;;;AASA,MAAa,qBAAwB,YAAgC;CAEnE,IAAI,YAAY,QAAQ,OAAO,YAAY,UACzC,AAAC,QAA4B,iBAAiB;CAGhD,OAAO;AACT"}

package/dist/esm/client/format/index.mjs

@@ -0,0 +1,3 @@
+import { useCompact, useCurrency, useDate, useIntl, useList, useNumber, usePercentage, useRelativeTime, useUnit } from "vanilla-intlayer/format";
+
+export { useCompact, useCurrency, useDate, useIntl, useList, useNumber, usePercentage, useRelativeTime, useUnit };

package/dist/esm/client/index.mjs

@@ -0,0 +1,3 @@
+import { getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage } from "vanilla-intlayer";
+
+export { getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage };

package/dist/esm/format/index.mjs

@@ -0,0 +1,11 @@
+import { useCompact } from "./useCompact.mjs";
+import { useCurrency } from "./useCurrency.mjs";
+import { useDate } from "./useDate.mjs";
+import { useIntl } from "./useIntl.mjs";
+import { useList } from "./useList.mjs";
+import { useNumber } from "./useNumber.mjs";
+import { usePercentage } from "./usePercentage.mjs";
+import { useRelativeTime } from "./useRelativeTime.mjs";
+import { useUnit } from "./useUnit.mjs";
+
+export { useCompact, useCurrency, useDate, useIntl, useList, useNumber, usePercentage, useRelativeTime, useUnit };

package/dist/esm/format/useCompact.mjs

@@ -0,0 +1,17 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { compact } from "@intlayer/core/formatters";
+
+//#region src/format/useCompact.ts
+const { defaultLocale } = internationalization;
+const useCompact = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => compact(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useCompact };
+//# sourceMappingURL=useCompact.mjs.map

package/dist/esm/format/useCompact.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCompact.mjs","names":[],"sources":["../../../src/format/useCompact.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { compact } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\nexport const useCompact = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof compact>) =>\n    compact(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,mBAAmB;CAC9B,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SACT,QAAQ,KAAK,IAAI;EACf,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/esm/format/useCurrency.mjs

@@ -0,0 +1,17 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { currency } from "@intlayer/core/formatters";
+
+//#region src/format/useCurrency.ts
+const { defaultLocale } = internationalization;
+const useCurrency = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => currency(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useCurrency };
+//# sourceMappingURL=useCurrency.mjs.map

package/dist/esm/format/useCurrency.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrency.mjs","names":[],"sources":["../../../src/format/useCurrency.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { currency } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\nexport const useCurrency = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof currency>) =>\n    currency(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,oBAAoB;CAC/B,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SACT,SAAS,KAAK,IAAI;EAChB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/esm/format/useDate.mjs

@@ -0,0 +1,26 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { date, presets } from "@intlayer/core/formatters";
+
+//#region src/format/useDate.ts
+const { defaultLocale } = internationalization;
+/**
+* Astro hook that provides a localized date/time formatter bound to the request locale.
+*/
+const useDate = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => {
+		const options = typeof args[1] === "string" ? {
+			...presets[args[1]],
+			locale
+		} : {
+			...args[1],
+			locale: args[1]?.locale ?? locale
+		};
+		return date(args[0], options);
+	};
+};
+
+//#endregion
+export { useDate };
+//# sourceMappingURL=useDate.mjs.map

package/dist/esm/format/useDate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDate.mjs","names":[],"sources":["../../../src/format/useDate.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { date, presets } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\n/**\n * Astro hook that provides a localized date/time formatter bound to the request locale.\n */\nexport const useDate = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof date>) => {\n    const options =\n      typeof args[1] === 'string'\n        ? { ...presets[args[1]], locale }\n        : { ...args[1], locale: args[1]?.locale ?? locale };\n\n    return date(args[0], options as Parameters<typeof date>[1]);\n  };\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;;;;AAK1B,MAAa,gBAAgB;CAC3B,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SAAkC;EAC3C,MAAM,UACJ,OAAO,KAAK,OAAO,WACf;GAAE,GAAG,QAAQ,KAAK;GAAK;EAAO,IAC9B;GAAE,GAAG,KAAK;GAAI,QAAQ,KAAK,EAAE,EAAE,UAAU;EAAO;EAEtD,OAAO,KAAK,KAAK,IAAI,OAAqC;CAC5D;AACF"}

package/dist/esm/format/useIntl.mjs

@@ -0,0 +1,23 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { bindIntl } from "@intlayer/core/utils";
+
+//#region src/format/useIntl.ts
+const { defaultLocale } = internationalization;
+/**
+* Astro hook that provides a locale-bound `Intl` object.
+*
+* It uses the request locale on the server, falling back to the configured
+* default locale.
+*/
+const useIntl = (locale) => {
+	const currentLocale = locale ?? getRequestLocale() ?? defaultLocale;
+	return {
+		intl: bindIntl(currentLocale),
+		subscribe: () => () => {}
+	};
+};
+
+//#endregion
+export { useIntl };
+//# sourceMappingURL=useIntl.mjs.map

package/dist/esm/format/useIntl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntl.mjs","names":[],"sources":["../../../src/format/useIntl.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { bindIntl, type WrappedIntl } from '@intlayer/core/utils';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\n/**\n * Astro hook that provides a locale-bound `Intl` object.\n *\n * It uses the request locale on the server, falling back to the configured\n * default locale.\n */\nexport const useIntl = (\n  locale?: LocalesValues\n): {\n  intl: WrappedIntl;\n  subscribe: (callback: (intl: WrappedIntl) => void) => () => void;\n} => {\n  const currentLocale =\n    locale ?? getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n  const intl = bindIntl(currentLocale);\n\n  return {\n    intl,\n    subscribe: () => () => {},\n  };\n};\n"],"mappings":";;;;;AAQA,MAAM,EAAE,kBAAkB;;;;;;;AAQ1B,MAAa,WACX,WAIG;CACH,MAAM,gBACJ,UAAU,iBAAiB,KAAM;CAGnC,OAAO;EACL,MAHW,SAAS,aAGjB;EACH,uBAAuB,CAAC;CAC1B;AACF"}

package/dist/esm/format/useList.mjs

@@ -0,0 +1,17 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { list } from "@intlayer/core/formatters";
+
+//#region src/format/useList.ts
+const { defaultLocale } = internationalization;
+const useList = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => list(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useList };
+//# sourceMappingURL=useList.mjs.map

package/dist/esm/format/useList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useList.mjs","names":[],"sources":["../../../src/format/useList.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { list } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\nexport const useList = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof list>) =>\n    list(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,gBAAgB;CAC3B,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SACT,KAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/esm/format/useNumber.mjs

@@ -0,0 +1,20 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { number } from "@intlayer/core/formatters";
+
+//#region src/format/useNumber.ts
+const { defaultLocale } = internationalization;
+/**
+* Astro hook that provides a localized number formatter bound to the request locale.
+*/
+const useNumber = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => number(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useNumber };
+//# sourceMappingURL=useNumber.mjs.map

package/dist/esm/format/useNumber.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNumber.mjs","names":[],"sources":["../../../src/format/useNumber.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { number } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\n/**\n * Astro hook that provides a localized number formatter bound to the request locale.\n */\nexport const useNumber = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof number>) =>\n    number(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;;;;AAK1B,MAAa,kBAAkB;CAC7B,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SACT,OAAO,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/esm/format/usePercentage.mjs

@@ -0,0 +1,17 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { percentage } from "@intlayer/core/formatters";
+
+//#region src/format/usePercentage.ts
+const { defaultLocale } = internationalization;
+const usePercentage = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => percentage(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { usePercentage };
+//# sourceMappingURL=usePercentage.mjs.map

package/dist/esm/format/usePercentage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePercentage.mjs","names":[],"sources":["../../../src/format/usePercentage.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { percentage } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\nexport const usePercentage = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof percentage>) =>\n    percentage(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,sBAAsB;CACjC,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SACT,WAAW,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/esm/format/useRelativeTime.mjs

@@ -0,0 +1,17 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { relativeTime } from "@intlayer/core/formatters";
+
+//#region src/format/useRelativeTime.ts
+const { defaultLocale } = internationalization;
+const useRelativeTime = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => relativeTime(args[0], args[1], {
+		...args[2],
+		locale: args[2]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useRelativeTime };
+//# sourceMappingURL=useRelativeTime.mjs.map

package/dist/esm/format/useRelativeTime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRelativeTime.mjs","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { relativeTime } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\nexport const useRelativeTime = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof relativeTime>) =>\n    relativeTime(args[0], args[1], {\n      ...args[2],\n      locale: args[2]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,wBAAwB;CACnC,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SACT,aAAa,KAAK,IAAI,KAAK,IAAI;EAC7B,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/esm/format/useUnit.mjs

@@ -0,0 +1,17 @@
+import { getRequestLocale } from "../requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { units } from "@intlayer/core/formatters";
+
+//#region src/format/useUnit.ts
+const { defaultLocale } = internationalization;
+const useUnit = () => {
+	const locale = getRequestLocale() ?? defaultLocale;
+	return (...args) => units(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+export { useUnit };
+//# sourceMappingURL=useUnit.mjs.map

package/dist/esm/format/useUnit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUnit.mjs","names":[],"sources":["../../../src/format/useUnit.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { units } from '@intlayer/core/formatters';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getRequestLocale } from '../requestStorage';\n\nconst { defaultLocale } = internationalization;\n\nexport const useUnit = () => {\n  const locale = getRequestLocale() ?? (defaultLocale as DeclaredLocales);\n\n  return (...args: Parameters<typeof units>) =>\n    units(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,gBAAgB;CAC3B,MAAM,SAAS,iBAAiB,KAAM;CAEtC,QAAQ,GAAG,SACT,MAAM,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}