svelte-intlayer 5.5.4 → 5.5.6

package/dist/cjs/client/getBrowserLocale.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getBrowserLocale_exports = {};
+__export(getBrowserLocale_exports, {
+  getBrowserLocale: () => getBrowserLocale
+});
+module.exports = __toCommonJS(getBrowserLocale_exports);
+const getBrowserLocale = () => {
+  if (typeof navigator === "undefined") {
+    return "en";
+  }
+  const browserLocale = navigator.language || navigator.languages?.[0];
+  if (!browserLocale) {
+    return "en";
+  }
+  const languageCode = browserLocale.split("-")[0];
+  return languageCode || "en";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBrowserLocale
+});
+//# sourceMappingURL=getBrowserLocale.cjs.map

package/dist/cjs/client/getBrowserLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/getBrowserLocale.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\n\n/**\n * Gets the user's preferred locale from browser settings\n * @returns The detected browser locale or 'en' as fallback\n */\nexport const getBrowserLocale = (): LocalesValues => {\n  if (typeof navigator === 'undefined') {\n    return 'en' as LocalesValues;\n  }\n\n  // Get the first preferred language\n  const browserLocale = navigator.language || navigator.languages?.[0];\n\n  if (!browserLocale) {\n    return 'en' as LocalesValues;\n  }\n\n  // Extract language code (e.g., 'en-US' -> 'en')\n  const languageCode = browserLocale.split('-')[0];\n\n  return (languageCode || 'en') as LocalesValues;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,MAAM,mBAAmB,MAAqB;AACnD,MAAI,OAAO,cAAc,aAAa;AACpC,WAAO;AAAA,EACT;AAGA,QAAM,gBAAgB,UAAU,YAAY,UAAU,YAAY,CAAC;AAEnE,MAAI,CAAC,eAAe;AAClB,WAAO;AAAA,EACT;AAGA,QAAM,eAAe,cAAc,MAAM,GAAG,EAAE,CAAC;AAE/C,SAAQ,gBAAgB;AAC1B;","names":[]}

package/dist/cjs/client/index.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  getBrowserLocale: () => import_getBrowserLocale.getBrowserLocale,
+  getIntlayerContext: () => import_intlayerContext.getIntlayerContext,
+  intlayerStore: () => import_intlayerStore.intlayerStore,
+  setIntlayerContext: () => import_intlayerContext.setIntlayerContext,
+  useDictionary: () => import_useDictionary.useDictionary,
+  useDictionaryDynamic: () => import_useDictionaryDynamic.useDictionaryDynamic,
+  useIntlayer: () => import_useIntlayer.useIntlayer,
+  useIntlayerAsync: () => import_useIntlayerAsync.useIntlayerAsync,
+  useLocale: () => import_useLocale.useLocale
+});
+module.exports = __toCommonJS(client_exports);
+var import_useDictionary = require('./useDictionary.cjs');
+var import_useDictionaryDynamic = require('./useDictionaryDynamic.cjs');
+var import_useIntlayer = require('./useIntlayer.cjs');
+var import_useIntlayerAsync = require('./useIntlayerAsync.cjs');
+var import_intlayerContext = require('./intlayerContext.cjs');
+var import_intlayerStore = require('./intlayerStore.cjs');
+var import_getBrowserLocale = require('./getBrowserLocale.cjs');
+var import_useLocale = require('./useLocale.cjs');
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBrowserLocale,
+  getIntlayerContext,
+  intlayerStore,
+  setIntlayerContext,
+  useDictionary,
+  useDictionaryDynamic,
+  useIntlayer,
+  useIntlayerAsync,
+  useLocale
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/client/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/index.ts"],"sourcesContent":["// Export all client-side functionality for Svelte applications\n\n// Core hooks\nexport { useDictionary } from './useDictionary';\nexport { useDictionaryDynamic } from './useDictionaryDynamic';\nexport { useIntlayer } from './useIntlayer';\nexport { useIntlayerAsync } from './useIntlayerAsync';\n\n// Context and providers\nexport { getIntlayerContext, setIntlayerContext } from './intlayerContext';\nexport { intlayerStore } from './intlayerStore';\n\n// Locale management\nexport { getBrowserLocale } from './getBrowserLocale';\nexport { useLocale } from './useLocale';\n\n// Type exports\nexport type { IntlayerStoreType } from './intlayerStore';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,2BAA8B;AAC9B,kCAAqC;AACrC,yBAA4B;AAC5B,8BAAiC;AAGjC,6BAAuD;AACvD,2BAA8B;AAG9B,8BAAiC;AACjC,uBAA0B;","names":[]}

package/dist/cjs/client/intlayerContext.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intlayerContext_exports = {};
+__export(intlayerContext_exports, {
+  getIntlayerContext: () => getIntlayerContext,
+  setIntlayerContext: () => setIntlayerContext
+});
+module.exports = __toCommonJS(intlayerContext_exports);
+var import_svelte = require("svelte");
+const INTLAYER_CONTEXT_KEY = Symbol("intlayer");
+const setIntlayerContext = (context) => {
+  (0, import_svelte.setContext)(INTLAYER_CONTEXT_KEY, context);
+};
+const getIntlayerContext = () => {
+  return (0, import_svelte.getContext)(INTLAYER_CONTEXT_KEY);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getIntlayerContext,
+  setIntlayerContext
+});
+//# sourceMappingURL=intlayerContext.cjs.map

package/dist/cjs/client/intlayerContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/intlayerContext.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport { getContext, setContext } from 'svelte';\n\nexport interface IntlayerContextType {\n  locale: LocalesValues;\n  setLocale: (locale: LocalesValues) => void;\n}\n\nconst INTLAYER_CONTEXT_KEY = Symbol('intlayer');\n\nexport const setIntlayerContext = (context: IntlayerContextType) => {\n  setContext(INTLAYER_CONTEXT_KEY, context);\n};\n\nexport const getIntlayerContext = (): IntlayerContextType | undefined => {\n  return getContext(INTLAYER_CONTEXT_KEY);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAAuC;AAOvC,MAAM,uBAAuB,OAAO,UAAU;AAEvC,MAAM,qBAAqB,CAAC,YAAiC;AAClE,gCAAW,sBAAsB,OAAO;AAC1C;AAEO,MAAM,qBAAqB,MAAuC;AACvE,aAAO,0BAAW,oBAAoB;AACxC;","names":[]}

package/dist/cjs/client/intlayerStore.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intlayerStore_exports = {};
+__export(intlayerStore_exports, {
+  intlayerStore: () => intlayerStore
+});
+module.exports = __toCommonJS(intlayerStore_exports);
+var import_store = require("svelte/store");
+const createIntlayerStore = () => {
+  const { subscribe, set, update } = (0, import_store.writable)({
+    locale: "en"
+    // Default locale
+  });
+  return {
+    subscribe,
+    setLocale: (locale) => update((store) => ({ ...store, locale })),
+    getLocale: () => (0, import_store.derived)({ subscribe }, ($store) => $store.locale),
+    reset: () => set({ locale: "en" })
+  };
+};
+const intlayerStore = createIntlayerStore();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  intlayerStore
+});
+//# sourceMappingURL=intlayerStore.cjs.map

package/dist/cjs/client/intlayerStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/intlayerStore.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport { derived, writable, type Readable, type Writable } from 'svelte/store';\n\nexport interface IntlayerStoreType {\n  locale: LocalesValues;\n}\n\n// Create the main intlayer store\nconst createIntlayerStore = () => {\n  const { subscribe, set, update }: Writable<IntlayerStoreType> = writable({\n    locale: 'en' as LocalesValues, // Default locale\n  });\n\n  return {\n    subscribe,\n    setLocale: (locale: LocalesValues) =>\n      update((store) => ({ ...store, locale })),\n    getLocale: (): Readable<LocalesValues> =>\n      derived({ subscribe }, ($store) => $store.locale),\n    reset: () => set({ locale: 'en' as LocalesValues }),\n  };\n};\n\nexport const intlayerStore = createIntlayerStore();\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAAgE;AAOhE,MAAM,sBAAsB,MAAM;AAChC,QAAM,EAAE,WAAW,KAAK,OAAO,QAAiC,uBAAS;AAAA,IACvE,QAAQ;AAAA;AAAA,EACV,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA,WAAW,CAAC,WACV,OAAO,CAAC,WAAW,EAAE,GAAG,OAAO,OAAO,EAAE;AAAA,IAC1C,WAAW,UACT,sBAAQ,EAAE,UAAU,GAAG,CAAC,WAAW,OAAO,MAAM;AAAA,IAClD,OAAO,MAAM,IAAI,EAAE,QAAQ,KAAsB,CAAC;AAAA,EACpD;AACF;AAEO,MAAM,gBAAgB,oBAAoB;","names":[]}

package/dist/cjs/client/useDictionary.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useDictionary_exports = {};
+__export(useDictionary_exports, {
+  useDictionary: () => useDictionary
+});
+module.exports = __toCommonJS(useDictionary_exports);
+var import_store = require("svelte/store");
+var import_getDictionary = require('../getDictionary.cjs');
+var import_intlayerContext = require('./intlayerContext.cjs');
+var import_intlayerStore = require('./intlayerStore.cjs');
+const useDictionary = (dictionary, locale) => {
+  const context = (0, import_intlayerContext.getIntlayerContext)();
+  return (0, import_store.derived)([import_intlayerStore.intlayerStore], ([$store]) => {
+    const targetLocale = locale ?? context?.locale ?? $store.locale;
+    return (0, import_getDictionary.getDictionary)(dictionary, targetLocale);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDictionary
+});
+//# sourceMappingURL=useDictionary.cjs.map

package/dist/cjs/client/useDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport { type Dictionary } from '@intlayer/core';\nimport { derived, type Readable } from 'svelte/store';\nimport { getDictionary } from '../getDictionary';\nimport { DeepTransformContent } from '../plugins';\nimport { getIntlayerContext } from './intlayerContext';\nimport { intlayerStore } from './intlayerStore';\n\n/**\n * Svelte hook that transforms a dictionary and returns reactive content\n * @param dictionary The dictionary to transform\n * @param locale The target locale (optional, uses context or store locale)\n * @returns Reactive store with transformed dictionary content\n */\nexport const useDictionary = <T extends Dictionary>(\n  dictionary: T,\n  locale?: LocalesValues\n): Readable<DeepTransformContent<T['content']>> => {\n  const context = getIntlayerContext();\n\n  // Create a derived store that reactively updates when locale changes\n  return derived([intlayerStore], ([$store]) => {\n    const targetLocale = locale ?? context?.locale ?? $store.locale;\n    return getDictionary<T, LocalesValues>(dictionary, targetLocale);\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAAuC;AACvC,2BAA8B;AAE9B,6BAAmC;AACnC,2BAA8B;AAQvB,MAAM,gBAAgB,CAC3B,YACA,WACiD;AACjD,QAAM,cAAU,2CAAmB;AAGnC,aAAO,sBAAQ,CAAC,kCAAa,GAAG,CAAC,CAAC,MAAM,MAAM;AAC5C,UAAM,eAAe,UAAU,SAAS,UAAU,OAAO;AACzD,eAAO,oCAAgC,YAAY,YAAY;AAAA,EACjE,CAAC;AACH;","names":[]}

package/dist/cjs/client/useDictionaryDynamic.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useDictionaryDynamic_exports = {};
+__export(useDictionaryDynamic_exports, {
+  useDictionaryDynamic: () => useDictionaryDynamic
+});
+module.exports = __toCommonJS(useDictionaryDynamic_exports);
+var import_store = require("svelte/store");
+var import_intlayerContext = require('./intlayerContext.cjs');
+var import_intlayerStore = require('./intlayerStore.cjs');
+const useDictionaryDynamic = (dictionaryPromise, key, locale) => {
+  const context = (0, import_intlayerContext.getIntlayerContext)();
+  const dictionaryStore = (0, import_store.writable)(null);
+  return (0, import_store.derived)([import_intlayerStore.intlayerStore], ([$store]) => {
+    const targetLocale = locale ?? context?.locale ?? $store.locale;
+    const loadDictionary = async () => {
+      try {
+        const dictionaryLoader = dictionaryPromise[targetLocale];
+        if (dictionaryLoader) {
+          const loadedDictionary = await dictionaryLoader();
+          dictionaryStore.set(loadedDictionary);
+        } else {
+          dictionaryStore.set(null);
+        }
+      } catch (error) {
+        console.error(
+          `Failed to load dictionary for key: ${String(key)}`,
+          error
+        );
+        dictionaryStore.set(null);
+      }
+    };
+    loadDictionary();
+    return null;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDictionaryDynamic
+});
+//# sourceMappingURL=useDictionaryDynamic.cjs.map

package/dist/cjs/client/useDictionaryDynamic.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport type {\n  Dictionary,\n  DictionaryKeys,\n  LanguageContent,\n} from '@intlayer/core';\nimport { derived, writable, type Readable } from 'svelte/store';\nimport { getIntlayerContext } from './intlayerContext';\nimport { intlayerStore } from './intlayerStore';\n\n/**\n * Svelte hook for handling dynamic dictionary loading\n * @param dictionaryPromise Promise-based dictionary content\n * @param key Dictionary key for caching\n * @param locale Target locale (optional)\n * @returns Reactive store with loaded dictionary content\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  K extends DictionaryKeys,\n>(\n  dictionaryPromise: LanguageContent<() => Promise<T>>,\n  key: K,\n  locale?: LocalesValues\n): Readable<T | null> => {\n  const context = getIntlayerContext();\n  const dictionaryStore = writable<T | null>(null);\n\n  // Create a derived store that loads the dictionary when locale changes\n  return derived([intlayerStore], ([$store]) => {\n    const targetLocale = locale ?? context?.locale ?? $store.locale;\n\n    // Load dictionary for the target locale asynchronously\n    const loadDictionary = async () => {\n      try {\n        const dictionaryLoader = dictionaryPromise[targetLocale];\n        if (dictionaryLoader) {\n          const loadedDictionary = await dictionaryLoader();\n          dictionaryStore.set(loadedDictionary);\n        } else {\n          dictionaryStore.set(null);\n        }\n      } catch (error) {\n        console.error(\n          `Failed to load dictionary for key: ${String(key)}`,\n          error\n        );\n        dictionaryStore.set(null);\n      }\n    };\n\n    loadDictionary();\n\n    // Return the current state, actual loading happens asynchronously\n    return null;\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,mBAAiD;AACjD,6BAAmC;AACnC,2BAA8B;AASvB,MAAM,uBAAuB,CAIlC,mBACA,KACA,WACuB;AACvB,QAAM,cAAU,2CAAmB;AACnC,QAAM,sBAAkB,uBAAmB,IAAI;AAG/C,aAAO,sBAAQ,CAAC,kCAAa,GAAG,CAAC,CAAC,MAAM,MAAM;AAC5C,UAAM,eAAe,UAAU,SAAS,UAAU,OAAO;AAGzD,UAAM,iBAAiB,YAAY;AACjC,UAAI;AACF,cAAM,mBAAmB,kBAAkB,YAAY;AACvD,YAAI,kBAAkB;AACpB,gBAAM,mBAAmB,MAAM,iBAAiB;AAChD,0BAAgB,IAAI,gBAAgB;AAAA,QACtC,OAAO;AACL,0BAAgB,IAAI,IAAI;AAAA,QAC1B;AAAA,MACF,SAAS,OAAO;AACd,gBAAQ;AAAA,UACN,sCAAsC,OAAO,GAAG,CAAC;AAAA,UACjD;AAAA,QACF;AACA,wBAAgB,IAAI,IAAI;AAAA,MAC1B;AAAA,IACF;AAEA,mBAAe;AAGf,WAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/cjs/client/useIntlayer.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useIntlayer_exports = {};
+__export(useIntlayer_exports, {
+  useIntlayer: () => useIntlayer
+});
+module.exports = __toCommonJS(useIntlayer_exports);
+var import_store = require("svelte/store");
+var import_getIntlayer = require('../getIntlayer.cjs');
+var import_intlayerContext = require('./intlayerContext.cjs');
+var import_intlayerStore = require('./intlayerStore.cjs');
+const useIntlayer = (key, locale) => {
+  const context = (0, import_intlayerContext.getIntlayerContext)();
+  return (0, import_store.derived)([import_intlayerStore.intlayerStore], ([$store]) => {
+    const targetLocale = locale ?? context?.locale ?? $store.locale;
+    return (0, import_getIntlayer.getIntlayer)(key, targetLocale);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useIntlayer
+});
+//# sourceMappingURL=useIntlayer.cjs.map

package/dist/cjs/client/useIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport type { DictionaryKeys } from '@intlayer/core';\nimport { derived, type Readable } from 'svelte/store';\n// @ts-ignore intlayer declared for module augmentation\nimport type { IntlayerDictionaryTypesConnector } from 'intlayer';\nimport { getIntlayer } from '../getIntlayer';\nimport { DeepTransformContent } from '../plugins';\nimport { getIntlayerContext } from './intlayerContext';\nimport { intlayerStore } from './intlayerStore';\n\n/**\n * Svelte hook that picks one dictionary by its key and returns reactive content\n * @param key The dictionary key to retrieve\n * @param locale The target locale (optional, uses context or store locale)\n * @returns Reactive store with transformed dictionary content\n */\nexport const useIntlayer = <T extends DictionaryKeys>(\n  key: T,\n  locale?: LocalesValues\n): Readable<\n  DeepTransformContent<IntlayerDictionaryTypesConnector[T]['content']>\n> => {\n  const context = getIntlayerContext();\n\n  // Create a derived store that reactively updates when locale changes\n  return derived([intlayerStore], ([$store]) => {\n    const targetLocale = locale ?? context?.locale ?? $store.locale;\n    return getIntlayer(key, targetLocale);\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAAuC;AAGvC,yBAA4B;AAE5B,6BAAmC;AACnC,2BAA8B;AAQvB,MAAM,cAAc,CACzB,KACA,WAGG;AACH,QAAM,cAAU,2CAAmB;AAGnC,aAAO,sBAAQ,CAAC,kCAAa,GAAG,CAAC,CAAC,MAAM,MAAM;AAC5C,UAAM,eAAe,UAAU,SAAS,UAAU,OAAO;AACzD,eAAO,gCAAY,KAAK,YAAY;AAAA,EACtC,CAAC;AACH;","names":[]}

package/dist/cjs/client/useIntlayerAsync.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useIntlayerAsync_exports = {};
+__export(useIntlayerAsync_exports, {
+  useIntlayerAsync: () => useIntlayerAsync
+});
+module.exports = __toCommonJS(useIntlayerAsync_exports);
+var import_store = require("svelte/store");
+var import_intlayerContext = require('./intlayerContext.cjs');
+var import_intlayerStore = require('./intlayerStore.cjs');
+const useIntlayerAsync = (key, locale) => {
+  const context = (0, import_intlayerContext.getIntlayerContext)();
+  const contentStore = (0, import_store.writable)(null);
+  return (0, import_store.derived)([import_intlayerStore.intlayerStore], ([$store]) => {
+    const targetLocale = locale ?? context?.locale ?? $store.locale;
+    const loadDictionary = async () => {
+      try {
+        const { getIntlayerAsync } = await import("@intlayer/core");
+        const content = await getIntlayerAsync(key, targetLocale);
+        contentStore.set(content);
+      } catch (error) {
+        console.error(
+          `Failed to load async dictionary for key: ${String(key)}`,
+          error
+        );
+        contentStore.set(null);
+      }
+    };
+    loadDictionary();
+    return null;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useIntlayerAsync
+});
+//# sourceMappingURL=useIntlayerAsync.cjs.map

package/dist/cjs/client/useIntlayerAsync.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useIntlayerAsync.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport type { DictionaryKeys } from '@intlayer/core';\nimport { derived, writable, type Readable } from 'svelte/store';\n// @ts-ignore intlayer declared for module augmentation\nimport type { IntlayerDictionaryTypesConnector } from 'intlayer';\nimport { DeepTransformContent } from '../plugins';\nimport { getIntlayerContext } from './intlayerContext';\nimport { intlayerStore } from './intlayerStore';\n\n/**\n * Svelte hook for asynchronous dictionary loading by key\n * @param key The dictionary key to retrieve\n * @param locale Target locale (optional)\n * @returns Reactive store with loaded dictionary content\n */\nexport const useIntlayerAsync = <T extends DictionaryKeys>(\n  key: T,\n  locale?: LocalesValues\n): Readable<DeepTransformContent<\n  IntlayerDictionaryTypesConnector[T]['content']\n> | null> => {\n  const context = getIntlayerContext();\n  const contentStore = writable<DeepTransformContent<\n    IntlayerDictionaryTypesConnector[T]['content']\n  > | null>(null);\n\n  // Create a derived store that loads the dictionary when locale changes\n  return derived([intlayerStore], ([$store]) => {\n    const targetLocale = locale ?? context?.locale ?? $store.locale;\n\n    // Load dictionary asynchronously\n    const loadDictionary = async () => {\n      try {\n        // This would typically use getIntlayerAsync from core\n        // For now, we'll simulate async loading\n        const { getIntlayerAsync } = await import('@intlayer/core');\n        const content = await getIntlayerAsync(key, targetLocale);\n        contentStore.set(content);\n      } catch (error) {\n        console.error(\n          `Failed to load async dictionary for key: ${String(key)}`,\n          error\n        );\n        contentStore.set(null);\n      }\n    };\n\n    loadDictionary();\n\n    // Return the current state, actual loading happens asynchronously\n    return null;\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAAiD;AAIjD,6BAAmC;AACnC,2BAA8B;AAQvB,MAAM,mBAAmB,CAC9B,KACA,WAGW;AACX,QAAM,cAAU,2CAAmB;AACnC,QAAM,mBAAe,uBAEX,IAAI;AAGd,aAAO,sBAAQ,CAAC,kCAAa,GAAG,CAAC,CAAC,MAAM,MAAM;AAC5C,UAAM,eAAe,UAAU,SAAS,UAAU,OAAO;AAGzD,UAAM,iBAAiB,YAAY;AACjC,UAAI;AAGF,cAAM,EAAE,iBAAiB,IAAI,MAAM,OAAO,gBAAgB;AAC1D,cAAM,UAAU,MAAM,iBAAiB,KAAK,YAAY;AACxD,qBAAa,IAAI,OAAO;AAAA,MAC1B,SAAS,OAAO;AACd,gBAAQ;AAAA,UACN,4CAA4C,OAAO,GAAG,CAAC;AAAA,UACvD;AAAA,QACF;AACA,qBAAa,IAAI,IAAI;AAAA,MACvB;AAAA,IACF;AAEA,mBAAe;AAGf,WAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/cjs/client/useLocale.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useLocale_exports = {};
+__export(useLocale_exports, {
+  useLocale: () => useLocale
+});
+module.exports = __toCommonJS(useLocale_exports);
+var import_store = require("svelte/store");
+var import_intlayerContext = require('./intlayerContext.cjs');
+var import_intlayerStore = require('./intlayerStore.cjs');
+const useLocale = () => {
+  const context = (0, import_intlayerContext.getIntlayerContext)();
+  if (context) {
+    return {
+      locale: (0, import_store.derived)(
+        [import_intlayerStore.intlayerStore],
+        ([$store]) => context.locale || $store.locale
+      ),
+      setLocale: context.setLocale
+    };
+  }
+  return {
+    locale: import_intlayerStore.intlayerStore.getLocale(),
+    setLocale: import_intlayerStore.intlayerStore.setLocale
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useLocale
+});
+//# sourceMappingURL=useLocale.cjs.map

package/dist/cjs/client/useLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { derived } from 'svelte/store';\nimport { getIntlayerContext } from './intlayerContext';\nimport { intlayerStore } from './intlayerStore';\n\n/**\n * Hook to get and set the current locale in Svelte applications\n * @returns Readable store with current locale and setter function\n */\nexport const useLocale = () => {\n  const context = getIntlayerContext();\n\n  if (context) {\n    // Use context if available\n    return {\n      locale: derived(\n        [intlayerStore],\n        ([$store]) => context.locale || $store.locale\n      ),\n      setLocale: context.setLocale,\n    };\n  }\n\n  // Fallback to global store\n  return {\n    locale: intlayerStore.getLocale(),\n    setLocale: intlayerStore.setLocale,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAwB;AACxB,6BAAmC;AACnC,2BAA8B;AAMvB,MAAM,YAAY,MAAM;AAC7B,QAAM,cAAU,2CAAmB;AAEnC,MAAI,SAAS;AAEX,WAAO;AAAA,MACL,YAAQ;AAAA,QACN,CAAC,kCAAa;AAAA,QACd,CAAC,CAAC,MAAM,MAAM,QAAQ,UAAU,OAAO;AAAA,MACzC;AAAA,MACA,WAAW,QAAQ;AAAA,IACrB;AAAA,EACF;AAGA,SAAO;AAAA,IACL,QAAQ,mCAAc,UAAU;AAAA,IAChC,WAAW,mCAAc;AAAA,EAC3B;AACF;","names":[]}

package/dist/cjs/getDictionary.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDictionary_exports = {};
+__export(getDictionary_exports, {
+  getDictionary: () => getDictionary
+});
+module.exports = __toCommonJS(getDictionary_exports);
+var import_core = require("@intlayer/core");
+var import_plugins = require('./plugins.cjs');
+const getDictionary = (dictionary, locale, additionalPlugins) => {
+  const plugins = [
+    import_plugins.intlayerNodePlugins,
+    import_plugins.svelteNodePlugins,
+    import_plugins.markdownPlugin,
+    ...additionalPlugins ?? []
+  ];
+  return (0, import_core.getDictionary)(
+    dictionary,
+    locale,
+    plugins
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDictionary
+});
+//# sourceMappingURL=getDictionary.cjs.map

package/dist/cjs/getDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/getDictionary.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config/client';\nimport {\n  Dictionary,\n  Plugins,\n  getDictionary as getDictionaryCore,\n} from '@intlayer/core';\nimport {\n  DeepTransformContent,\n  intlayerNodePlugins,\n  markdownPlugin,\n  svelteNodePlugins,\n} from './plugins';\n\n/**\n * Get dictionary content for a specific locale in Svelte applications\n * @param dictionary The dictionary object to transform\n * @param locale The target locale (optional, defaults to current locale)\n * @param additionalPlugins Additional transformation plugins\n * @returns Transformed dictionary content optimized for Svelte\n */\nexport const getDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = Locales,\n>(\n  dictionary: T,\n  locale?: L,\n  additionalPlugins?: Plugins[]\n) => {\n  const plugins: Plugins[] = [\n    intlayerNodePlugins,\n    svelteNodePlugins,\n    markdownPlugin,\n    ...(additionalPlugins ?? []),\n  ];\n\n  return getDictionaryCore(\n    dictionary,\n    locale,\n    plugins\n  ) as any as DeepTransformContent<T['content']>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAIO;AACP,qBAKO;AASA,MAAM,gBAAgB,CAI3B,YACA,QACA,sBACG;AACH,QAAM,UAAqB;AAAA,IACzB;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,qBAAqB,CAAC;AAAA,EAC5B;AAEA,aAAO,YAAAA;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":["getDictionaryCore"]}

package/dist/cjs/getIntlayer.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getIntlayer_exports = {};
+__export(getIntlayer_exports, {
+  getIntlayer: () => getIntlayer
+});
+module.exports = __toCommonJS(getIntlayer_exports);
+var import_core = require("@intlayer/core");
+var import_plugins = require('./plugins.cjs');
+const getIntlayer = (key, locale, additionalPlugins) => {
+  const plugins = [
+    import_plugins.intlayerNodePlugins,
+    import_plugins.svelteNodePlugins,
+    import_plugins.markdownPlugin,
+    ...additionalPlugins ?? []
+  ];
+  return (0, import_core.getIntlayer)(key, locale, plugins);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getIntlayer
+});
+//# sourceMappingURL=getIntlayer.cjs.map

package/dist/cjs/getIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import {\n  DictionaryKeys,\n  getIntlayer as getIntlayerCore,\n  Plugins,\n} from '@intlayer/core';\n// @ts-ignore intlayer declared for module augmentation\nimport type { IntlayerDictionaryTypesConnector, LocalesValues } from 'intlayer';\nimport {\n  DeepTransformContent,\n  intlayerNodePlugins,\n  markdownPlugin,\n  svelteNodePlugins,\n} from './plugins';\n\n/**\n * Get dictionary content by key for Svelte applications\n * @param key The dictionary key to retrieve\n * @param locale The target locale (optional)\n * @param additionalPlugins Additional transformation plugins\n * @returns Transformed dictionary content optimized for Svelte\n */\nexport const getIntlayer = <T extends DictionaryKeys, L extends LocalesValues>(\n  key: T,\n  locale?: L,\n  additionalPlugins?: Plugins[]\n) => {\n  const plugins: Plugins[] = [\n    intlayerNodePlugins,\n    svelteNodePlugins,\n    markdownPlugin,\n    ...(additionalPlugins ?? []),\n  ];\n\n  return getIntlayerCore(key, locale, plugins) as any as DeepTransformContent<\n    IntlayerDictionaryTypesConnector[T]['content']\n  >;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAIO;AAGP,qBAKO;AASA,MAAM,cAAc,CACzB,KACA,QACA,sBACG;AACH,QAAM,UAAqB;AAAA,IACzB;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,qBAAqB,CAAC;AAAA,EAC5B;AAEA,aAAO,YAAAA,aAAgB,KAAK,QAAQ,OAAO;AAG7C;","names":["getIntlayerCore"]}

package/dist/cjs/index.cjs

@@ -15,11 +15,17 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require('./intlayerPlugin.cjs'), module.exports);
-__reExport(index_exports, require('./intlayerMiddlewarePlugin.cjs'), module.exports);
+__reExport(index_exports, require('./client/index.cjs'), module.exports);
+__reExport(index_exports, require('./getDictionary.cjs'), module.exports);
+__reExport(index_exports, require('./getIntlayer.cjs'), module.exports);
+__reExport(index_exports, require('./markdown/index.cjs'), module.exports);
+__reExport(index_exports, require('./plugins.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require('./intlayerPlugin.cjs'),
-  ...require('./intlayerMiddlewarePlugin.cjs')
+  ...require('./client/index.cjs'),
+  ...require('./getDictionary.cjs'),
+  ...require('./getIntlayer.cjs'),
+  ...require('./markdown/index.cjs'),
+  ...require('./plugins.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './intlayerPlugin';\nexport * from './intlayerMiddlewarePlugin';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,6BAAd;AACA,0BAAc,uCADd;","names":[]}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { IInterpreterPluginSvelte } from './plugins';\n\ndeclare module '@intlayer/core' {\n  interface IInterpreterPlugin<T, S> extends IInterpreterPluginSvelte<T> {}\n}\n\nexport * from './client';\nexport * from './getDictionary';\nexport * from './getIntlayer';\nexport * from './markdown';\nexport * from './plugins';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,0BAAc,qBANd;AAOA,0BAAc,4BAPd;AAQA,0BAAc,0BARd;AASA,0BAAc,uBATd;AAUA,0BAAc,sBAVd;","names":[]}

package/dist/cjs/markdown/index.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var markdown_exports = {};
+__export(markdown_exports, {
+  defaultMarkdownRenderer: () => defaultMarkdownRenderer,
+  processMarkdown: () => processMarkdown
+});
+module.exports = __toCommonJS(markdown_exports);
+const processMarkdown = (content) => {
+  return content;
+};
+const defaultMarkdownRenderer = {
+  render: processMarkdown,
+  configure: (options) => {
+    console.log("Configuring markdown renderer with options:", options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultMarkdownRenderer,
+  processMarkdown
+});
+//# sourceMappingURL=index.cjs.map