astro-intlayer 9.5.4 → 9.5.5

package/dist/esm/html/index.mjs

@@ -0,0 +1,3 @@
+import { installIntlayerHTML, installIntlayerHTMLDynamic, renderHTML, useHTML, useHTMLRenderer } from "vanilla-intlayer/html";
+
+export { installIntlayerHTML, installIntlayerHTMLDynamic, renderHTML, useHTML, useHTMLRenderer };

package/dist/esm/index.mjs

@@ -1,23 +1,24 @@
-import { emitRewrittenPages } from "./emitRewrittenPages.mjs";
-import { resolve } from "node:path";
-import { getConfiguration } from "@intlayer/config/node";
-import { getAlias } from "@intlayer/config/utils";
-import { prepareIntlayer } from "@intlayer/engine/build";
-import { INTLAYER_NO_EXTERNAL_PATTERN, intlayer as intlayer$1 } from "vite-intlayer";
+import { getIntlayerLocals } from "./requestStorage.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import { useIntlayer } from "./useIntlayer.mjs";
+import { useLocale } from "./useLocale.mjs";
 
 //#region src/index.ts
 /**
-* Keeps the intlayer packages out of Node's native module loader in *every*
-* Vite environment Astro renders from.
+* Package self-reference to the Node-only half of the integration.
 *
-* 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.
+* Kept in a variable so the `import()` below is not statically analyzable:
+* Astro bundles this package into the server build (`ssr.noExternal`), and a
+* literal specifier would make the bundler follow it into `vite-intlayer`,
+* `@intlayer/engine` and the framework compilers — which have no business in
+* the server build, and do not even bundle (`velocityjs`, …). Left alone, the
+* import only runs from `astro.config`, in Node.
 */
-const intlayerNoExternalEnvironments = () => ({
-	name: "astro-intlayer-no-external",
-	configEnvironment: () => ({ resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] } })
-});
+const integrationSpecifier = "astro-intlayer/integration";
+const loadIntegration = () => import(
+	/* @vite-ignore */
+	integrationSpecifier
+);
 /**
 * Astro integration for Intlayer.
 *
@@ -25,12 +26,14 @@ const intlayerNoExternalEnvironments = () => ({
 * 1. Preparing Intlayer resources (dictionaries) at config setup.
 * 2. Injecting Vite plugins for aliases, locale-based routing (middleware), and build optimizations (prune).
 * 3. Configuring Vite aliases for dictionary access.
-* 4. Emitting the prerendered pages at their rewritten (localized) URLs.
+* 4. Registering the `astro-intlayer/middleware`, which resolves the request
+*    locale into `Astro.locals.intlayer` for the `useLocale` / `useIntlayer` /
+*    `useDictionary` hooks of this package.
+* 5. Emitting the prerendered pages at their rewritten (localized) URLs.
 *
-* 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.
+* The implementation is loaded lazily: this entry is also the one pages import
+* their hooks from, and it must not drag the Node-only tooling into their
+* server bundle.
 *
 * @returns An Astro integration object.
 *
@@ -48,26 +51,17 @@ const intlayerNoExternalEnvironments = () => ({
 const intlayer = () => ({
 	name: "astro-intlayer",
 	hooks: {
-		"astro:config:setup": async ({ updateConfig }) => {
-			const configuration = getConfiguration();
-			await prepareIntlayer(configuration);
-			updateConfig({ vite: {
-				plugins: [intlayer$1(), intlayerNoExternalEnvironments()],
-				resolve: { alias: { ...getAlias({
-					configuration,
-					formatter: (value) => resolve(value)
-				}) } },
-				ssr: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] }
-			} });
+		"astro:config:setup": async (options) => {
+			const { configSetup } = await loadIntegration();
+			await configSetup(options);
 		},
-		"astro:build:done": async ({ dir, logger }) => {
-			const configuration = getConfiguration();
-			const emittedPages = await emitRewrittenPages(configuration, dir);
-			if (emittedPages.length > 0) logger.info(`Emitted ${emittedPages.length} rewritten page(s): ${emittedPages.map(([from, to]) => `${from} \u2192 ${to}`).join(", ")}`);
+		"astro:build:done": async (options) => {
+			const { buildDone } = await loadIntegration();
+			await buildDone(options);
 		}
 	}
 });
 
 //#endregion
-export { intlayer as default, intlayer };
+export { intlayer as default, intlayer, getIntlayerLocals, useDictionary, useIntlayer, useLocale };
 //# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["viteIntlayerPlugin"],"sources":["../../src/index.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 * Astro integration for Intlayer.\n *\n * It handles:\n * 1. Preparing Intlayer resources (dictionaries) at config setup.\n * 2. Injecting Vite plugins for aliases, locale-based routing (middleware), and build optimizations (prune).\n * 3. Configuring Vite aliases for dictionary access.\n * 4. Emitting the prerendered pages at their rewritten (localized) URLs.\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 *\n * @returns An Astro integration object.\n *\n * @example\n * ```ts\n * // astro.config.mjs\n * import { defineConfig } from 'astro/config';\n * import { intlayer } from 'astro-intlayer';\n *\n * export default defineConfig({\n *   integrations: [intlayer()],\n * });\n * ```\n */\nexport const intlayer = (): AstroIntegration =>\n  ({\n    name: 'astro-intlayer',\n    hooks: {\n      'astro:config:setup': async ({ updateConfig }) => {\n        const configuration = getConfiguration();\n\n        // Prepare once per process start to ensure generated entries exist\n        await prepareIntlayer(configuration);\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      // Astro renders each page from its canonical file-system route, so a\n      // 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      'astro:build:done': async ({ dir, logger }) => {\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    },\n  }) satisfies AstroIntegration;\n\n/**\n * Alias of {@link intlayer}, kept so `astro add astro-intlayer` works.\n *\n * Astro's CLI codemod always writes a default import\n * (`import intlayer from 'astro-intlayer'`) without checking what the package\n * exports, so the integration has to be reachable that way too. The named\n * export stays the documented one.\n */\nexport default intlayer;\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAAC,4BAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,kBACV;CACC,MAAM;CACN,OAAO;EACL,sBAAsB,OAAO,EAAE,mBAAmB;GAChD,MAAM,gBAAgB,iBAAiB;GAGvC,MAAM,gBAAgB,aAAa;GAEnC,aAAa,EACX,MAAM;IACJ,SAAS,CACPA,WAAmB,GACnB,+BAA+B,CACjC;IACA,SAAS,EACP,OAAO,EACL,GAAG,SAAS;KACV;KACA,YAAY,UAAU,QAAQ,KAAK;IACrC,CAAC,EACH,EACF;IAWA,KAAK,EACH,YAAY,CAAC,4BAA4B,EAC3C;GACF,EACF,CAAC;EACH;EAMA,oBAAoB,OAAO,EAAE,KAAK,aAAa;GAC7C,MAAM,gBAAgB,iBAAiB;GAEvC,MAAM,eAAe,MAAM,mBAAmB,eAAe,GAAG;GAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;EAEJ;CACF;AACF"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["import type { AstroIntegration } from 'astro';\n\nexport type { IntlayerLocals } from './middleware';\nexport { getIntlayerLocals } from './requestStorage';\nexport { useDictionary } from './useDictionary';\nexport { useIntlayer } from './useIntlayer';\nexport type { UseLocaleProps, UseLocaleResult } from './useLocale';\nexport { useLocale } from './useLocale';\n\n/**\n * Package self-reference to the Node-only half of the integration.\n *\n * Kept in a variable so the `import()` below is not statically analyzable:\n * Astro bundles this package into the server build (`ssr.noExternal`), and a\n * literal specifier would make the bundler follow it into `vite-intlayer`,\n * `@intlayer/engine` and the framework compilers — which have no business in\n * the server build, and do not even bundle (`velocityjs`, …). Left alone, the\n * import only runs from `astro.config`, in Node.\n */\nconst integrationSpecifier = 'astro-intlayer/integration';\n\nconst loadIntegration = (): Promise<typeof import('./integration')> =>\n  import(/* @vite-ignore */ integrationSpecifier);\n\n/**\n * Astro integration for Intlayer.\n *\n * It handles:\n * 1. Preparing Intlayer resources (dictionaries) at config setup.\n * 2. Injecting Vite plugins for aliases, locale-based routing (middleware), and build optimizations (prune).\n * 3. Configuring Vite aliases for dictionary access.\n * 4. Registering the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the `useLocale` / `useIntlayer` /\n *    `useDictionary` hooks of this package.\n * 5. Emitting the prerendered pages at their rewritten (localized) URLs.\n *\n * The implementation is loaded lazily: this entry is also the one pages import\n * their hooks from, and it must not drag the Node-only tooling into their\n * server bundle.\n *\n * @returns An Astro integration object.\n *\n * @example\n * ```ts\n * // astro.config.mjs\n * import { defineConfig } from 'astro/config';\n * import { intlayer } from 'astro-intlayer';\n *\n * export default defineConfig({\n *   integrations: [intlayer()],\n * });\n * ```\n */\nexport const intlayer = (): AstroIntegration =>\n  ({\n    name: 'astro-intlayer',\n    hooks: {\n      'astro:config:setup': async (options) => {\n        const { configSetup } = await loadIntegration();\n\n        await configSetup(options);\n      },\n      'astro:build:done': async (options) => {\n        const { buildDone } = await loadIntegration();\n\n        await buildDone(options);\n      },\n    },\n  }) satisfies AstroIntegration;\n\n/**\n * Alias of {@link intlayer}, kept so `astro add astro-intlayer` works.\n *\n * Astro's CLI codemod always writes a default import\n * (`import intlayer from 'astro-intlayer'`) without checking what the package\n * exports, so the integration has to be reachable that way too. The named\n * export stays the documented one.\n */\nexport default intlayer;\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,MAAM,uBAAuB;AAE7B,MAAM,wBACJ;;CAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+B5B,MAAa,kBACV;CACC,MAAM;CACN,OAAO;EACL,sBAAsB,OAAO,YAAY;GACvC,MAAM,EAAE,gBAAgB,MAAM,gBAAgB;GAE9C,MAAM,YAAY,OAAO;EAC3B;EACA,oBAAoB,OAAO,YAAY;GACrC,MAAM,EAAE,cAAc,MAAM,gBAAgB;GAE5C,MAAM,UAAU,OAAO;EACzB;CACF;AACF"}

package/dist/esm/integration.mjs

@@ -0,0 +1,65 @@
+import { emitRewrittenPages } from "./emitRewrittenPages.mjs";
+import { resolve } from "node:path";
+import { getConfiguration } from "@intlayer/config/node";
+import { getAlias } from "@intlayer/config/utils";
+import { prepareIntlayer } from "@intlayer/engine/build";
+import { INTLAYER_NO_EXTERNAL_PATTERN, intlayer } from "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: [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 = getConfiguration();
+	await prepareIntlayer(configuration);
+	addMiddleware({
+		entrypoint: "astro-intlayer/middleware",
+		order: "pre"
+	});
+	updateConfig({ vite: {
+		plugins: [intlayer(), intlayerNoExternalEnvironments()],
+		resolve: { alias: { ...getAlias({
+			configuration,
+			formatter: (value) => resolve(value)
+		}) } },
+		ssr: { noExternal: [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 = getConfiguration();
+	const emittedPages = await emitRewrittenPages(configuration, dir);
+	if (emittedPages.length > 0) logger.info(`Emitted ${emittedPages.length} rewritten page(s): ${emittedPages.map(([from, to]) => `${from} \u2192 ${to}`).join(", ")}`);
+};
+
+//#endregion
+export { buildDone, configSetup };
+//# sourceMappingURL=integration.mjs.map

package/dist/esm/integration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.mjs","names":["viteIntlayerPlugin"],"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,CAAC,4BAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;AAkCA,MAAa,cAAc,OAAO,EAChC,cACA,oBACuC;CACvC,MAAM,gBAAgB,iBAAiB;CAGvC,MAAM,gBAAgB,aAAa;CAInC,cAAc;EACZ,YAAY;EACZ,OAAO;CACT,CAAC;CAED,aAAa,EACX,MAAM;EACJ,SAAS,CACPA,SAAmB,GACnB,+BAA+B,CACjC;EACA,SAAS,EACP,OAAO,EACL,GAAG,SAAS;GACV;GACA,YAAY,UAAU,QAAQ,KAAK;EACrC,CAAC,EACH,EACF;EAWA,KAAK,EACH,YAAY,CAAC,4BAA4B,EAC3C;CACF,EACF,CAAC;AACH;;;;;;;AAQA,MAAa,YAAY,OAAO,EAC9B,KACA,aACqC;CACrC,MAAM,gBAAgB,iBAAiB;CAEvC,MAAM,eAAe,MAAM,mBAAmB,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/esm/markdown/index.mjs

@@ -0,0 +1,3 @@
+import { compileMarkdown, installIntlayerMarkdown, installIntlayerMarkdownDynamic, parseMarkdown, renderMarkdown, useMarkdown, useMarkdownRenderer } from "vanilla-intlayer/markdown";
+
+export { compileMarkdown, installIntlayerMarkdown, installIntlayerMarkdownDynamic, parseMarkdown, renderMarkdown, useMarkdown, useMarkdownRenderer };

package/dist/esm/middleware.mjs

@@ -0,0 +1,42 @@
+import { requestStorage } from "./requestStorage.mjs";
+import { getLocaleFromRequest } from "@intlayer/core/localization";
+import { internationalization } from "@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 getLocaleFromRequest({
+			url: context.url,
+			headers: context.isPrerendered ? new Headers() : context.request.headers
+		}),
+		defaultLocale: internationalization.defaultLocale,
+		availableLocales: internationalization.locales
+	};
+	return requestStorage.run(context.locals, next);
+};
+
+//#endregion
+export { onRequest };
+//# sourceMappingURL=middleware.mjs.map

package/dist/esm/middleware.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.mjs","names":[],"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,MAAM,qBAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAe,qBAAqB;EACpC,kBAAkB,qBAAqB;CACzC;CAEA,OAAO,eAAe,IAAI,QAAQ,QAAQ,IAAI;AAChD"}

package/dist/esm/requestStorage.mjs

@@ -0,0 +1,21 @@
+import { AsyncLocalStorage } from "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 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
+export { getIntlayerLocals, getRequestLocale, requestStorage };
+//# sourceMappingURL=requestStorage.mjs.map

package/dist/esm/requestStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestStorage.mjs","names":[],"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,IAAI,kBAE/B;;;;AAKH,MAAa,0BACX,eAAe,SAAS,CAAC,EAAE;;;;AAK7B,MAAa,yBACX,kBAAkB,CAAC,EAAE"}

package/dist/esm/useDictionary.mjs

@@ -0,0 +1,37 @@
+import { getRequestLocale } from "./requestStorage.mjs";
+import { withInertOnChange } from "./withInertOnChange.mjs";
+import { resolveDictionaryArgument } from "@intlayer/core/dictionaryManipulator";
+import { getDictionary } from "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) => withInertOnChange(getDictionary(dictionary, resolveDictionaryArgument({
+	localeOrSelector,
+	contextLocale: getRequestLocale(),
+	dictionaryKey: dictionary.key
+})));
+
+//#endregion
+export { useDictionary };
+//# sourceMappingURL=useDictionary.mjs.map

package/dist/esm/useDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.mjs","names":[],"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,qBAOA,kBACE,cACE,YACA,0BAA0B;CACxB;CACA,eAAe,iBAAiB;CAChC,eAAe,WAAW;AAC5B,CAAC,CACH,CACF"}

package/dist/esm/useIntlayer.mjs

@@ -0,0 +1,37 @@
+import { getRequestLocale } from "./requestStorage.mjs";
+import { withInertOnChange } from "./withInertOnChange.mjs";
+import { resolveDictionaryArgument } from "@intlayer/core/dictionaryManipulator";
+import { getIntlayer } from "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) => withInertOnChange(getIntlayer(key, resolveDictionaryArgument({
+	localeOrSelector,
+	contextLocale: getRequestLocale(),
+	dictionaryKey: key
+})));
+
+//#endregion
+export { useIntlayer };
+//# sourceMappingURL=useIntlayer.mjs.map

package/dist/esm/useIntlayer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.mjs","names":[],"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,qBAIA,kBACE,YACE,KACA,0BAA0B;CACxB;CACA,eAAe,iBAAiB;CAChC,eAAe;AACjB,CAAC,CACH,CACF"}

package/dist/esm/useLocale.mjs

@@ -0,0 +1,40 @@
+import { getRequestLocale } from "./requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+
+//#region src/useLocale.ts
+const { defaultLocale, locales: availableLocales } = 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: 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
+export { useLocale };
+//# sourceMappingURL=useLocale.mjs.map

package/dist/esm/useLocale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.mjs","names":[],"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,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;AAwBrD,MAAa,aAAa,SAAyB,CAAC,OAAwB;CAC1E,QAAQ,iBAAiB,KAAM;CAChB;CACG;CAClB,iBAAiB;EACf,QAAQ,KACN,4GACF;CACF;CACA,uBAAuB,CAAC;AAC1B"}

package/dist/esm/withInertOnChange.mjs

@@ -0,0 +1,16 @@
+//#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
+export { withInertOnChange };
+//# sourceMappingURL=withInertOnChange.mjs.map

package/dist/esm/withInertOnChange.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withInertOnChange.mjs","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/types/client/format/index.d.ts

@@ -0,0 +1,2 @@
+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/types/client/index.d.ts

@@ -0,0 +1,2 @@
+import { DeepTransformContent, IntlayerNode, UseLocaleProps, UseLocaleResult, WithOnChange, getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage } from "vanilla-intlayer";
+export { type DeepTransformContent, type IntlayerNode, type UseLocaleProps, type UseLocaleResult, type WithOnChange, getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage };

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

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

package/dist/types/format/useCompact.d.ts

@@ -0,0 +1,5 @@
+import { compact } from "@intlayer/core/formatters";
+//#region src/format/useCompact.d.ts
+export declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
+//#endregion
+//# sourceMappingURL=useCompact.d.ts.map

package/dist/types/format/useCompact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;qBAOa,sBAAU,MAGJ,kBAAkB"}

package/dist/types/format/useCurrency.d.ts

@@ -0,0 +1,5 @@
+import { currency } from "@intlayer/core/formatters";
+//#region src/format/useCurrency.d.ts
+export declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
+//#endregion
+//# sourceMappingURL=useCurrency.d.ts.map

package/dist/types/format/useCurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;qBAOa,uBAAW,MAGL,kBAAkB"}

package/dist/types/format/useDate.d.ts

@@ -0,0 +1,8 @@
+import { date } from "@intlayer/core/formatters";
+//#region src/format/useDate.d.ts
+/**
+ * Astro hook that provides a localized date/time formatter bound to the request locale.
+ */
+export declare const useDate: () => (...args: Parameters<typeof date>) => string;
+//#endregion
+//# sourceMappingURL=useDate.d.ts.map

package/dist/types/format/useDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../src/format/useDate.ts"],"mappings":";;;;;qBAUa,mBAAO,MAGD,kBAAkB"}

package/dist/types/format/useIntl.d.ts

@@ -0,0 +1,15 @@
+import { WrappedIntl } from "@intlayer/core/utils";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/format/useIntl.d.ts
+/**
+ * Astro hook that provides a locale-bound `Intl` object.
+ *
+ * It uses the request locale on the server, falling back to the configured
+ * default locale.
+ */
+export declare const useIntl: (locale?: LocalesValues) => {
+  intl: WrappedIntl;
+  subscribe: (callback: (intl: WrappedIntl) => void) => () => void;
+};
+//#endregion
+//# sourceMappingURL=useIntl.d.ts.map

package/dist/types/format/useIntl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/format/useIntl.ts"],"mappings":";;;;;;;;;qBAgBa,UAAO,SACT;EAET,MAAM;EACN,YAAY,WAAW,MAAM"}

package/dist/types/format/useList.d.ts

@@ -0,0 +1,5 @@
+import { list } from "@intlayer/core/formatters";
+//#region src/format/useList.d.ts
+export declare const useList: () => (...args: Parameters<typeof list>) => string;
+//#endregion
+//# sourceMappingURL=useList.d.ts.map

package/dist/types/format/useList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;qBAOa,mBAAO,MAGD,kBAAkB"}

package/dist/types/format/useNumber.d.ts

@@ -0,0 +1,8 @@
+import { number } from "@intlayer/core/formatters";
+//#region src/format/useNumber.d.ts
+/**
+ * Astro hook that provides a localized number formatter bound to the request locale.
+ */
+export declare const useNumber: () => (...args: Parameters<typeof number>) => string;
+//#endregion
+//# sourceMappingURL=useNumber.d.ts.map

package/dist/types/format/useNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;qBAUa,qBAAS,MAGH,kBAAkB"}

package/dist/types/format/usePercentage.d.ts

@@ -0,0 +1,5 @@
+import { percentage } from "@intlayer/core/formatters";
+//#region src/format/usePercentage.d.ts
+export declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
+//#endregion
+//# sourceMappingURL=usePercentage.d.ts.map

package/dist/types/format/usePercentage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;qBAOa,yBAAa,MAGP,kBAAkB"}

package/dist/types/format/useRelativeTime.d.ts

@@ -0,0 +1,5 @@
+import { relativeTime } from "@intlayer/core/formatters";
+//#region src/format/useRelativeTime.d.ts
+export declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
+//#endregion
+//# sourceMappingURL=useRelativeTime.d.ts.map

package/dist/types/format/useRelativeTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;qBAOa,2BAAe,MAGT,kBAAkB"}

package/dist/types/format/useUnit.d.ts

@@ -0,0 +1,5 @@
+import { units } from "@intlayer/core/formatters";
+//#region src/format/useUnit.d.ts
+export declare const useUnit: () => (...args: Parameters<typeof units>) => string;
+//#endregion
+//# sourceMappingURL=useUnit.d.ts.map

package/dist/types/format/useUnit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../src/format/useUnit.ts"],"mappings":";;qBAOa,mBAAO,MAGD,kBAAkB"}

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

@@ -0,0 +1,2 @@
+import { HTMLComponents, IntlayerHTMLPluginOptions, IntlayerHTMLProvider, RenderHTMLFunction, RenderHTMLOptions, RenderHTMLProps, installIntlayerHTML, installIntlayerHTMLDynamic, renderHTML, useHTML, useHTMLRenderer } from "vanilla-intlayer/html";
+export { type HTMLComponents, type IntlayerHTMLPluginOptions, type IntlayerHTMLProvider, type RenderHTMLFunction, type RenderHTMLOptions, type RenderHTMLProps, installIntlayerHTML, installIntlayerHTMLDynamic, renderHTML, useHTML, useHTMLRenderer };