@prosary/nuxt 0.0.0-stage → 0.0.0

package/.dist/config.d.mts

@@ -0,0 +1,59 @@
+import { TranslateRunOptions } from "@prosary/kit";
+/**
+ * The module's configuration. The messages are always authored as FormatJS
+ * message descriptors that a `@prosary/kit` config points at; the module
+ * takes them one of two ways —
+ *
+ * - **Built here.** With no `build`, the module loads the app's own
+ *   `prosary.config.ts` and builds it through the kit at build time. No
+ *   options are needed at all; with `translate`, it translates first.
+ * - **Built elsewhere.** Point `build` at the output of a kit build —
+ *   a content package in a monorepo, or a published one — and the module
+ *   uses it from where it stands:
+ *
+ *   ```ts
+ *   export default defineNuxtConfig({
+ *     prosary: { build: "@acme/messages" },
+ *   });
+ *   ```
+ */
+export interface NuxtProsaryConfig {
+  /**
+   * The kit config to build from, relative to the project root. Defaults to
+   * `prosary.config.ts`. Ignored when a `build` is passed.
+   */
+  config?: string;
+  /**
+   * How to translate: the model — from any AI SDK provider — its call
+   * settings, and the project's instructions, as the kit config's `translate`
+   * carries them beside the source and the targets. Present, the module
+   * translates before it builds, exactly as `prosary translate` does: what
+   * each locale is missing or has out of date is translated and written to
+   * the translations directory, and nothing else is touched. Takes the place
+   * of the model and the settings in the kit config. Ignored when a `build`
+   * is passed, and during `nuxt prepare`.
+   */
+  translate?: NonNullable<TranslateRunOptions["translate"]>;
+  /**
+   * A kit build made elsewhere: the output directory `prosary build` wrote.
+   * A path — relative to the project root, or absolute — to the directory or
+   * its `index.mjs`, or a package whose main entry is that `index.mjs`.
+   */
+  build?: string;
+  /**
+   * The overrides: a directory, relative to the source directory (`app/`), of components
+   * that render in place of elements and directives. Each `.vue` file at its
+   * top level renders the tag or directive its name spells in kebab case:
+   * `H2.vue` renders every `h2`, `Callout.vue` every `callout` directive.
+   * `<Prose :tree>` renders a document with them. Defaults to
+   * `components/prose`.
+   */
+  components?: string;
+}
+/**
+ * Identity helper that types a Nuxt prosary configuration.
+ *
+ * @param config - The Nuxt prosary configuration.
+ * @returns The same config.
+ */
+export declare const defineProsaryConfig: (config: NuxtProsaryConfig) => NuxtProsaryConfig;

package/.dist/config.mjs

@@ -0,0 +1,2 @@
+const defineProsaryConfig = (config) => config;
+export { defineProsaryConfig };

package/.dist/constant.d.mts

@@ -0,0 +1,29 @@
+/**
+ * The build-directory folder the module writes the kit's output into — the
+ * same `index` and `bundles` modules, locale bundles and content documents
+ * `prosary build` writes to its output directory, importable in the app as
+ * `#build/prosary/index.mjs` and `#build/prosary/bundles.mjs`.
+ */
+export declare const MODULES = "prosary";
+/**
+ * The folder of a kit build its content documents sit under:
+ * `content/<locale>/<path>`. The kit's own `CONTENT`, repeated here so a
+ * build made elsewhere is used without the kit installed.
+ */
+export declare const CONTENT = "content";
+/** The cookie the visitor's locale is kept in. */
+export declare const LOCALE_COOKIE = "prosary-locale";
+/** The cookie the visitor's time zone is kept in. */
+export declare const TIME_ZONE_COOKIE = "prosary-time-zone";
+/** The cookie the visitor's convention is kept in. */
+export declare const CONVENTION_COOKIE = "prosary-convention";
+/**
+ * Where the built content documents are served from, as static files:
+ * `{CONTENT_URL}/<locale>/<path>`.
+ */
+export declare const CONTENT_URL = "/_prosary/content";
+/**
+ * The directory of overrides, relative to the source directory, when the config
+ * names none: components that render in place of elements and directives.
+ */
+export declare const OVERRIDES = "components/prose";

package/.dist/constant.mjs

@@ -0,0 +1,8 @@
+const MODULES = "prosary";
+const CONTENT = "content";
+const LOCALE_COOKIE = "prosary-locale";
+const TIME_ZONE_COOKIE = "prosary-time-zone";
+const CONVENTION_COOKIE = "prosary-convention";
+const CONTENT_URL = "/_prosary/content";
+const OVERRIDES = "components/prose";
+export { CONTENT, CONTENT_URL, CONVENTION_COOKIE, LOCALE_COOKIE, MODULES, OVERRIDES, TIME_ZONE_COOKIE };

package/.dist/module.d.mts

@@ -0,0 +1,24 @@
+import { NuxtProsaryConfig } from "./config.mjs";
+/**
+ * Nuxt module for prosary.
+ *
+ * Its messages are always FormatJS descriptors built by `@prosary/kit`:
+ * either the app's own `prosary.config.ts`, built here, or the output of a
+ * kit build made elsewhere, which `build` points at. Built here, the module
+ * first translates what the locales are missing when given `translate`, then
+ * compiles the source messages and every locale's translations at build
+ * time and writes the kit's output — the `index` contract module, the
+ * `bundles` loaders, each locale's bundle and the content documents — as
+ * build templates under `prosary/`. Built elsewhere, the same `index` and
+ * `bundles` modules re-export the build's own. Either way it serves the
+ * content documents as static files, and registers the runtime plugin and
+ * the `useProsary`, `useT`, `useLocale` and `useDocument` auto-imports, and
+ * `<Prose>`, which renders a document with the app's overrides.
+ *
+ * A visitor gets one locale. The server picks it — their cookie, else the
+ * best match for the languages their browser asks for, else the source
+ * locale — and renders with that locale's bundle; the browser loads the same
+. * bundle as its own chunk, and another only when the visitor switches.
+ */
+declare const _default: import("@nuxt/schema").NuxtModule<NuxtProsaryConfig, NuxtProsaryConfig, false>;
+export { _default as default };

package/.dist/module.mjs

@@ -0,0 +1,223 @@
+import { CONTENT, CONTENT_URL, MODULES } from "./constant.mjs";
+import { addComponent, addImports, addPlugin, addServerHandler, addTemplate, createResolver, defineNuxtModule, directoryToURL, tryResolveModule, useLogger } from "@nuxt/kit";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const kebab = (name) => {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+};
+const scanOverrides = (directory) => {
+	if (!existsSync(directory)) return [];
+	return readdirSync(directory).filter((entry) => extname(entry) === ".vue").sort().map((entry) => ({
+		name: kebab(basename(entry, ".vue")),
+		file: join(directory, entry)
+	}));
+};
+const componentsModule = (overrides) => {
+	const names = overrides.map((override) => JSON.stringify(override.name));
+	const imports = overrides.map((override, index) => `import override${index} from ${JSON.stringify(override.file)};`);
+	const entries = overrides.map((override, index) => `  ${JSON.stringify(override.name)}: override${index},`);
+	const keys = names.length === 0 ? "never" : `Known<${names.join(" | ")}>`;
+	return [{
+		path: "components.mjs",
+		contents: [
+			"// Generated by @prosary/nuxt. Do not edit by hand.",
+			...imports,
+			`export const components = Object.freeze({\n${entries.join("\n")}\n});`,
+			""
+		].join("\n")
+	}, {
+		path: "components.d.mts",
+		contents: [
+			"// Generated by @prosary/nuxt. Do not edit by hand.",
+			"import type { Component } from \"vue\";",
+			"import type { Directive, Element } from \"./index.mjs\";",
+			"/** An override names an element or a directive the content builds. */",
+			"type Known<K extends Element | Directive> = K;",
+			`export declare const components: Readonly<Record<${keys}, Component>>;`,
+			""
+		].join("\n")
+	}];
+};
+const ENTRIES = ["index", "bundles"];
+const OUTPUT = "hast";
+const assertOutput = (output, where) => {
+	if (output === OUTPUT) return;
+	const found = output === void 0 ? "names no form (it predates content.output)" : `builds it as ${JSON.stringify(output)}`;
+	throw new Error(`prosary: the content must be built as ${JSON.stringify(OUTPUT)}, which the module renders — ${where} ${found}. Set \`content.output\` to ${JSON.stringify(OUTPUT)} in the kit config, the default, and build again.`);
+};
+const outputOf = async (directory) => {
+	return (await import(pathToFileURL(join(directory, "index.mjs")).href)).content?.output;
+};
+const loadKit = async () => {
+	try {
+		return await import("@prosary/kit");
+	} catch (error) {
+		throw new Error("prosary: building the app's messages needs @prosary/kit, which could not be loaded — add it to your devDependencies, or point `build` at a kit build made elsewhere", { cause: error });
+	}
+};
+const locate = async (build, root) => {
+	let path;
+	if (build.startsWith(".") || isAbsolute(build)) path = resolve(root, build);
+	else {
+		const resolved = await tryResolveModule(build, directoryToURL(root));
+		path = resolved?.startsWith("file:") ? fileURLToPath(resolved) : resolved;
+	}
+	if (path === void 0 || !existsSync(path)) throw new Error(`prosary: \`build\` ${JSON.stringify(build)} could not be found from ${root}`);
+	const directory = statSync(path).isFile() ? dirname(path) : path;
+	for (const entry of ENTRIES) if (!existsSync(join(directory, `${entry}.mjs`))) throw new Error(`prosary: ${directory} is not a kit build — it has no ${entry}.mjs (run \`prosary build\` there first)`);
+	return directory;
+};
+const adopt = (directory) => {
+	return ENTRIES.flatMap((entry) => {
+		const contents = `export * from ${JSON.stringify(join(directory, `${entry}.mjs`))};\n`;
+		return [{
+			path: `${entry}.mjs`,
+			contents
+		}, {
+			path: `${entry}.d.mts`,
+			contents
+		}];
+	});
+};
+const runTranslate = async (translate, options, root, config) => {
+	const logger = useLogger("prosary");
+	const output = await translate({
+		root,
+		config,
+		translate: options
+	});
+	for (const [locale, outcome] of Object.entries(output)) {
+		const { written, rejected, skipped, kept, documents } = outcome;
+		if (written.length + documents.written.length > 0) logger.info(`${locale}: translated ${written.length} messages and ${documents.written.length} documents`);
+		for (const [key, issues] of Object.entries({
+			...rejected,
+			...documents.rejected
+		})) logger.warn(`${locale}: the translation of ${JSON.stringify(key)} was rejected — it ${issues.join("; it ")}`);
+		for (const key of skipped) logger.warn(`${locale}: ${JSON.stringify(key)} came back with no translation`);
+		for (const key of kept) logger.warn(`${locale}: ${JSON.stringify(key)} was written by hand and its source has since changed (kept — delete it to translate again)`);
+	}
+};
+const loadSource = async (options, nuxt) => {
+	const root = nuxt.options.rootDir;
+	if (options.build !== void 0) {
+		const directory = await locate(options.build, root);
+		const content = join(directory, CONTENT);
+		const served = existsSync(content);
+		if (served) assertOutput(await outputOf(directory), `the build at ${directory}`);
+		return {
+			files: adopt(directory),
+			content: served ? content : void 0
+		};
+	}
+	const { FILENAME, emit, loadConfig, resolveKit, translate } = await loadKit();
+	const path = resolve(root, options.config ?? FILENAME);
+	nuxt.options.watch.push(path);
+	if (options.translate !== void 0 && !nuxt.options._prepare) await runTranslate(translate, options.translate, root, path);
+	const kit = await resolveKit(await loadConfig(path), { cwd: root });
+	nuxt.options.watch.push(...kit.inputs);
+	if (kit.documents.length > 0) assertOutput(kit.output, `the kit config at ${path}`);
+	return {
+		files: emit(kit),
+		content: kit.documents.length > 0 ? join(nuxt.options.buildDir, MODULES, CONTENT) : void 0
+	};
+};
+var module_default = defineNuxtModule({
+	meta: {
+		name: "prosary",
+		configKey: "prosary"
+	},
+	setup: async (options, nuxt) => {
+		const resolver = createResolver(import.meta.url);
+		const runtime = (name) => resolver.resolvePath(`./runtime/${name}`);
+		const files = {
+			composable: await runtime("composable"),
+			store: await runtime("store"),
+			types: await runtime("types"),
+			document: await runtime("document"),
+			plugin: await runtime("plugin"),
+			content: await runtime("server/content")
+		};
+		const source = await loadSource(options, nuxt);
+		for (const file of source.files) addTemplate({
+			filename: `${MODULES}/${file.path}`,
+			write: true,
+			getContents: () => file.contents
+		});
+		if (source.content !== void 0) {
+			nuxt.options.nitro.publicAssets ||= [];
+			nuxt.options.nitro.publicAssets.push({
+				dir: source.content,
+				baseURL: CONTENT_URL,
+				maxAge: 0,
+				fallthrough: true
+			});
+			if (nuxt.options.dev) {
+				nuxt.options.nitro.serverAssets ||= [];
+				nuxt.options.nitro.serverAssets.push({
+					baseName: "prosary",
+					dir: source.content
+				});
+				addServerHandler({
+					route: `${CONTENT_URL}/**`,
+					handler: files.content
+				});
+			}
+		}
+		const overrides = resolve(nuxt.options.srcDir, options.components ?? "components/prose");
+		nuxt.options.watch.push(overrides);
+		for (const file of componentsModule(scanOverrides(overrides))) addTemplate({
+			filename: `${MODULES}/${file.path}`,
+			write: true,
+			getContents: () => file.contents
+		});
+		const document = resolve(nuxt.options.buildDir, MODULES, "document");
+		addTemplate({
+			filename: `${MODULES}/document.mjs`,
+			write: true,
+			getContents: () => `export { default } from ${JSON.stringify(files.document)};\n`
+		});
+		addTemplate({
+			filename: `${MODULES}/document.d.ts`,
+			write: true,
+			getContents: () => `export { default } from ${JSON.stringify(files.document.replace(/\.ts$/, ""))};\n`
+		});
+		addComponent({
+			name: "Prose",
+			filePath: `${document}.mjs`
+		});
+		addPlugin({ src: files.plugin });
+		addImports([
+			...[
+				"useProsary",
+				"useT",
+				"useLocale",
+				"useDocument"
+			].map((name) => ({
+				from: files.composable,
+				name
+			})),
+			{
+				from: files.store,
+				name: "accessProsary"
+			},
+			...[
+				"AppProsaryContract",
+				"AppProsaryLocale",
+				"AppProsaryKey",
+				"AppProsaryMessage",
+				"AppProsaryDocument",
+				"AppProsaryBundle",
+				"AppProsaryConfig",
+				"AppProsarySelection",
+				"AppProsaryResolver",
+				"AppProsary"
+			].map((name) => ({
+				from: files.types,
+				name,
+				type: true
+			}))
+		]);
+	}
+});
+export { module_default as default };

package/.dist/runtime/client.d.mts

@@ -0,0 +1,23 @@
+import { AppProsary, ProsaryNuxtApp, SetLocale } from "./types.mjs";
+/**
+ * Builds the app's prosary service over reactive state: the selection in
+ * {@link accessProsary}'s `useState`, and the active locale's messages in a
+ * shallow ref this call owns — replaced whole on a switch, never observed in
+ * depth, and never serialized.
+ *
+ * On the server the selection is settled first: the locale from the
+ * visitor's cookie, else the best match for their `Accept-Language`, else
+ * the source locale; the time zone and convention from their cookies when
+ * those still hold. The browser starts from the selection the server
+ * rendered with. Either side then loads that one locale's bundle.
+ *
+ * Every later change is written through to the cookies, so the next request
+ * renders the way the visitor left things.
+ *
+ * @param nuxtApp - The Nuxt app, for its hooks.
+ * @returns The service, and the function that switches locale.
+ */
+export declare const makeProsary: (nuxtApp: ProsaryNuxtApp) => Promise<{
+  service: AppProsary;
+  setLocale: SetLocale;
+}>;

package/.dist/runtime/client.mjs

@@ -0,0 +1,74 @@
+import { negotiate } from "./negotiate.mjs";
+import { onServer } from "./side.mjs";
+import { accessProsary } from "./store.mjs";
+import { shallowRef } from "vue";
+import { useRequestHeaders } from "#imports";
+import { contract } from "#build/prosary/index.mjs";
+import { bundles } from "#build/prosary/bundles.mjs";
+import { defineSchema, makeProsary as makeProsary$1 } from "prosary";
+const makeProsary = async (nuxtApp) => {
+	const { selection, cookies } = accessProsary();
+	const schema = defineSchema(contract);
+	if (onServer()) {
+		const header = useRequestHeaders(["accept-language"])["accept-language"];
+		const { locale, timeZone, convention } = cookies;
+		selection.value = {
+			locale: schema.check.locale(locale.value) ? locale.value : negotiate(header, contract.locales) ?? contract.locale,
+			...schema.check.timeZone(timeZone.value) ? { timeZone: timeZone.value } : {},
+			...schema.check.convention(convention.value) ? { convention: convention.value } : {}
+		};
+	}
+	const messages = shallowRef(await bundles[selection.value.locale]());
+	const service = makeProsary$1(contract, {
+		get locale() {
+			return selection.value.locale;
+		},
+		set locale(value) {
+			selection.value.locale = value;
+		},
+		get messages() {
+			return messages.value;
+		},
+		set messages(value) {
+			messages.value = value;
+		},
+		get timeZone() {
+			return selection.value.timeZone;
+		},
+		set timeZone(value) {
+			selection.value.timeZone = value;
+		},
+		get convention() {
+			return selection.value.convention;
+		},
+		set convention(value) {
+			selection.value.convention = value;
+		}
+	}, { set: { config: {
+		locale: (locale) => {
+			cookies.locale.value = locale;
+			nuxtApp.callHook("prosary:locale", locale);
+			return locale;
+		},
+		timeZone: (timeZone) => {
+			cookies.timeZone.value = timeZone ?? null;
+			return timeZone;
+		},
+		convention: (convention) => {
+			cookies.convention.value = convention ?? null;
+			return convention;
+		}
+	} } });
+	let latest = 0;
+	const setLocale = async (locale) => {
+		schema.assert.locale(locale);
+		const call = ++latest;
+		const bundle = await bundles[locale]();
+		if (call === latest) service.apply(locale, bundle);
+	};
+	return {
+		service,
+		setLocale
+	};
+};
+export { makeProsary };

package/.dist/runtime/composable.d.mts

@@ -0,0 +1,40 @@
+import { AppProsary, AppProsaryDocument, AppProsaryLocale, AppProsaryResolver, SetLocale } from "./types.mjs";
+import { Root } from "../_chunks/libs/@types/hast.mjs";
+import { ComputedRef } from "vue";
+/**
+ * Composable for the app's prosary service: the formatting helpers
+ * (`number`, `date`, `time`, `relative`, `list`, `name`), the time zone and
+ * convention, and the raw state. Everything it reads is reactive, so a
+ * template that calls it re-renders when the locale, time zone or convention
+ * changes.
+ */
+export declare const useProsary: () => AppProsary;
+/**
+ * Composable for the app's messages as functions — the same object templates
+ * reach as `$t`: `t.greeting({ name })`, or by key, `t("greeting", { name })`.
+ * An `AppProsaryMessage` held as data goes in whole: `t(message)`. Each call formats in the locale active at that moment.
+ */
+export declare const useT: () => AppProsaryResolver;
+/**
+ * Composable for the locale: the active one, the ones the app is built for,
+ * and the switch. `setLocale` loads the locale's bundle before anything
+ * changes, so the page never renders a locale it does not hold.
+ */
+export declare const useLocale: () => {
+  locale: ComputedRef<AppProsaryLocale>;
+  locales: readonly AppProsaryLocale[];
+  setLocale: SetLocale;
+};
+/**
+ * Composable for one content document, as its HTML syntax tree, in the
+ * active locale. The tree is fetched as the JSON file the build wrote for
+ * that locale — the server render includes it, and a locale switch fetches
+ * the other locale's copy.
+ *
+ * @param path - The document's path under the content directory.
+ */
+export declare const useDocument: (path: AppProsaryDocument) => Promise<{
+  data: import("vue").Ref<Root | undefined, Root | undefined>;
+}> & {
+  data: import("vue").Ref<Root | undefined, Root | undefined>;
+};

package/.dist/runtime/composable.mjs

@@ -0,0 +1,27 @@
+import { CONTENT_URL } from "../constant.mjs";
+import { computed } from "vue";
+import { useAsyncData, useRequestFetch } from "#imports";
+import { useNuxtApp } from "#app";
+const useProsary = () => {
+	const { $prosary } = useNuxtApp();
+	return $prosary;
+};
+const useT = () => {
+	const { $t } = useNuxtApp();
+	return $t;
+};
+const useLocale = () => {
+	const { $prosary, $setLocale } = useNuxtApp();
+	return {
+		locale: computed(() => $prosary.config.locale),
+		locales: $prosary.locales(),
+		setLocale: $setLocale
+	};
+};
+const useDocument = (path) => {
+	const { $prosary } = useNuxtApp();
+	const request = useRequestFetch();
+	const file = path.replace(/\.md$/, ".json");
+	return useAsyncData(`prosary:document:${path}`, () => request(`${CONTENT_URL}/${$prosary.config.locale}/${file}`, { responseType: "json" }), { watch: [() => $prosary.config.locale] });
+};
+export { useDocument, useLocale, useProsary, useT };

package/.dist/runtime/document.d.mts

@@ -0,0 +1,21 @@
+import { Root } from "../_chunks/libs/@types/hast.mjs";
+import { PropType } from "vue";
+/**
+ * Renders a content document with the app's overrides: `ProsaryDocument`
+ * of `@prosary/vue`, given the component map built from the overrides
+ * directory. Takes the tree `useDocument` loads.
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  tree: {
+    type: PropType<Root>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  tree: {
+    type: PropType<Root>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export { _default as default };

package/.dist/runtime/document.mjs

@@ -0,0 +1,15 @@
+import { defineComponent, h } from "vue";
+import { ProsaryDocument } from "@prosary/vue";
+import { components } from "#build/prosary/components.mjs";
+var document_default = defineComponent({
+	name: "Prose",
+	props: { tree: {
+		type: Object,
+		required: true
+	} },
+	setup: (props) => () => h(ProsaryDocument, {
+		tree: props.tree,
+		components
+	})
+});
+export { document_default as default };

package/.dist/runtime/negotiate.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Picks the locale an `Accept-Language` header asks for, from the ones the
+ * app is built for. The header's tags are tried in the order the visitor
+ * ranks them: an exact match first, then a locale in the same language
+ * (`pt-PT` is served `pt-BR` before a lower-ranked language is tried).
+ *
+ * @param header - The `Accept-Language` header, if the request sent one.
+ * @param locales - The locales the app is built for.
+ * @returns The best match, or `undefined` when nothing the visitor asks for
+ * is available.
+ */
+export declare const negotiate: <L extends string>(header: string | undefined, locales: readonly L[]) => L | undefined;

package/.dist/runtime/negotiate.mjs

@@ -0,0 +1,21 @@
+const language = (tag) => {
+	return (tag.split("-")[0] ?? tag).toLowerCase();
+};
+const negotiate = (header, locales) => {
+	if (header === void 0) return;
+	const wanted = header.split(",").map((part) => {
+		const [tag = "", ...params] = part.trim().split(";");
+		const quality = params.map((param) => /^\s*q=([0-9.]+)\s*$/.exec(param)?.[1]).find((value) => value !== void 0);
+		return {
+			tag: tag.trim().toLowerCase(),
+			quality: quality === void 0 ? 1 : Number(quality)
+		};
+	}).filter(({ tag, quality }) => tag !== "" && tag !== "*" && quality > 0).sort((a, b) => b.quality - a.quality);
+	for (const { tag } of wanted) {
+		const exact = locales.find((locale) => locale.toLowerCase() === tag);
+		if (exact !== void 0) return exact;
+		const related = locales.find((locale) => language(locale) === language(tag));
+		if (related !== void 0) return related;
+	}
+};
+export { negotiate };

package/.dist/runtime/plugin.d.mts

@@ -0,0 +1,22 @@
+import { AppProsary, SetLocale } from "./types.mjs";
+/**
+ * Nuxt plugin that builds the prosary service over reactive, per-request
+ * state and provides it as `$prosary`, with its messages as `$t` and the
+ * locale switch as `$setLocale`.
+ *
+ * The visitor's selection is held in {@link useState} so the browser starts
+ * from the locale the server rendered with; the plugin awaits that locale's
+ * bundle before the app renders, on both sides, so the first render and the
+ * hydration read the same messages. The active locale is mirrored onto the
+ * document root as `lang` and `dir`, and follows every switch.
+ */
+declare const _default: import("#app").Plugin<{
+  prosary: AppProsary;
+  t: import("prosary").Resolver<import("#build/prosary/index.mjs").Contract>;
+  setLocale: SetLocale;
+}> & import("#app").ObjectPlugin<{
+  prosary: AppProsary;
+  t: import("prosary").Resolver<import("#build/prosary/index.mjs").Contract>;
+  setLocale: SetLocale;
+}>;
+export { _default as default };

package/.dist/runtime/plugin.mjs

@@ -0,0 +1,29 @@
+import { makeProsary } from "./client.mjs";
+import { computed } from "vue";
+import { useHead } from "#imports";
+import { defineNuxtPlugin } from "#app";
+const direction = (locale) => {
+	try {
+		const info = new Intl.Locale(locale);
+		return (info.getTextInfo?.() ?? info.textInfo)?.direction ?? "ltr";
+	} catch {
+		return "ltr";
+	}
+};
+var plugin_default = defineNuxtPlugin({
+	name: "prosary",
+	setup: async (nuxtApp) => {
+		const { service, setLocale } = await makeProsary(nuxtApp);
+		useHead({ htmlAttrs: {
+			lang: computed(() => service.config.locale),
+			dir: computed(() => direction(service.config.locale))
+		} });
+		await nuxtApp.callHook("prosary:ready", service);
+		return { provide: {
+			prosary: service,
+			t: service.createResolver(),
+			setLocale
+		} };
+	}
+});
+export { plugin_default as default };

package/.dist/runtime/server/content.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Serves the content documents in development, from the server's own
+ * handler. The documents are public assets, which Nitro's dev server serves
+ * to the browser from outside the worker — so a page rendered on the server
+ * in development, fetching its document from inside the worker, would get a
+ * 404. This handler answers that fetch from the same directory, mounted as a
+ * server asset. A production build has no need of it: there the static
+ * handler serves the assets to every fetch.
+ */
+declare const _default: (event: import("#imports").H3Event) => Promise<{} | undefined>;
+export { _default as default };

package/.dist/runtime/server/content.mjs

@@ -0,0 +1,8 @@
+import { createError, defineEventHandler, getRouterParam, useStorage } from "#imports";
+var content_default = defineEventHandler(async (event) => {
+	const path = getRouterParam(event, "_") ?? "";
+	const document = await useStorage("assets:prosary").getItem(path);
+	if (document === null) throw createError({ statusCode: 404 });
+	return document;
+});
+export { content_default as default };