vanilla-intlayer 8.5.0

package/dist/types/client/useLocaleStorage.d.ts

@@ -0,0 +1,31 @@
+import { LocalesValues } from '@intlayer/types/module_augmentation';
+/**
+ * Get the current locale from storage (cookie or localStorage).
+ */
+export declare const localeInStorage: import('intlayer').Locale | undefined;
+/**
+ * @deprecated Use localeInStorage instead.
+ */
+export declare const localeCookie: import('intlayer').Locale | undefined;
+/**
+ * Persist the locale to storage (cookie and/or localStorage).
+ */
+export declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * @deprecated Use setLocaleInStorage instead.
+ */
+export declare const setLocaleCookie: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * Returns the current locale from storage and a setter.
+ */
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+    localeStorage: import('intlayer').Locale;
+    setLocaleStorage: (locale: LocalesValues) => void;
+};
+/**
+ * @deprecated Use useLocaleStorage instead.
+ */
+export declare const useLocaleCookie: (isCookieEnabled?: boolean) => {
+    localeCookie: import('intlayer').Locale;
+    setLocaleCookie: (locale: LocalesValues) => void;
+};

package/dist/types/client/useRewriteURL.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Keep the browser URL in sync with the current locale.
+ *
+ * Rewrites the current URL immediately and subscribes to future locale changes.
+ * Returns an `unsubscribe` function to stop listening.
+ *
+ * Uses `window.history.replaceState` — no full-page navigation.
+ *
+ * @returns A cleanup function that removes the locale change listener.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayer, useRewriteURL } from 'vanilla-intlayer';
+ *
+ * installIntlayer('en');
+ *
+ * const unsubscribe = useRewriteURL();
+ *
+ * // Later, if you want to stop URL rewriting:
+ * unsubscribe();
+ * ```
+ */
+export declare const useRewriteURL: () => (() => void);

package/dist/types/editor/useEditor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Initialises the Intlayer visual editor client.
+ *
+ * Does nothing when `INTLAYER_EDITOR_ENABLED` is `"false"` or the editor
+ * package reports that it is disabled.
+ *
+ * Call this once at application startup.
+ *
+ * @returns A cleanup function that stops the editor.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayer, useEditor } from 'vanilla-intlayer';
+ *
+ * installIntlayer('en');
+ * const stopEditor = useEditor();
+ * ```
+ */
+export declare const useEditor: () => (() => void);

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

@@ -0,0 +1 @@
+export * from './useIntl';

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

@@ -0,0 +1,31 @@
+import { WrappedIntl } from '@intlayer/core/utils';
+import { LocalesValues } from '@intlayer/types/module_augmentation';
+/**
+ * Get a locale-bound `Intl` object and subscribe to locale changes.
+ *
+ * The returned `intl` property acts like the native `Intl` namespace but
+ * automatically uses the current application locale, so you do not need to
+ * pass the locale manually to `NumberFormat`, `DateTimeFormat`, etc.
+ *
+ * @param locale - Optional locale override.
+ * @returns An object with `intl: WrappedIntl` and a `subscribe` function.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayer, useIntl } from 'vanilla-intlayer';
+ *
+ * installIntlayer('en');
+ *
+ * const { intl, subscribe } = useIntl();
+ *
+ * console.log(new intl.NumberFormat({ style: 'currency', currency: 'USD' }).format(9.99));
+ *
+ * const unsubscribe = subscribe((newIntl) => {
+ *   console.log(new newIntl.NumberFormat({ style: 'currency', currency: 'USD' }).format(9.99));
+ * });
+ * ```
+ */
+export declare const useIntl: (locale?: LocalesValues) => {
+    intl: WrappedIntl;
+    subscribe: (callback: (intl: WrappedIntl) => void) => () => void;
+};

package/dist/types/getDictionary.d.ts

@@ -0,0 +1,4 @@
+import { Dictionary } from '@intlayer/types/dictionary';
+import { DeclaredLocales, LocalesValues } from '@intlayer/types/module_augmentation';
+import { DeepTransformContent } from './plugins';
+export declare const getDictionary: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L) => DeepTransformContent<T["content"], L>;

package/dist/types/getIntlayer.d.ts

@@ -0,0 +1,3 @@
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from '@intlayer/types/module_augmentation';
+import { DeepTransformContent } from './plugins';
+export declare const getIntlayer: <T extends DictionaryKeys, L extends LocalesValues = DeclaredLocales>(key: T, locale?: L) => DeepTransformContent<DictionaryRegistryContent<T>, L>;

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

@@ -0,0 +1,14 @@
+import { HTMLComponents } from './types';
+export type RenderHTMLProps = {
+    components?: HTMLComponents<'permissive', {}>;
+};
+/**
+ * Renders an HTML string directly, without a global provider.
+ * Returns the raw string unchanged.
+ */
+export declare const renderHTML: (content: string, _props?: RenderHTMLProps) => string;
+/**
+ * Returns a render function that uses the global provider's configuration
+ * (installed via `installIntlayerHTML`), falling back to identity.
+ */
+export declare const useHTMLRenderer: ({ components, }?: RenderHTMLProps) => ((content: string) => string);

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

@@ -0,0 +1,3 @@
+export { type RenderHTMLProps, renderHTML, useHTMLRenderer, } from './HTMLRenderer';
+export { type IntlayerHTMLPluginOptions, type IntlayerHTMLProvider, installIntlayerHTML, installIntlayerHTMLDynamic, type RenderHTMLFunction, type RenderHTMLOptions, useHTML, } from './installIntlayerHTML';
+export type { HTMLComponents } from './types';

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

@@ -0,0 +1,62 @@
+import { HTMLComponents } from './types';
+export type RenderHTMLOptions = {
+    components?: HTMLComponents<'permissive', {}>;
+};
+export type RenderHTMLFunction = (html: string, overrides?: HTMLComponents<'permissive', {}> | RenderHTMLOptions) => string;
+export type IntlayerHTMLProvider = {
+    renderHTML: RenderHTMLFunction;
+};
+export type IntlayerHTMLPluginOptions = {
+    components?: HTMLComponents<'permissive', {}>;
+    renderHTML?: RenderHTMLFunction;
+};
+/**
+ * Create and return a single IntlayerHTMLProvider instance.
+ */
+export declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction) => IntlayerHTMLProvider;
+/**
+ * Install the Intlayer HTML provider for your vanilla JS application.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayerHTML } from 'vanilla-intlayer';
+ *
+ * installIntlayerHTML({
+ *   components: {
+ *     a: ({ href, children }) => `<a class="styled-link" href="${href}">${children}</a>`,
+ *   },
+ * });
+ * ```
+ */
+export declare const installIntlayerHTML: (pluginOptions?: IntlayerHTMLPluginOptions | RenderHTMLFunction) => IntlayerHTMLProvider;
+/**
+ * Access the installed IntlayerHTMLProvider.
+ * Returns a fallback renderer that outputs the raw HTML string if no
+ * provider has been installed.
+ */
+export declare const useHTML: () => IntlayerHTMLProvider;
+/**
+ * Asynchronously install an HTML renderer whose implementation is loaded
+ * via a dynamic `import()`.
+ *
+ * Use this to keep a heavy HTML sanitiser / component renderer out of the
+ * initial bundle — the loader is only called the first time this function
+ * is executed.
+ *
+ * The returned promise resolves once the provider is ready. Any calls to
+ * `useHTML()` before the promise resolves will use the fallback (identity)
+ * renderer.
+ *
+ * @param loader - A zero-argument async function that resolves to either a
+ *   `RenderHTMLFunction` or an `IntlayerHTMLPluginOptions` object.
+ *
+ * @example
+ * ```ts
+ * // Load a custom HTML sanitiser only when needed
+ * await installIntlayerHTMLDynamic(async () => {
+ *   const DOMPurify = await import('dompurify');
+ *   return (html) => DOMPurify.sanitize(html);
+ * });
+ * ```
+ */
+export declare const installIntlayerHTMLDynamic: (loader: () => Promise<IntlayerHTMLPluginOptions | RenderHTMLFunction>) => Promise<IntlayerHTMLProvider>;

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

@@ -0,0 +1,42 @@
+import { HTMLTagsType } from '@intlayer/core/transpiler';
+/**
+ * Helper to extract specific props from the configuration value.
+ */
+type PropsFromConfig<Value> = Value extends true ? {} : Value extends object ? Value : {};
+/**
+ * Common props for HTML elements rendered in vanilla JS.
+ * Components receive these as a plain object and return an HTML string.
+ */
+type ElementProps = Record<string, unknown> & {
+    children?: string;
+};
+/**
+ * Vanilla component type — a function that takes props and returns a string of HTML.
+ */
+type VanillaHTMLComponent<P = {}> = (props: P & ElementProps) => string;
+/**
+ * Helper: Defines the mapping for the explicitly listed keys in T.
+ */
+type DefinedComponents<T, IsRequired extends boolean> = IsRequired extends true ? {
+    [K in keyof T]: VanillaHTMLComponent<PropsFromConfig<T[K]>>;
+} : {
+    [K in keyof T]?: VanillaHTMLComponent<PropsFromConfig<T[K]>>;
+};
+/**
+ * Helper: Defines the standard HTML tags NOT listed in T.
+ */
+type RestHTMLComponents<T> = {
+    [K in Exclude<keyof HTMLTagsType, keyof T>]?: VanillaHTMLComponent;
+};
+/**
+ * The supported modes for the HTMLComponents type.
+ */
+export type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+/**
+ * Component map for HTML rendering in vanilla JS.
+ * Each component receives props and children and returns an HTML string.
+ */
+export type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' ? DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' ? DefinedComponents<T, false> & RestHTMLComponents<T> & {
+    [key: string]: VanillaHTMLComponent;
+} : DefinedComponents<T, false> & RestHTMLComponents<T>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+import { LocalesValues } from '@intlayer/types/module_augmentation';
+import { IInterpreterPluginVanilla } from './plugins';
+declare module '@intlayer/core/interpreter' {
+    interface IInterpreterPlugin<T, S, L extends LocalesValues> extends IInterpreterPluginVanilla<T, S, L> {
+    }
+}
+export * from './client';
+export * from './editor/useEditor';
+export * from './format/useIntl';
+export * from './getDictionary';
+export * from './getIntlayer';
+export * from './plugins';

package/dist/types/markdown/MarkdownRenderer.d.ts

@@ -0,0 +1,22 @@
+import { HTMLComponents } from '../html/types';
+import { MarkdownProviderOptions } from './installIntlayerMarkdown';
+export type RenderMarkdownProps = MarkdownProviderOptions & {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: string;
+};
+/**
+ * Renders markdown to an HTML string without using the global provider.
+ *
+ * @example
+ * ```ts
+ * import { renderMarkdown } from 'vanilla-intlayer/markdown';
+ *
+ * document.querySelector('#content').innerHTML = renderMarkdown('# Hello **World**');
+ * ```
+ */
+export declare const renderMarkdown: (content: string, { forceBlock, forceInline, preserveFrontmatter, tagfilter, }?: RenderMarkdownProps) => string;
+/**
+ * Returns a render function that uses the global provider's configuration
+ * (installed via `installIntlayerMarkdown`), falling back to `compileMarkdown`.
+ */
+export declare const useMarkdownRenderer: (props?: RenderMarkdownProps) => ((content: string) => string);

package/dist/types/markdown/compiler.d.ts

@@ -0,0 +1,19 @@
+import { CompileOptions, sanitizer as defaultSanitizer, slugify as defaultSlugify, RuleType } from '@intlayer/core/markdown';
+export { defaultSanitizer as sanitizer, defaultSlugify as slugify, RuleType };
+export type MarkdownCompilerOptions = CompileOptions;
+/**
+ * Compile markdown to an HTML string.
+ *
+ * The resulting string can be inserted into the DOM via `element.innerHTML`
+ * or the `renderMarkdown` helper.
+ *
+ * @example
+ * ```ts
+ * import { compileMarkdown } from 'vanilla-intlayer/markdown';
+ *
+ * document.querySelector('#content').innerHTML = compileMarkdown('# Hello **World**');
+ * ```
+ */
+export declare const compileMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => string;
+export declare const compiler: (markdown?: string, options?: MarkdownCompilerOptions) => string;
+export declare const compile: (markdown?: string, options?: MarkdownCompilerOptions) => string;

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

@@ -0,0 +1,3 @@
+export { compileMarkdown } from './compiler';
+export { type IntlayerMarkdownPluginOptions, type IntlayerMarkdownProvider, installIntlayerMarkdown, installIntlayerMarkdownDynamic, type MarkdownProviderOptions, type RenderMarkdownFunction, useMarkdown, } from './installIntlayerMarkdown';
+export { type RenderMarkdownProps, renderMarkdown, useMarkdownRenderer, } from './MarkdownRenderer';

package/dist/types/markdown/installIntlayerMarkdown.d.ts

@@ -0,0 +1,70 @@
+import { HTMLComponents } from '../html/types';
+export type MarkdownProviderOptions = {
+    /** Forces the compiler to always output content with a block-level wrapper. */
+    forceBlock?: boolean;
+    /** Forces the compiler to always output content with an inline wrapper. */
+    forceInline?: boolean;
+    /** Whether to preserve frontmatter in the markdown content. */
+    preserveFrontmatter?: boolean;
+    /** Whether to use the GitHub Tag Filter. */
+    tagfilter?: boolean;
+};
+export type RenderMarkdownOptions = MarkdownProviderOptions & {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: string;
+};
+export type RenderMarkdownFunction = (markdown: string, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: string) => string | Promise<string>;
+export type IntlayerMarkdownProvider = {
+    components?: HTMLComponents<'permissive', {}>;
+    renderMarkdown: RenderMarkdownFunction;
+};
+export type IntlayerMarkdownPluginOptions = MarkdownProviderOptions & {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: string;
+    renderMarkdown?: RenderMarkdownFunction;
+};
+/**
+ * Create and return a single IntlayerMarkdownProvider instance.
+ */
+export declare const createIntlayerMarkdownClient: (renderMarkdown: RenderMarkdownFunction, components?: HTMLComponents<"permissive", {}>) => IntlayerMarkdownProvider;
+/**
+ * Install the Intlayer Markdown provider for your vanilla JS application.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayerMarkdown } from 'vanilla-intlayer/markdown';
+ *
+ * installIntlayerMarkdown({ forceBlock: true });
+ * ```
+ */
+export declare const installIntlayerMarkdown: (pluginOptions?: IntlayerMarkdownPluginOptions | RenderMarkdownFunction) => IntlayerMarkdownProvider;
+/**
+ * Access the installed IntlayerMarkdownProvider.
+ * Returns a fallback renderer that compiles with default options if no
+ * provider has been installed.
+ */
+export declare const useMarkdown: () => IntlayerMarkdownProvider;
+/**
+ * Asynchronously install a markdown renderer whose implementation is loaded
+ * via a dynamic `import()`.
+ *
+ * Use this to keep the markdown compiler out of the initial bundle — the
+ * loader is only called the first time this function is executed.
+ *
+ * The returned promise resolves once the provider is ready. Any calls to
+ * `useMarkdown()` before the promise resolves will use the fallback
+ * (raw-string) renderer.
+ *
+ * @param loader - A zero-argument async function that resolves to either a
+ *   `RenderMarkdownFunction` or an `IntlayerMarkdownPluginOptions` object.
+ *
+ * @example
+ * ```ts
+ * // Load a custom markdown renderer (e.g. marked) only when needed
+ * await installIntlayerMarkdownDynamic(async () => {
+ *   const { marked } = await import('marked');
+ *   return (markdown) => marked(markdown) as string;
+ * });
+ * ```
+ */
+export declare const installIntlayerMarkdownDynamic: (loader: () => Promise<IntlayerMarkdownPluginOptions | RenderMarkdownFunction>) => Promise<IntlayerMarkdownProvider>;

package/dist/types/markdown/runtime.d.ts

@@ -0,0 +1,12 @@
+import { MarkdownRuntime } from '@intlayer/core/markdown';
+/**
+ * Vanilla-specific MarkdownRuntime that produces HTML strings.
+ */
+export declare const vanillaRuntime: MarkdownRuntime;
+/**
+ * Creates a vanilla runtime with a custom createElement for advanced use cases.
+ */
+export declare const createVanillaRuntime: (options?: {
+    onCreateElement?: (type: any, props: Record<string, any> | null, children: any[]) => string;
+}) => MarkdownRuntime;
+export default vanillaRuntime;

package/dist/types/plugins.d.ts

@@ -0,0 +1,71 @@
+import { DeepTransformContent as DeepTransformContentCore, IInterpreterPluginState as IInterpreterPluginStateCore, Plugins } from '@intlayer/core/interpreter';
+import { DeclaredLocales, LocalesValues } from '@intlayer/types/module_augmentation';
+import { NodeType } from '@intlayer/types/nodeType';
+import { HTMLComponents } from './html/types';
+import { IntlayerNode as IntlayerNodeCore } from './renderIntlayerNode';
+import * as NodeTypes from '@intlayer/types/nodeType';
+/** ---------------------------------------------
+ * INTLAYER NODE PLUGIN
+ * --------------------------------------------- */
+export type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
+export type IntlayerNode<T, P = {}> = IntlayerNodeCore<T> & P;
+export declare const intlayerNodePlugins: Plugins;
+/** ---------------------------------------------
+ * INSERTION PLUGIN
+ * --------------------------------------------- */
+export type InsertionCond<T, _S, L extends LocalesValues> = T extends {
+    nodeType: NodeType | string;
+    [NodeTypes.INSERTION]: infer I;
+    fields: readonly (infer F)[];
+} ? <V extends {
+    [K in Extract<F, string>]: string | number;
+}>(values: V) => I extends string ? IntlayerNode<string> : DeepTransformContent<I, L> : never;
+export declare const insertionPlugin: Plugins;
+/** ---------------------------------------------
+ * MARKDOWN PLUGIN
+ * --------------------------------------------- */
+export type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
+    metadata: DeepTransformContent<string>;
+    /** Returns the raw markdown string; render with compileMarkdown(). */
+    use: (components?: HTMLComponents<'permissive', {}>) => string;
+}> : never;
+export declare const markdownStringPlugin: Plugins;
+export type MarkdownCond<T> = T extends {
+    nodeType: NodeType | string;
+    [NodeTypes.MARKDOWN]: infer M;
+    metadata?: infer U;
+    tags?: infer U;
+} ? {
+    use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<M>;
+    metadata: DeepTransformContent<U>;
+} : never;
+export declare const markdownPlugin: Plugins;
+/** ---------------------------------------------
+ * HTML PLUGIN
+ * --------------------------------------------- */
+export type HTMLPluginCond<T> = T extends {
+    nodeType: NodeType | string;
+    [NodeTypes.HTML]: infer I;
+    tags?: infer U;
+} ? {
+    /** Returns the raw HTML string. */
+    use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<I>;
+} : never;
+export declare const htmlPlugin: Plugins;
+/** ---------------------------------------------
+ * PLUGINS RESULT
+ * --------------------------------------------- */
+export interface IInterpreterPluginVanilla<T, S, L extends LocalesValues> {
+    vanillaIntlayerNode: IntlayerNodeCond<T>;
+    vanillaInsertion: InsertionCond<T, S, L>;
+    vanillaMarkdown: MarkdownCond<T>;
+    vanillaHtml: HTMLPluginCond<T>;
+}
+export type IInterpreterPluginState = Omit<IInterpreterPluginStateCore, 'insertion'> & {
+    vanillaIntlayerNode: true;
+    vanillaInsertion: true;
+    vanillaMarkdown: true;
+    vanillaHtml: true;
+};
+export type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContentCore<T, IInterpreterPluginState, L>;
+export declare const getPlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];

package/dist/types/renderIntlayerNode.d.ts

@@ -0,0 +1,22 @@
+import { ResolvedEditor } from '@intlayer/types/module_augmentation';
+export type IntlayerNode<T = string> = ResolvedEditor<T & {
+    raw: T;
+    value: T;
+    toString: () => string;
+    valueOf: () => T;
+    toJSON: () => T;
+    __update: (next: IntlayerNode<T>) => void;
+}, {
+    raw: T;
+    value: T;
+    toString: () => string;
+    valueOf: () => T;
+    toJSON: () => T;
+    __update: (next: IntlayerNode<T>) => void;
+}>;
+export declare const renderIntlayerNode: <T extends string | number | boolean | null | undefined>({ value, additionalProps, }: {
+    value: T;
+    children?: any;
+    additionalProps?: Record<string, unknown>;
+    [key: string]: unknown;
+}) => IntlayerNode<T>;

package/package.json

@@ -0,0 +1,137 @@
+{
+  "name": "vanilla-intlayer",
+  "version": "8.5.0",
+  "private": false,
+  "description": "Easily internationalize i18n your Vanilla JS, HTML, and PHP applications with type-safe multilingual content management.",
+  "keywords": [
+    "intlayer",
+    "data",
+    "internationalization",
+    "multilingual",
+    "i18n",
+    "typescript",
+    "vanilla",
+    "json"
+  ],
+  "homepage": "https://intlayer.org",
+  "bugs": {
+    "url": "https://github.com/aymericzip/intlayer/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aymericzip/intlayer.git"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Aymeric PINEAU",
+    "url": "https://github.com/aymericzip"
+  },
+  "contributors": [
+    {
+      "name": "Aymeric Pineau",
+      "email": "ay.pineau@gmail.com",
+      "url": "https://github.com/aymericzip"
+    }
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/esm/index.mjs"
+    },
+    "./markdown": {
+      "types": "./dist/types/markdown/index.d.ts",
+      "require": "./dist/cjs/markdown/index.cjs",
+      "import": "./dist/esm/markdown/index.mjs"
+    },
+    "./html": {
+      "types": "./dist/types/html/index.d.ts",
+      "require": "./dist/cjs/html/index.cjs",
+      "import": "./dist/esm/html/index.mjs"
+    },
+    "./format": {
+      "types": "./dist/types/format/index.d.ts",
+      "require": "./dist/cjs/format/index.cjs",
+      "import": "./dist/esm/format/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts"
+      ],
+      "markdown": [
+        "./dist/types/markdown/index.d.ts"
+      ],
+      "html": [
+        "./dist/types/html/index.d.ts"
+      ],
+      "format": [
+        "./dist/types/format/index.d.ts"
+      ],
+      "package.json": [
+        "./package.json"
+      ]
+    }
+  },
+  "files": [
+    "./dist",
+    "./package.json"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "build:ci": "vite build",
+    "clean": "bun --bun rimraf ./dist .turbo",
+    "dev": "vite build --watch",
+    "format": "bun --bun biome format . --check",
+    "format:fix": "bun --bun biome format --write .",
+    "lint": "bun --bun biome lint .",
+    "lint:fix": "bun --bun biome lint --write .",
+    "prepublish": "cp -f ../../README.md ./README.md",
+    "publish": "bun publish || true",
+    "publish:canary": "bun publish --access public --tag canary || true",
+    "publish:latest": "bun publish --access public --tag latest || true",
+    "test": "bun --bun vitest run",
+    "test:watch": "bun --bun vitest",
+    "typecheck": "tsc --noEmit --project tsconfig.types.json"
+  },
+  "dependencies": {
+    "@intlayer/api": "8.5.0",
+    "@intlayer/config": "8.5.0",
+    "@intlayer/core": "8.5.0",
+    "@intlayer/editor": "8.5.0",
+    "@intlayer/types": "8.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.5.0",
+    "@utils/ts-config": "1.0.4",
+    "@utils/ts-config-types": "1.0.4",
+    "@utils/tsdown-config": "1.0.4",
+    "fast-glob": "3.3.3",
+    "rimraf": "6.1.3",
+    "tsdown": "0.21.4",
+    "typescript": "6.0.2",
+    "vite": "8.0.2",
+    "vite-plugin-dts": "4.5.4",
+    "vitest": "4.1.1"
+  },
+  "peerDependencies": {
+    "intlayer": "8.5.0"
+  },
+  "peerDependenciesMeta": {
+    "intlayer": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=14.18"
+  },
+  "bug": {
+    "url": "https://github.com/aymericzip/intlayer/issues"
+  }
+}