@secorto/i18n 0.0.4

package/README.md

@@ -0,0 +1,12 @@
+# @secorto/i18n
+
+Reusable building blocks for multilingual content systems.
+
+## Goals
+
+- Framework-agnostic core.
+- Build-time validation.
+- Translation-aware content navigation.
+- Localized tags.
+- Astro adapters.
+- Documentation-first architecture.

package/dist/index.d.mts

@@ -0,0 +1,299 @@
+//#region src/core/locale.d.ts
+interface Locales<L extends string> {
+  readonly all: readonly L[];
+  fromString(lang: string | undefined): L;
+  isValid(lang: string): lang is L;
+}
+declare function createLocales<L extends string>(locales: readonly L[]): Locales<L>;
+//#endregion
+//#region src/core/translationLink.d.ts
+/**
+ * Represents a translation that is available and can be accessed by users.
+ */
+type AvailableLink<L extends string> = {
+  type: 'available';
+  href: string;
+  locale: L;
+};
+/**
+ * Represents a translation that does not exist for the given locale.
+ */
+type MissingLink<L extends string> = {
+  type: 'missing';
+  href: null;
+  locale: L;
+};
+/**
+ * Represents a translation that exists as a draft but is not yet publicly available.
+ */
+type DraftLink<L extends string> = {
+  type: 'draft';
+  href: string;
+  locale: L;
+};
+/**
+ * Represents the state of a translation for a locale.
+ */
+type TranslationLink<L extends string> = AvailableLink<L> | MissingLink<L> | DraftLink<L>;
+/**
+ * Represents a translation link that can be accessed, either as a published
+ * translation (`available`) or as a draft (`draft`).
+ */
+type AccessibleTranslationLink<L extends string> = AvailableLink<L> | DraftLink<L>;
+/**
+ * Creates an available translation link.
+ */
+declare function availableLink<L extends string>(href: string, lang: L): AvailableLink<L>;
+/**
+ * Creates a missing translation link.
+ */
+declare function missingLink<L extends string>(lang: L): MissingLink<L>;
+/**
+ * Creates a draft translation link.
+ */
+declare function draftLink<L extends string>(href: string, lang: L): DraftLink<L>;
+/** Returns whether the link is accessible. */
+declare function isAccessible<L extends string>(link: TranslationLink<L>): link is AccessibleTranslationLink<L>;
+/** Returns whether the link is available. */
+declare function isAvailable<L extends string>(link: TranslationLink<L>): link is AvailableLink<L>;
+/** Returns whether the link is a draft. */
+declare function isDraft<L extends string>(link: TranslationLink<L>): link is DraftLink<L>;
+/** Returns whether the link is missing. */
+declare function isMissing<L extends string>(link: TranslationLink<L>): link is MissingLink<L>;
+/**
+ * Resolves the default accessible translation link from a collection of links.
+ *
+ * Selection priority:
+ * 1. An `available` link matching `defaultLang`.
+ * 2. The first `available` link.
+ * 3. A `draft` link matching `defaultLang`.
+ * 4. The first `draft` link.
+ *
+ * @template L Type representing the supported locales.
+ * @param links Translation links to evaluate.
+ * @param defaultLang Preferred locale to prioritize during selection.
+ * @returns The selected accessible translation link.
+ *
+ * @throws {Error} If `links` is empty or if no accessible link exists.
+ */
+declare function resolveDefaultAccessibleLink<L extends string>(links: TranslationLink<L>[], defaultLang: L): AccessibleTranslationLink<L>;
+//#endregion
+//#region src/core/standalone.d.ts
+/**
+ * Represents a localized standalone page.
+ */
+interface StandalonePageEntry {
+  /**
+   * Route to the page.
+   */
+  route: string;
+  /**
+   * Indicates whether the page exists only as a draft.
+   */
+  draft?: boolean;
+}
+/**
+ * Maps a page identifier to its localized standalone page entries.
+ *
+ * The first key represents the page identifier and the nested keys represent
+ * locales.
+ */
+type StandalonePageIndex<K extends string, L extends string> = Record<K, Partial<Record<L, StandalonePageEntry>>>;
+/**
+ * Creates translation links for a standalone page.
+ *
+ * Validates that:
+ * - the translation key is indexed
+ * - the current route belongs to the indexed translation group
+ */
+declare function createStandalonePageLinks<L extends string>(path: string, translationKey: string, index: StandalonePageIndex<string, L>, locales: Locales<L>): TranslationLink<L>[];
+//#endregion
+//#region src/core/extract-id.d.ts
+/**
+ * Extracts the locale and cleanId from an entryId of the form "es/my-post".
+ * Locale validation is delegated to the Locales value object.
+ *
+ * @param entryId Raw entry identifier (e.g., "es/my-post")
+ * @param locales Locales value object created via createLocales()
+ * @returns An object containing the validated locale and cleanId
+ * @throws Error if the entryId is malformed or the locale is invalid
+ */
+declare function extractCleanId<L extends string>(entryId: string, locales: Locales<L>): {
+  locale: L;
+  id: string;
+};
+//#endregion
+//#region src/section/routes.d.ts
+type SectionDictionary<Section extends string, Language extends string, TValue> = Record<Section, Record<Language, TValue>>;
+/**
+ * Value object that encapsulates localized slugs per section and exposes
+ * a stable API for building localized URLs.
+ *
+ * Invariants:
+ * - Each (locale, slug) pair must be unique across all sections.
+ * - The object is constructed exclusively through `createSectionRoutes`.
+ *
+ * @template Section - Section keys (e.g., 'blog', 'talk').
+ * @template Language - Locale keys (e.g., 'es', 'en').
+ */
+interface SectionRoutes<Section extends string, Language extends string> {
+  /**
+   * Raw dictionary of localized slugs per section.
+   * This structure is immutable once the value object is created.
+   */
+  readonly routes: Record<Section, Record<Language, string>>;
+  /**
+   * Returns the configured section identifiers.
+   */
+  getSections(): Section[];
+  /**
+   * Returns the localized slug for a section.
+   *
+   * @param section Section identifier.
+   * @param locale Locale identifier.
+   * @returns Localized slug for the section.
+   */
+  getSectionRoute(section: Section, locale: Language): string;
+  /**
+   * Returns the localized URL for a section, including locale prefix.
+   *
+   * @param section Section identifier.
+   * @param locale Locale identifier.
+   * @returns URL string for the section in the given locale.
+   */
+  getSectionURL(section: Section, locale: Language): string;
+  /**
+   * Returns the localized URL for a content entry inside a section.
+   *
+   * @param section Section identifier.
+   * @param locale Locale identifier.
+   * @param slug Entry slug.
+   * @returns Full URL for the entry.
+   */
+  getEntryURL(section: Section, locale: Language, slug: string): string;
+}
+/**
+ * Constructs a nominal SectionRoutes value from a raw SectionDictionary.
+ *
+ * This function enforces the domain invariants for localized section routes:
+ * - each (locale, slug) pair must be unique across all sections
+ * - the resulting value is branded as 'SectionRoutes'
+ *
+ * If any invariant is violated, an error is thrown and the SectionRoutes value
+ * is not constructed.
+ *
+ * @template Section - The section keys (e.g., 'blog', 'docs').
+ * @template Language - The language codes (e.g., 'es', 'en').
+ * @param routes Raw dictionary of localized slugs per section.
+ * @returns A branded SectionRoutes value.
+ */
+declare function createSectionRoutes<Section extends string, Language extends string>(routes: SectionDictionary<Section, Language, string>): SectionRoutes<Section, Language>;
+//#endregion
+//#region src/section/translation-index.d.ts
+/**
+ * Represents a localized entry in the translation system.
+ * @template E - The type of the content (e.g., { title: string, body: string }).
+ * @template C - The section of the application (e.g., 'blog', 'docs').
+ * @template L - The language code (e.g., 'es', 'en').
+ */
+interface LocalizedEntry<TEntry, L extends string> {
+  cleanId: string;
+  translationKey: string;
+  locale: L;
+  draft: boolean;
+  original: TEntry;
+}
+/**
+ * Represents a translation index that groups localized entries by their translation key and locale.
+ * @template L - The type of the language code (e.g., 'es', 'en').
+ * @template E - The type of the content (e.g., { title: string, body: string }).
+ * @template C - The section of the application (e.g., 'blog', 'docs').
+ */
+type TranslationIndex<L extends string, TEntry> = Record<string, Partial<Record<L, LocalizedEntry<TEntry, L>>>>;
+/**
+ * Builds a translation index from an array of localized entries.
+ * The index groups entries by their translation key and locale.
+ * If duplicate entries for the same translation key and locale are found, an error is thrown.
+ * @template E - The type of the content (e.g., { title: string, body: string }).
+ * @template C - The section of the application (e.g., 'blog', 'docs').
+ * @template L - The language code (e.g., 'es', 'en').
+ * @param entries Entries to index
+ * @returns The translation index, grouped by translation key and locale
+ * @throws Error if duplicate entries for the same translation key and locale are found
+ */
+declare function createTranslationIndex<L extends string, TEntry>(entries: readonly LocalizedEntry<TEntry, L>[]): TranslationIndex<L, TEntry>;
+//#endregion
+//#region src/section/entry-adapter.d.ts
+interface GenericCollectionEntry<C extends string, TData> {
+  id: string;
+  collection: C;
+  data: TData;
+}
+declare function resolveTranslationKey<T extends object>(data: T, cleanId: string): string;
+/**
+ * Converts a collection entry into a localized entry.
+ *
+ * Extracts the locale and clean ID from the entry ID and resolves the
+ * translation key used to group translations of the same content.
+ *
+ * @param entry Collection entry to adapt.
+ * @param locales Supported locales used to parse the entry ID.
+ * @returns The corresponding localized entry.
+ */
+declare function adaptToLocalizedEntry<C extends string, T extends object, L extends string, TEntry extends GenericCollectionEntry<C, T>>(entry: TEntry, locales: Locales<L>): LocalizedEntry<TEntry, L>;
+//#endregion
+//#region src/section/detail-path.d.ts
+type DetailPath<C extends string, L extends string, TEntry extends GenericCollectionEntry<C, object>> = {
+  params: {
+    locale: L;
+    section: string;
+    id: string;
+  };
+  props: {
+    entry: LocalizedEntry<TEntry, L>;
+    section: C;
+    siblings: TranslationIndex<L, TEntry>[string];
+  };
+};
+/**
+ * Generates the static path definitions required to build localized detail pages
+ * for all entries across all configured sections.
+ *
+ * For each section defined in `routes`, this function:
+ * 1. Fetches the collection entries.
+ * 2. Adapts them into localized entries.
+ * 3. Groups translations by translation key.
+ * 4. Produces one path per localized entry, including its translation siblings.
+ *
+ * The resulting paths can be consumed by static site generators to create
+ * localized detail pages with access to the current entry and all of its
+ * translations.
+ *
+ * @template TEntry Entry type returned by the collection loader.
+ * @template E Entry data type.
+ * @template C Section identifiers (for example: `'blog' | 'docs'`).
+ * @template L Locale identifiers (for example: `'en' | 'es'`).
+ *
+ * @param routes Localized section routes used to resolve URL segments.
+ * @param fetchCollection Function that retrieves all entries belonging
+ * to a given section.
+ * @param allowedLocales Supported locales
+ */
+declare function getStaticPathsEntries<C extends string, E extends object, L extends string, TEntry extends GenericCollectionEntry<C, E>>(routes: SectionRoutes<C, L>, fetchCollection: (collection: C) => Promise<TEntry[]>, allowedLocales: Locales<L>): Promise<DetailPath<C, L, TEntry>[]>;
+//#endregion
+//#region src/section/details-links.d.ts
+/**
+ * Creates translation links for all supported locales.
+ *
+ * Existing translations are returned as `available` links. Missing
+ * translations are represented as `missing` links. The output preserves
+ * the order defined by `locales.all`.
+ *
+ * @param siblings Available translations indexed by locale.
+ * @param sectionRoutes Routes used to build localized URLs.
+ * @param locales Supported locales.
+ * @returns One translation link per supported locale.
+ */
+declare function createDetailTranslationLinks<C extends string, L extends string, TEntry extends GenericCollectionEntry<C, object>>(siblings: Partial<Record<L, LocalizedEntry<TEntry, L>>>, sectionRoutes: SectionRoutes<C, L>, locales: Locales<L>): TranslationLink<L>[];
+//#endregion
+export { AccessibleTranslationLink, AvailableLink, DetailPath, DraftLink, GenericCollectionEntry, Locales, LocalizedEntry, MissingLink, SectionDictionary, SectionRoutes, StandalonePageEntry, StandalonePageIndex, TranslationIndex, TranslationLink, adaptToLocalizedEntry, availableLink, createDetailTranslationLinks, createLocales, createSectionRoutes, createStandalonePageLinks, createTranslationIndex, draftLink, extractCleanId, getStaticPathsEntries, isAccessible, isAvailable, isDraft, isMissing, missingLink, resolveDefaultAccessibleLink, resolveTranslationKey };

package/dist/index.mjs

@@ -0,0 +1,304 @@
+//#region src/core/locale.ts
+function isLocale(locales, lang) {
+	return locales.includes(lang);
+}
+function createLocales(locales) {
+	return {
+		all: locales,
+		fromString(lang) {
+			if (!lang) throw new TypeError(`Invalid language: ${lang}`);
+			if (isLocale(locales, lang)) return lang;
+			throw new TypeError(`Invalid language: ${lang}`);
+		},
+		isValid(lang) {
+			return isLocale(locales, lang);
+		}
+	};
+}
+//#endregion
+//#region src/core/translationLink.ts
+/**
+* Creates an available translation link.
+*/
+function availableLink(href, lang) {
+	return {
+		type: "available",
+		href,
+		locale: lang
+	};
+}
+/**
+* Creates a missing translation link.
+*/
+function missingLink(lang) {
+	return {
+		type: "missing",
+		href: null,
+		locale: lang
+	};
+}
+/**
+* Creates a draft translation link.
+*/
+function draftLink(href, lang) {
+	return {
+		type: "draft",
+		href,
+		locale: lang
+	};
+}
+/** Returns whether the link is accessible. */
+function isAccessible(link) {
+	return link.type === "available" || link.type === "draft";
+}
+/** Returns whether the link is available. */
+function isAvailable(link) {
+	return link.type === "available";
+}
+/** Returns whether the link is a draft. */
+function isDraft(link) {
+	return link.type === "draft";
+}
+/** Returns whether the link is missing. */
+function isMissing(link) {
+	return link.type === "missing";
+}
+/**
+* Resolves the default accessible translation link from a collection of links.
+*
+* Selection priority:
+* 1. An `available` link matching `defaultLang`.
+* 2. The first `available` link.
+* 3. A `draft` link matching `defaultLang`.
+* 4. The first `draft` link.
+*
+* @template L Type representing the supported locales.
+* @param links Translation links to evaluate.
+* @param defaultLang Preferred locale to prioritize during selection.
+* @returns The selected accessible translation link.
+*
+* @throws {Error} If `links` is empty or if no accessible link exists.
+*/
+function resolveDefaultAccessibleLink(links, defaultLang) {
+	if (!links || links.length === 0) throw new Error("resolveDefaultAccessibleLink: unexpected empty links array");
+	const defaultAny = links.find((l) => l.locale === defaultLang);
+	if (defaultAny && isAvailable(defaultAny)) return defaultAny;
+	const firstAvailable = links.find(isAvailable);
+	if (firstAvailable) return firstAvailable;
+	if (defaultAny && isDraft(defaultAny)) return defaultAny;
+	const firstDraft = links.find(isDraft);
+	if (firstDraft) return firstDraft;
+	throw new Error("resolveDefaultAccessibleLink: expected at least one accessible link");
+}
+//#endregion
+//#region src/core/extract-id.ts
+/**
+* Extracts the locale and cleanId from an entryId of the form "es/my-post".
+* Locale validation is delegated to the Locales value object.
+*
+* @param entryId Raw entry identifier (e.g., "es/my-post")
+* @param locales Locales value object created via createLocales()
+* @returns An object containing the validated locale and cleanId
+* @throws Error if the entryId is malformed or the locale is invalid
+*/
+function extractCleanId(entryId, locales) {
+	if (!entryId) throw new Error("entryId cannot be empty");
+	const firstSlash = entryId.indexOf("/");
+	if (firstSlash <= 0) throw new Error(`Invalid entryId "${entryId}" — missing locale prefix`);
+	const rawLocale = entryId.slice(0, firstSlash);
+	if (!locales.isValid(rawLocale)) throw new Error(`Invalid entryId "${entryId}". Unknown locale prefix "${rawLocale}". Expected one of: ${locales.all.join(", ")}.`);
+	return {
+		locale: rawLocale,
+		id: entryId.slice(firstSlash + 1)
+	};
+}
+//#endregion
+//#region src/core/standalone.ts
+/**
+* Creates translation links for a standalone page.
+*
+* Validates that:
+* - the translation key is indexed
+* - the current route belongs to the indexed translation group
+*/
+function createStandalonePageLinks(path, translationKey, index, locales) {
+	const { locale: currentLocale, id: currentRoute } = extractCleanId(path, locales);
+	const group = index[translationKey];
+	if (!group) throw new Error(`Standalone page '${translationKey}' is not indexed.`);
+	const currentEntry = group[currentLocale];
+	if (!currentEntry) throw new Error(`Standalone page '${translationKey}' has no entry for locale '${currentLocale}'.`);
+	if (currentEntry.route !== currentRoute) throw new Error(`Route '${path}' does not belong to standalone page '${translationKey}'.`);
+	return locales.all.map((locale) => {
+		const entry = group[locale];
+		if (!entry) return missingLink(locale);
+		const href = `/${locale}/${entry.route}`;
+		if (entry.draft) return draftLink(href, locale);
+		return availableLink(href, locale);
+	});
+}
+//#endregion
+//#region src/section/routes.ts
+/**
+* Constructs a nominal SectionRoutes value from a raw SectionDictionary.
+*
+* This function enforces the domain invariants for localized section routes:
+* - each (locale, slug) pair must be unique across all sections
+* - the resulting value is branded as 'SectionRoutes'
+*
+* If any invariant is violated, an error is thrown and the SectionRoutes value
+* is not constructed.
+*
+* @template Section - The section keys (e.g., 'blog', 'docs').
+* @template Language - The language codes (e.g., 'es', 'en').
+* @param routes Raw dictionary of localized slugs per section.
+* @returns A branded SectionRoutes value.
+*/
+function createSectionRoutes(routes) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const section of Object.keys(routes)) {
+		const localized = routes[section];
+		for (const locale of Object.keys(localized)) {
+			const slug = localized[locale];
+			const key = `${locale}:${slug}`;
+			if (seen.has(key)) {
+				const other = seen.get(key);
+				throw new Error(`Duplicated route for locale "${locale}" and slug "${slug}" between sections "${other}" and "${section}".`);
+			}
+			seen.set(key, section);
+		}
+	}
+	const getSections = () => Object.keys(routes);
+	const getSectionRoute = (section, locale) => routes[section][locale];
+	const getSectionURL = (section, locale) => `/${locale}/${getSectionRoute(section, locale)}`;
+	const getEntryURL = (section, locale, slug) => `${getSectionURL(section, locale)}/${slug}`;
+	return {
+		routes,
+		getSections,
+		getSectionRoute,
+		getSectionURL,
+		getEntryURL
+	};
+}
+//#endregion
+//#region src/section/translation-index.ts
+/**
+* Builds a translation index from an array of localized entries.
+* The index groups entries by their translation key and locale.
+* If duplicate entries for the same translation key and locale are found, an error is thrown.
+* @template E - The type of the content (e.g., { title: string, body: string }).
+* @template C - The section of the application (e.g., 'blog', 'docs').
+* @template L - The language code (e.g., 'es', 'en').
+* @param entries Entries to index
+* @returns The translation index, grouped by translation key and locale
+* @throws Error if duplicate entries for the same translation key and locale are found
+*/
+function createTranslationIndex(entries) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const key = entry.translationKey;
+		const locale = entry.locale;
+		let group = map.get(key);
+		if (!group) {
+			group = {};
+			map.set(key, group);
+		} else if (locale in group) throw new Error(`Duplicate translation for key "${key}" and locale "${locale}"`);
+		group[locale] = entry;
+	}
+	return Object.fromEntries(map);
+}
+//#endregion
+//#region src/section/entry-adapter.ts
+function resolveTranslationKey(data, cleanId) {
+	return "translationKey" in data && typeof data.translationKey === "string" ? data.translationKey : cleanId;
+}
+/**
+* Converts a collection entry into a localized entry.
+*
+* Extracts the locale and clean ID from the entry ID and resolves the
+* translation key used to group translations of the same content.
+*
+* @param entry Collection entry to adapt.
+* @param locales Supported locales used to parse the entry ID.
+* @returns The corresponding localized entry.
+*/
+function adaptToLocalizedEntry(entry, locales) {
+	const { locale, id: cleanId } = extractCleanId(entry.id, locales);
+	const draft = "draft" in entry.data && entry.data.draft === true;
+	return {
+		cleanId,
+		locale,
+		translationKey: resolveTranslationKey(entry.data, cleanId),
+		draft,
+		original: entry
+	};
+}
+//#endregion
+//#region src/section/detail-path.ts
+/**
+* Generates the static path definitions required to build localized detail pages
+* for all entries across all configured sections.
+*
+* For each section defined in `routes`, this function:
+* 1. Fetches the collection entries.
+* 2. Adapts them into localized entries.
+* 3. Groups translations by translation key.
+* 4. Produces one path per localized entry, including its translation siblings.
+*
+* The resulting paths can be consumed by static site generators to create
+* localized detail pages with access to the current entry and all of its
+* translations.
+*
+* @template TEntry Entry type returned by the collection loader.
+* @template E Entry data type.
+* @template C Section identifiers (for example: `'blog' | 'docs'`).
+* @template L Locale identifiers (for example: `'en' | 'es'`).
+*
+* @param routes Localized section routes used to resolve URL segments.
+* @param fetchCollection Function that retrieves all entries belonging
+* to a given section.
+* @param allowedLocales Supported locales
+*/
+async function getStaticPathsEntries(routes, fetchCollection, allowedLocales) {
+	const allPaths = [];
+	for (const sectionKey of routes.getSections()) {
+		const localizedEntries = (await fetchCollection(sectionKey)).map((entry) => adaptToLocalizedEntry(entry, allowedLocales));
+		const index = createTranslationIndex(localizedEntries);
+		for (const localized of localizedEntries) allPaths.push({
+			params: {
+				locale: localized.locale,
+				section: routes.getSectionRoute(sectionKey, localized.locale),
+				id: localized.cleanId
+			},
+			props: {
+				entry: localized,
+				section: sectionKey,
+				siblings: index[localized.translationKey]
+			}
+		});
+	}
+	return allPaths;
+}
+//#endregion
+//#region src/section/details-links.ts
+/**
+* Creates translation links for all supported locales.
+*
+* Existing translations are returned as `available` links. Missing
+* translations are represented as `missing` links. The output preserves
+* the order defined by `locales.all`.
+*
+* @param siblings Available translations indexed by locale.
+* @param sectionRoutes Routes used to build localized URLs.
+* @param locales Supported locales.
+* @returns One translation link per supported locale.
+*/
+function createDetailTranslationLinks(siblings, sectionRoutes, locales) {
+	return locales.all.map((locale) => {
+		const sibling = siblings[locale];
+		if (!sibling) return missingLink(locale);
+		const href = sectionRoutes.getEntryURL(sibling.original.collection, locale, sibling.cleanId);
+		return sibling.draft ? draftLink(href, locale) : availableLink(href, locale);
+	});
+}
+//#endregion
+export { adaptToLocalizedEntry, availableLink, createDetailTranslationLinks, createLocales, createSectionRoutes, createStandalonePageLinks, createTranslationIndex, draftLink, extractCleanId, getStaticPathsEntries, isAccessible, isAvailable, isDraft, isMissing, missingLink, resolveDefaultAccessibleLink, resolveTranslationKey };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@secorto/i18n",
+  "version": "0.0.4",
+  "private": false,
+  "sideEffects": false,
+  "description": "Framework-agnostic i18n primitive",
+  "keywords": [
+    "steps",
+    "playwright",
+    "testing"
+  ],
+  "homepage": "https://github.com/secorto/secorto_web/blob/master/packages/i18n#readme",
+  "bugs": {
+    "url": "https://github.com/secorto/secorto_web/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/secorto/secorto_web.git"
+  },
+  "license": "MIT",
+  "author": "Sergio Carlos Orozco Torres",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./core": {
+      "types": "./src/core/index.ts",
+      "import": "./dist/core/index.mjs",
+      "default": "./dist/core/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./src/index.ts",
+  "directories": {
+    "test": "tests"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rimraf dist",
+    "test": "vitest --run",
+    "test:unit": "vitest",
+    "test:unit:watch": "vitest --watch"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.10"
+  },
+  "tsdown": {
+    "entry": [
+      "src/index.ts"
+    ]
+  }
+}