preact-intlayer 5.5.4 → 5.5.6

package/dist/cjs/editor/useEditedContentRenderer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useEditedContentRenderer.tsx"],"sourcesContent":["'use client';\n\nimport { Locales } from '@intlayer/config/client';\nimport { getContent, type KeyPath } from '@intlayer/core';\nimport { FC } from 'preact/compat';\nimport { useEditedContentActions } from './EditedContentContext';\n\ntype EditedContentRendererProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  children: string;\n  locale?: Locales;\n};\n\nexport const useEditedContentRenderer = ({\n  dictionaryKey,\n  keyPath,\n  children,\n}: EditedContentRendererProps) => {\n  const editedContentContext = useEditedContentActions();\n\n  if (editedContentContext) {\n    const editedValue = editedContentContext.getEditedContentValue(\n      dictionaryKey,\n      keyPath\n    ) as string;\n\n    const value = editedValue ?? children;\n\n    return value;\n  }\n\n  return children;\n};\n\nexport const EditedContentRenderer: FC<EditedContentRendererProps> = (\n  props\n) => {\n  const content = useEditedContentRenderer(props);\n\n  if (typeof content === 'object') {\n    const transformedEditedContent = getContent(content, props, props.locale);\n\n    if (typeof transformedEditedContent !== 'string') {\n      console.error(\n        `Incorrect edited content format. Content type: ${typeof transformedEditedContent}. Expected string. Value ${JSON.stringify(transformedEditedContent)}`\n      );\n\n      return props.children;\n    }\n\n    return transformedEditedContent;\n  }\n\n  return content;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,kBAAyC;AAEzC,kCAAwC;AASjC,MAAM,2BAA2B,CAAC;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF,MAAkC;AAChC,QAAM,2BAAuB,qDAAwB;AAErD,MAAI,sBAAsB;AACxB,UAAM,cAAc,qBAAqB;AAAA,MACvC;AAAA,MACA;AAAA,IACF;AAEA,UAAM,QAAQ,eAAe;AAE7B,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,MAAM,wBAAwD,CACnE,UACG;AACH,QAAM,UAAU,yBAAyB,KAAK;AAE9C,MAAI,OAAO,YAAY,UAAU;AAC/B,UAAM,+BAA2B,wBAAW,SAAS,OAAO,MAAM,MAAM;AAExE,QAAI,OAAO,6BAA6B,UAAU;AAChD,cAAQ;AAAA,QACN,kDAAkD,OAAO,wBAAwB,4BAA4B,KAAK,UAAU,wBAAwB,CAAC;AAAA,MACvJ;AAEA,aAAO,MAAM;AAAA,IACf;AAEA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/editor/useIframeClickInterceptor.cjs

@@ -0,0 +1,50 @@
+"use strict";
+"use client";
+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 useIframeClickInterceptor_exports = {};
+__export(useIframeClickInterceptor_exports, {
+  useIframeClickInterceptor: () => useIframeClickInterceptor,
+  useIframeClickMerger: () => useIframeClickMerger
+});
+module.exports = __toCommonJS(useIframeClickInterceptor_exports);
+var import_editor = require("@intlayer/editor");
+var import_hooks = require("preact/hooks");
+var import_useCrossFrameMessageListener = require('./useCrossFrameMessageListener.cjs');
+const useIframeClickInterceptor = () => {
+  const postMessage = (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
+    import_editor.MessageKey.INTLAYER_IFRAME_CLICKED
+  );
+  const handlePostMessageEvent = () => {
+    postMessage();
+  };
+  (0, import_hooks.useEffect)(() => {
+    window.addEventListener("mousedown", handlePostMessageEvent);
+    return () => window.removeEventListener("mousedown", handlePostMessageEvent);
+  }, [postMessage]);
+};
+const useIframeClickMerger = () => (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
+  import_editor.MessageKey.INTLAYER_IFRAME_CLICKED,
+  import_editor.mergeIframeClick
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useIframeClickInterceptor,
+  useIframeClickMerger
+});
+//# sourceMappingURL=useIframeClickInterceptor.cjs.map

package/dist/cjs/editor/useIframeClickInterceptor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useIframeClickInterceptor.tsx"],"sourcesContent":["'use client';\n\nimport { MessageKey, mergeIframeClick } from '@intlayer/editor';\nimport { useEffect } from 'preact/hooks';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\nexport const useIframeClickInterceptor = () => {\n  const postMessage = useCrossFrameMessageListener<undefined>(\n    MessageKey.INTLAYER_IFRAME_CLICKED\n  );\n  const handlePostMessageEvent: EventListener = () => {\n    postMessage();\n  };\n\n  useEffect(() => {\n    window.addEventListener('mousedown', handlePostMessageEvent);\n\n    return () =>\n      window.removeEventListener('mousedown', handlePostMessageEvent);\n  }, [postMessage]);\n};\n\nexport const useIframeClickMerger = () =>\n  useCrossFrameMessageListener<MessageEvent>(\n    MessageKey.INTLAYER_IFRAME_CLICKED,\n    mergeIframeClick\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAA6C;AAC7C,mBAA0B;AAC1B,0CAA6C;AAEtC,MAAM,4BAA4B,MAAM;AAC7C,QAAM,kBAAc;AAAA,IAClB,yBAAW;AAAA,EACb;AACA,QAAM,yBAAwC,MAAM;AAClD,gBAAY;AAAA,EACd;AAEA,8BAAU,MAAM;AACd,WAAO,iBAAiB,aAAa,sBAAsB;AAE3D,WAAO,MACL,OAAO,oBAAoB,aAAa,sBAAsB;AAAA,EAClE,GAAG,CAAC,WAAW,CAAC;AAClB;AAEO,MAAM,uBAAuB,UAClC;AAAA,EACE,yBAAW;AAAA,EACX;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.preactNodePlugins,
+    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  type Dictionary,\n  type Plugins,\n  getDictionary as getDictionaryCore,\n} from '@intlayer/core';\nimport {\n  type DeepTransformContent,\n  intlayerNodePlugins,\n  markdownPlugin,\n  preactNodePlugins,\n} from './plugins';\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    preactNodePlugins,\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;AAEA,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.preactNodePlugins,
+    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  type DictionaryKeys,\n  type Plugins,\n  getIntlayer as getIntlayerCore,\n} from '@intlayer/core';\n// @ts-ignore intlayer declared for module augmentation\nimport type { IntlayerDictionaryTypesConnector, LocalesValues } from 'intlayer';\nimport {\n  type DeepTransformContent,\n  intlayerNodePlugins,\n  markdownPlugin,\n  preactNodePlugins,\n} from './plugins';\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    preactNodePlugins,\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;AAEA,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

@@ -3,6 +3,10 @@ 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))
@@ -11,15 +15,48 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
+__export(index_exports, {
+  IntlayerClientContext: () => import_client.IntlayerClientContext,
+  IntlayerProvider: () => import_client.IntlayerProvider,
+  IntlayerProviderContent: () => import_client.IntlayerProviderContent,
+  MarkdownProvider: () => import_markdown.MarkdownProvider,
+  getBrowserLocale: () => import_client.getBrowserLocale,
+  localeCookie: () => import_client.localeCookie,
+  setLocaleCookie: () => import_client.setLocaleCookie,
+  t: () => import_client.t,
+  useDictionary: () => import_client.useDictionary,
+  useDictionaryDynamic: () => import_client.useDictionaryDynamic,
+  useIntlayer: () => import_client.useIntlayer,
+  useIntlayerAsync: () => import_client.useIntlayerAsync,
+  useIntlayerContext: () => import_client.useIntlayerContext,
+  useLoadDynamic: () => import_client.useLoadDynamic,
+  useLocale: () => import_client.useLocale,
+  useLocaleBase: () => import_client.useLocaleBase,
+  useLocaleCookie: () => import_client.useLocaleCookie
+});
 module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require('./intlayerPlugin.cjs'), module.exports);
-__reExport(index_exports, require('./intlayerMiddlewarePlugin.cjs'), module.exports);
+var import_client = require('./client/index.cjs');
+var import_markdown = require('./markdown/index.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require('./intlayerPlugin.cjs'),
-  ...require('./intlayerMiddlewarePlugin.cjs')
+  IntlayerClientContext,
+  IntlayerProvider,
+  IntlayerProviderContent,
+  MarkdownProvider,
+  getBrowserLocale,
+  localeCookie,
+  setLocaleCookie,
+  t,
+  useDictionary,
+  useDictionaryDynamic,
+  useIntlayer,
+  useIntlayerAsync,
+  useIntlayerContext,
+  useLoadDynamic,
+  useLocale,
+  useLocaleBase,
+  useLocaleCookie
 });
 //# 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 type { IInterpreterPluginPreact } from './plugins';\n\ndeclare module '@intlayer/core' {\n  interface IInterpreterPlugin<T, S> extends IInterpreterPluginPreact<T> {}\n}\n\nexport {\n  getBrowserLocale,\n  IntlayerClientContext,\n  IntlayerProvider,\n  IntlayerProviderContent,\n  localeCookie,\n  setLocaleCookie,\n  t,\n  useDictionary,\n  useDictionaryDynamic,\n  useIntlayer,\n  useIntlayerAsync,\n  useIntlayerContext,\n  useLoadDynamic,\n  useLocale,\n  useLocaleBase,\n  useLocaleCookie,\n  type IntlayerProviderProps,\n} from './client/index';\nexport { type IntlayerNode } from './IntlayerNode';\nexport { MarkdownProvider } from './markdown/index';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,oBAkBO;AAEP,sBAAiC;","names":[]}

package/dist/cjs/markdown/MarkdownProvider.cjs

@@ -0,0 +1,41 @@
+"use strict";
+"use client";
+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 MarkdownProvider_exports = {};
+__export(MarkdownProvider_exports, {
+  MarkdownProvider: () => MarkdownProvider,
+  useMarkdownContext: () => useMarkdownContext
+});
+module.exports = __toCommonJS(MarkdownProvider_exports);
+var import_jsx_runtime = require("preact/jsx-runtime");
+var import_compat = require("preact/compat");
+const MarkdownContext = (0, import_compat.createContext)({
+  renderMarkdown: (markdown) => markdown
+});
+const useMarkdownContext = () => (0, import_compat.useContext)(MarkdownContext);
+const MarkdownProvider = ({
+  children,
+  renderMarkdown
+}) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MarkdownContext.Provider, { value: { renderMarkdown }, children });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MarkdownProvider,
+  useMarkdownContext
+});
+//# sourceMappingURL=MarkdownProvider.cjs.map

package/dist/cjs/markdown/MarkdownProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createContext,\n  useContext,\n  type FC,\n  type PropsWithChildren,\n  type ReactNode,\n} from 'preact/compat';\n\ntype MarkdownContextValue = {\n  renderMarkdown: (markdown: string) => ReactNode;\n};\n\ntype MarkdownProviderProps = PropsWithChildren<MarkdownContextValue>;\n\nconst MarkdownContext = createContext<MarkdownContextValue>({\n  renderMarkdown: (markdown: string) => markdown,\n});\n\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n  children,\n  renderMarkdown,\n}) => (\n  <MarkdownContext.Provider value={{ renderMarkdown }}>\n    {children}\n  </MarkdownContext.Provider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BE;AAxBF,oBAMO;AAQP,MAAM,sBAAkB,6BAAoC;AAAA,EAC1D,gBAAgB,CAAC,aAAqB;AACxC,CAAC;AAEM,MAAM,qBAAqB,UAAM,0BAAW,eAAe;AAE3D,MAAM,mBAA8C,CAAC;AAAA,EAC1D;AAAA,EACA;AACF,MACE,4CAAC,gBAAgB,UAAhB,EAAyB,OAAO,EAAE,eAAe,GAC/C,UACH;","names":[]}

package/dist/cjs/markdown/MarkdownRenderer.cjs

@@ -0,0 +1,83 @@
+"use strict";
+"use client";
+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 MarkdownRenderer_exports = {};
+__export(MarkdownRenderer_exports, {
+  MarkdownMetadataRenderer: () => MarkdownMetadataRenderer,
+  MarkdownRenderer: () => MarkdownRenderer
+});
+module.exports = __toCommonJS(MarkdownRenderer_exports);
+var import_core = require("@intlayer/core");
+var import_useEditedContentRenderer = require('../editor/useEditedContentRenderer.cjs');
+var import_MarkdownProvider = require('./MarkdownProvider.cjs');
+const MarkdownRenderer = ({
+  dictionaryKey,
+  keyPath,
+  children,
+  locale
+}) => {
+  const { renderMarkdown } = (0, import_MarkdownProvider.useMarkdownContext)();
+  const editedContentContext = (0, import_useEditedContentRenderer.useEditedContentRenderer)({
+    dictionaryKey,
+    keyPath,
+    children
+  });
+  if (typeof editedContentContext !== "string") {
+    const transformedEditedContent = (0, import_core.getContent)(
+      editedContentContext,
+      {
+        dictionaryKey,
+        keyPath
+      },
+      locale
+    );
+    if (typeof transformedEditedContent !== "string") {
+      console.error(
+        `Incorrect Markdown content. Edited Markdown content type: ${typeof transformedEditedContent}. Expected string. Value ${JSON.stringify(transformedEditedContent)}`
+      );
+      return renderMarkdown(children);
+    }
+    return renderMarkdown(transformedEditedContent);
+  }
+  return renderMarkdown(editedContentContext);
+};
+const MarkdownMetadataRenderer = ({
+  dictionaryKey,
+  keyPath,
+  children,
+  metadataKeyPath
+}) => {
+  const editedContentContext = (0, import_useEditedContentRenderer.useEditedContentRenderer)({
+    dictionaryKey,
+    keyPath,
+    children
+  });
+  const metadata = (0, import_core.getMarkdownMetadata)(editedContentContext);
+  const metadataEl = (0, import_core.getContentNodeByKeyPath)(
+    metadata,
+    metadataKeyPath
+  );
+  return metadataEl;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MarkdownMetadataRenderer,
+  MarkdownRenderer
+});
+//# sourceMappingURL=MarkdownRenderer.cjs.map

package/dist/cjs/markdown/MarkdownRenderer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"sourcesContent":["'use client';\n\nimport { LocalesValues } from '@intlayer/config/client';\nimport {\n  ContentNode,\n  getContent,\n  getContentNodeByKeyPath,\n  getMarkdownMetadata,\n  KeyPath,\n} from '@intlayer/core';\nimport { FC, ReactNode } from 'preact/compat';\nimport { useEditedContentRenderer } from '../editor/useEditedContentRenderer';\nimport { useMarkdownContext } from './MarkdownProvider';\n\ntype MarkdownRendererProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  locale?: LocalesValues;\n  children: string;\n};\n\nexport const MarkdownRenderer: FC<MarkdownRendererProps> = ({\n  dictionaryKey,\n  keyPath,\n  children,\n  locale,\n}): ReactNode => {\n  const { renderMarkdown } = useMarkdownContext();\n  const editedContentContext = useEditedContentRenderer({\n    dictionaryKey,\n    keyPath,\n    children,\n  });\n\n  if (typeof editedContentContext !== 'string') {\n    const transformedEditedContent = getContent(\n      editedContentContext,\n      {\n        dictionaryKey,\n        keyPath,\n      },\n      locale\n    );\n\n    if (typeof transformedEditedContent !== 'string') {\n      console.error(\n        `Incorrect Markdown content. Edited Markdown content type: ${typeof transformedEditedContent}. Expected string. Value ${JSON.stringify(transformedEditedContent)}`\n      );\n\n      return renderMarkdown(children);\n    }\n\n    return renderMarkdown(transformedEditedContent);\n  }\n\n  return renderMarkdown(editedContentContext);\n};\n\ntype MarkdownMetadataRendererProps = MarkdownRendererProps & {\n  metadataKeyPath: KeyPath[];\n};\n\nexport const MarkdownMetadataRenderer: FC<MarkdownMetadataRendererProps> = ({\n  dictionaryKey,\n  keyPath,\n  children,\n  metadataKeyPath,\n}): ReactNode => {\n  const editedContentContext = useEditedContentRenderer({\n    dictionaryKey,\n    keyPath,\n    children,\n  });\n  const metadata = getMarkdownMetadata(editedContentContext);\n\n  const metadataEl = getContentNodeByKeyPath(\n    metadata as ContentNode,\n    metadataKeyPath\n  );\n\n  return metadataEl as ReactNode;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,kBAMO;AAEP,sCAAyC;AACzC,8BAAmC;AAS5B,MAAM,mBAA8C,CAAC;AAAA,EAC1D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAiB;AACf,QAAM,EAAE,eAAe,QAAI,4CAAmB;AAC9C,QAAM,2BAAuB,0DAAyB;AAAA,IACpD;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,MAAI,OAAO,yBAAyB,UAAU;AAC5C,UAAM,+BAA2B;AAAA,MAC/B;AAAA,MACA;AAAA,QACE;AAAA,QACA;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAEA,QAAI,OAAO,6BAA6B,UAAU;AAChD,cAAQ;AAAA,QACN,6DAA6D,OAAO,wBAAwB,4BAA4B,KAAK,UAAU,wBAAwB,CAAC;AAAA,MAClK;AAEA,aAAO,eAAe,QAAQ;AAAA,IAChC;AAEA,WAAO,eAAe,wBAAwB;AAAA,EAChD;AAEA,SAAO,eAAe,oBAAoB;AAC5C;AAMO,MAAM,2BAA8D,CAAC;AAAA,EAC1E;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAiB;AACf,QAAM,2BAAuB,0DAAyB;AAAA,IACpD;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,eAAW,iCAAoB,oBAAoB;AAEzD,QAAM,iBAAa;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/markdown/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var markdown_exports = {};
+module.exports = __toCommonJS(markdown_exports);
+__reExport(markdown_exports, require('./MarkdownProvider.cjs'), module.exports);
+__reExport(markdown_exports, require('./MarkdownRenderer.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./MarkdownProvider.cjs'),
+  ...require('./MarkdownRenderer.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/markdown/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/markdown/index.ts"],"sourcesContent":["export * from './MarkdownProvider';\nexport * from './MarkdownRenderer';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,6BAAc,+BAAd;AACA,6BAAc,+BADd;","names":[]}

package/dist/cjs/plugins.cjs

@@ -0,0 +1,128 @@
+"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 plugins_exports = {};
+__export(plugins_exports, {
+  intlayerNodePlugins: () => intlayerNodePlugins,
+  markdownPlugin: () => markdownPlugin,
+  markdownStringPlugin: () => markdownStringPlugin,
+  preactNodePlugins: () => preactNodePlugins
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_jsx_runtime = require("preact/jsx-runtime");
+var import_preact = require("preact");
+var import_core = require("@intlayer/core");
+var import_IntlayerNode = require('./IntlayerNode.cjs');
+var import_editor = require('./editor/index.cjs');
+var import_useEditedContentRenderer = require('./editor/useEditedContentRenderer.cjs');
+var import_markdown = require('./markdown/index.cjs');
+var import_renderPreactElement = require('./preactElement/renderPreactElement.cjs');
+const intlayerNodePlugins = {
+  id: "intlayer-node-plugin",
+  canHandle: (node) => typeof node === "bigint" || typeof node === "string" || typeof node === "number",
+  transform: (_node, {
+    plugins,
+    // Removed to avoid next error - Functions cannot be passed directly to Client Components
+    ...rest
+  }) => (0, import_IntlayerNode.renderIntlayerNode)({
+    ...rest,
+    value: rest.children,
+    children: /* @__PURE__ */ (0, import_preact.createElement)(import_editor.ContentSelectorRenderer, { ...rest, key: rest.children }, /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_useEditedContentRenderer.EditedContentRenderer, { ...rest, children: rest.children }))
+  })
+};
+const preactNodePlugins = {
+  id: "preact-node-plugin",
+  canHandle: (node) => typeof node === "object" && typeof node.props !== "undefined" && typeof node.key !== "undefined",
+  transform: (node, {
+    plugins,
+    // Removed to avoid next error - Functions cannot be passed directly to Client Components
+    ...rest
+  }) => (0, import_IntlayerNode.renderIntlayerNode)({
+    ...rest,
+    value: "[[preact-element]]",
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_editor.ContentSelectorRenderer, { ...rest, children: (0, import_renderPreactElement.renderPreactElement)(node) })
+  })
+};
+const markdownStringPlugin = {
+  id: "markdown-string-plugin",
+  canHandle: (node) => typeof node === "string",
+  transform: (node, props, deepTransformNode) => {
+    const {
+      plugins,
+      // Removed to avoid next error - Functions cannot be passed directly to Client Components
+      ...rest
+    } = props;
+    const metadata = (0, import_core.getMarkdownMetadata)(node);
+    const metadataPlugins = {
+      id: "markdown-metadata-plugin",
+      canHandle: (metadataNode) => typeof metadataNode === "string" || typeof metadataNode === "number" || typeof metadataNode === "boolean" || !metadataNode,
+      transform: (metadataNode, props2) => (0, import_IntlayerNode.renderIntlayerNode)({
+        ...props2,
+        value: metadataNode,
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_editor.ContentSelectorRenderer, { ...rest, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          import_markdown.MarkdownMetadataRenderer,
+          {
+            ...rest,
+            metadataKeyPath: props2.keyPath,
+            children: node
+          }
+        ) })
+      })
+    };
+    const metadataNodes = deepTransformNode(metadata, {
+      plugins: [metadataPlugins],
+      dictionaryKey: rest.dictionaryKey,
+      keyPath: []
+    });
+    return (0, import_IntlayerNode.renderIntlayerNode)({
+      ...props,
+      value: node,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_editor.ContentSelectorRenderer, { ...rest, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_markdown.MarkdownRenderer, { ...rest, children: node }) }),
+      additionalProps: {
+        metadata: metadataNodes
+      }
+    });
+  }
+};
+const markdownPlugin = {
+  id: "markdown-plugin",
+  canHandle: (node) => typeof node === "object" && node?.nodeType === import_core.NodeType.Markdown,
+  transform: (node, props, deepTransformNode) => {
+    const newKeyPath = [
+      ...props.keyPath,
+      {
+        type: import_core.NodeType.Markdown
+      }
+    ];
+    const children = node[import_core.NodeType.Markdown];
+    return deepTransformNode(children, {
+      ...props,
+      children,
+      keyPath: newKeyPath,
+      plugins: [markdownStringPlugin, ...props.plugins ?? []]
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  intlayerNodePlugins,
+  markdownPlugin,
+  markdownStringPlugin,
+  preactNodePlugins
+});
+//# sourceMappingURL=plugins.cjs.map

package/dist/cjs/plugins.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plugins.tsx"],"sourcesContent":["import {\n  KeyPath,\n  NodeType,\n  getMarkdownMetadata,\n  type DeepTransformContent as DeepTransformContentCore,\n  type IInterpreterPluginState as IInterpreterPluginStateCore,\n  type MarkdownContent,\n  type Plugins,\n} from '@intlayer/core';\nimport type { ComponentChildren } from 'preact';\nimport { renderIntlayerNode, type IntlayerNode } from './IntlayerNode';\nimport { ContentSelectorRenderer } from './editor';\nimport { EditedContentRenderer } from './editor/useEditedContentRenderer';\nimport { MarkdownMetadataRenderer, MarkdownRenderer } from './markdown';\nimport { renderPreactElement } from './preactElement/renderPreactElement';\n\n/** ---------------------------------------------\n *  INTLAYER NODE PLUGIN\n *  --------------------------------------------- */\n\nexport type IntlayerNodeCond<T> = T extends number | string\n  ? IntlayerNode<T>\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const intlayerNodePlugins: Plugins = {\n  id: 'intlayer-node-plugin',\n  canHandle: (node) =>\n    typeof node === 'bigint' ||\n    typeof node === 'string' ||\n    typeof node === 'number',\n  transform: (\n    _node,\n    {\n      plugins, // Removed to avoid next error - Functions cannot be passed directly to Client Components\n      ...rest\n    }\n  ) =>\n    renderIntlayerNode({\n      ...rest,\n      value: rest.children,\n      children: (\n        <ContentSelectorRenderer {...rest} key={rest.children}>\n          <EditedContentRenderer {...rest}>\n            {rest.children}\n          </EditedContentRenderer>\n        </ContentSelectorRenderer>\n      ),\n    }),\n};\n\n/** ---------------------------------------------\n *  PREACT NODE PLUGIN\n *  --------------------------------------------- */\n\nexport type PreactNodeCond<T> = T extends {\n  props: any;\n  key: any;\n}\n  ? ComponentChildren\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const preactNodePlugins: Plugins = {\n  id: 'preact-node-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' &&\n    typeof node.props !== 'undefined' &&\n    typeof node.key !== 'undefined',\n\n  transform: (\n    node,\n    {\n      plugins, // Removed to avoid next error - Functions cannot be passed directly to Client Components\n      ...rest\n    }\n  ) =>\n    renderIntlayerNode({\n      ...rest,\n      value: '[[preact-element]]',\n      children: (\n        <ContentSelectorRenderer {...rest}>\n          {renderPreactElement(node)}\n        </ContentSelectorRenderer>\n      ),\n    }),\n};\n\n/**\n * MARKDOWN PLUGIN\n */\n\nexport type MarkdownStringCond<T> = T extends string\n  ? IntlayerNode<string, { metadata: DeepTransformContent<string> }>\n  : never;\n\n/** Markdown string plugin. Replaces string node with a component that render the markdown. */\nexport const markdownStringPlugin: Plugins = {\n  id: 'markdown-string-plugin',\n  canHandle: (node) => typeof node === 'string',\n  transform: (node: string, props, deepTransformNode) => {\n    const {\n      plugins, // Removed to avoid next error - Functions cannot be passed directly to Client Components\n      ...rest\n    } = props;\n\n    const metadata = getMarkdownMetadata(node);\n\n    const metadataPlugins: Plugins = {\n      id: 'markdown-metadata-plugin',\n      canHandle: (metadataNode) =>\n        typeof metadataNode === 'string' ||\n        typeof metadataNode === 'number' ||\n        typeof metadataNode === 'boolean' ||\n        !metadataNode,\n      transform: (metadataNode, props) =>\n        renderIntlayerNode({\n          ...props,\n          value: metadataNode,\n          children: (\n            <ContentSelectorRenderer {...rest}>\n              <MarkdownMetadataRenderer\n                {...rest}\n                metadataKeyPath={props.keyPath}\n              >\n                {node}\n              </MarkdownMetadataRenderer>\n            </ContentSelectorRenderer>\n          ),\n        }),\n    };\n\n    // Transform metadata while keeping the same structure\n    const metadataNodes = deepTransformNode(metadata, {\n      plugins: [metadataPlugins],\n      dictionaryKey: rest.dictionaryKey,\n      keyPath: [],\n    });\n\n    return renderIntlayerNode({\n      ...props,\n      value: node,\n      children: (\n        <ContentSelectorRenderer {...rest}>\n          <MarkdownRenderer {...rest}>{node}</MarkdownRenderer>\n        </ContentSelectorRenderer>\n      ),\n      additionalProps: {\n        metadata: metadataNodes,\n      },\n    });\n  },\n};\n\nexport type MarkdownCond<T> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Markdown]: infer M;\n  metadata?: infer U;\n}\n  ? IntlayerNode<DeepTransformContent<M>, { metadata: DeepTransformContent<U> }>\n  : never;\n\nexport const markdownPlugin: Plugins = {\n  id: 'markdown-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Markdown,\n  transform: (node: MarkdownContent, props, deepTransformNode) => {\n    const newKeyPath: KeyPath[] = [\n      ...props.keyPath,\n      {\n        type: NodeType.Markdown,\n      },\n    ];\n\n    const children = node[NodeType.Markdown];\n\n    return deepTransformNode(children, {\n      ...props,\n      children,\n      keyPath: newKeyPath,\n      plugins: [markdownStringPlugin, ...(props.plugins ?? [])],\n    });\n  },\n};\n/** ---------------------------------------------\n *  PLUGINS RESULT\n *  --------------------------------------------- */\n\nexport interface IInterpreterPluginPreact<T> {\n  preactNode: PreactNodeCond<T>;\n  intlayerNode: IntlayerNodeCond<T>;\n  markdown: MarkdownCond<T>;\n}\n\n/**\n * Insert this type as param of `DeepTransformContent` to avoid `intlayer` package pollution.\n *\n * Otherwise the the `preact-intlayer` plugins will override the types of `intlayer` functions.\n */\nexport type IInterpreterPluginState = IInterpreterPluginStateCore & {\n  preactNode: true;\n  intlayerNode: true;\n  markdown: true;\n};\n\nexport type DeepTransformContent<T> = DeepTransformContentCore<\n  T,\n  IInterpreterPluginState\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2CU;AADF;AA1CR,kBAQO;AAEP,0BAAsD;AACtD,oBAAwC;AACxC,sCAAsC;AACtC,sBAA2D;AAC3D,iCAAoC;AAW7B,MAAM,sBAA+B;AAAA,EAC1C,IAAI;AAAA,EACJ,WAAW,CAAC,SACV,OAAO,SAAS,YAChB,OAAO,SAAS,YAChB,OAAO,SAAS;AAAA,EAClB,WAAW,CACT,OACA;AAAA,IACE;AAAA;AAAA,IACA,GAAG;AAAA,EACL,UAEA,wCAAmB;AAAA,IACjB,GAAG;AAAA,IACH,OAAO,KAAK;AAAA,IACZ,UACE,iDAAC,yCAAyB,GAAG,MAAM,KAAK,KAAK,YAC3C,4CAAC,yDAAuB,GAAG,MACxB,eAAK,UACR,CACF;AAAA,EAEJ,CAAC;AACL;AAcO,MAAM,oBAA6B;AAAA,EACxC,IAAI;AAAA,EACJ,WAAW,CAAC,SACV,OAAO,SAAS,YAChB,OAAO,KAAK,UAAU,eACtB,OAAO,KAAK,QAAQ;AAAA,EAEtB,WAAW,CACT,MACA;AAAA,IACE;AAAA;AAAA,IACA,GAAG;AAAA,EACL,UAEA,wCAAmB;AAAA,IACjB,GAAG;AAAA,IACH,OAAO;AAAA,IACP,UACE,4CAAC,yCAAyB,GAAG,MAC1B,8DAAoB,IAAI,GAC3B;AAAA,EAEJ,CAAC;AACL;AAWO,MAAM,uBAAgC;AAAA,EAC3C,IAAI;AAAA,EACJ,WAAW,CAAC,SAAS,OAAO,SAAS;AAAA,EACrC,WAAW,CAAC,MAAc,OAAO,sBAAsB;AACrD,UAAM;AAAA,MACJ;AAAA;AAAA,MACA,GAAG;AAAA,IACL,IAAI;AAEJ,UAAM,eAAW,iCAAoB,IAAI;AAEzC,UAAM,kBAA2B;AAAA,MAC/B,IAAI;AAAA,MACJ,WAAW,CAAC,iBACV,OAAO,iBAAiB,YACxB,OAAO,iBAAiB,YACxB,OAAO,iBAAiB,aACxB,CAAC;AAAA,MACH,WAAW,CAAC,cAAcA,eACxB,wCAAmB;AAAA,QACjB,GAAGA;AAAA,QACH,OAAO;AAAA,QACP,UACE,4CAAC,yCAAyB,GAAG,MAC3B;AAAA,UAAC;AAAA;AAAA,YACE,GAAG;AAAA,YACJ,iBAAiBA,OAAM;AAAA,YAEtB;AAAA;AAAA,QACH,GACF;AAAA,MAEJ,CAAC;AAAA,IACL;AAGA,UAAM,gBAAgB,kBAAkB,UAAU;AAAA,MAChD,SAAS,CAAC,eAAe;AAAA,MACzB,eAAe,KAAK;AAAA,MACpB,SAAS,CAAC;AAAA,IACZ,CAAC;AAED,eAAO,wCAAmB;AAAA,MACxB,GAAG;AAAA,MACH,OAAO;AAAA,MACP,UACE,4CAAC,yCAAyB,GAAG,MAC3B,sDAAC,oCAAkB,GAAG,MAAO,gBAAK,GACpC;AAAA,MAEF,iBAAiB;AAAA,QACf,UAAU;AAAA,MACZ;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAUO,MAAM,iBAA0B;AAAA,EACrC,IAAI;AAAA,EACJ,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,qBAAS;AAAA,EAC1D,WAAW,CAAC,MAAuB,OAAO,sBAAsB;AAC9D,UAAM,aAAwB;AAAA,MAC5B,GAAG,MAAM;AAAA,MACT;AAAA,QACE,MAAM,qBAAS;AAAA,MACjB;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,qBAAS,QAAQ;AAEvC,WAAO,kBAAkB,UAAU;AAAA,MACjC,GAAG;AAAA,MACH;AAAA,MACA,SAAS;AAAA,MACT,SAAS,CAAC,sBAAsB,GAAI,MAAM,WAAW,CAAC,CAAE;AAAA,IAC1D,CAAC;AAAA,EACH;AACF;","names":["props"]}

package/dist/cjs/preactElement/renderPreactElement.cjs

@@ -0,0 +1,62 @@
+"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 renderPreactElement_exports = {};
+__export(renderPreactElement_exports, {
+  renderPreactElement: () => renderPreactElement
+});
+module.exports = __toCommonJS(renderPreactElement_exports);
+var import_compat = require("preact/compat");
+const renderPreactElement = (element) => {
+  if (typeof element === "string") {
+    return element;
+  }
+  const convertChildrenAsArray = (element2) => {
+    if (element2?.props && typeof element2.props.children === "object") {
+      const childrenResult = [];
+      const { children } = element2.props;
+      Object.keys(children ?? {}).forEach((key) => {
+        childrenResult.push(
+          renderPreactElement((children ?? {})[key])
+        );
+      });
+      return {
+        ...element2,
+        props: { ...element2.props, children: childrenResult }
+      };
+    }
+    return {
+      ...element2,
+      props: { ...element2.props, children: element2.props?.children ?? [] }
+    };
+  };
+  const fixedElement = convertChildrenAsArray(
+    element
+  );
+  const { type, props } = fixedElement;
+  return (0, import_compat.createElement)(
+    type ?? "span",
+    props,
+    ...props.children
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderPreactElement
+});
+//# sourceMappingURL=renderPreactElement.cjs.map

package/dist/cjs/preactElement/renderPreactElement.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/preactElement/renderPreactElement.ts"],"sourcesContent":["import { type ComponentChild, type VNode } from 'preact';\nimport { createElement } from 'preact/compat';\n\n// This function recursively creates Preact elements from a given JSON-like structure\nexport const renderPreactElement = (element: VNode<any>) => {\n  if (typeof element === 'string') {\n    // If it's a string, simply return it (used for text content)\n    return element;\n  }\n\n  const convertChildrenAsArray = (\n    element: VNode<{ children?: ComponentChild | ComponentChild[] }>\n  ): VNode<{ children?: ComponentChild | ComponentChild[] }> => {\n    if (element?.props && typeof element.props.children === 'object') {\n      const childrenResult: ComponentChild[] = [];\n      const { children } = element.props;\n\n      // Create the children elements recursively, if any\n      Object.keys(children ?? {}).forEach((key) => {\n        childrenResult.push(\n          renderPreactElement((children ?? {})[key as keyof typeof children])\n        );\n      });\n\n      return {\n        ...element,\n        props: { ...element.props, children: childrenResult },\n      };\n    }\n\n    return {\n      ...element,\n      props: { ...element.props, children: element.props?.children ?? [] },\n    };\n  };\n\n  const fixedElement = convertChildrenAsArray(\n    element as VNode<{ children?: ComponentChild | ComponentChild[] }>\n  );\n\n  const { type, props } = fixedElement;\n\n  // Create and return the Preact element\n  return createElement(\n    type ?? 'span',\n    props,\n    ...(props.children as ComponentChild[])\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAA8B;AAGvB,MAAM,sBAAsB,CAAC,YAAwB;AAC1D,MAAI,OAAO,YAAY,UAAU;AAE/B,WAAO;AAAA,EACT;AAEA,QAAM,yBAAyB,CAC7BA,aAC4D;AAC5D,QAAIA,UAAS,SAAS,OAAOA,SAAQ,MAAM,aAAa,UAAU;AAChE,YAAM,iBAAmC,CAAC;AAC1C,YAAM,EAAE,SAAS,IAAIA,SAAQ;AAG7B,aAAO,KAAK,YAAY,CAAC,CAAC,EAAE,QAAQ,CAAC,QAAQ;AAC3C,uBAAe;AAAA,UACb,qBAAqB,YAAY,CAAC,GAAG,GAA4B,CAAC;AAAA,QACpE;AAAA,MACF,CAAC;AAED,aAAO;AAAA,QACL,GAAGA;AAAA,QACH,OAAO,EAAE,GAAGA,SAAQ,OAAO,UAAU,eAAe;AAAA,MACtD;AAAA,IACF;AAEA,WAAO;AAAA,MACL,GAAGA;AAAA,MACH,OAAO,EAAE,GAAGA,SAAQ,OAAO,UAAUA,SAAQ,OAAO,YAAY,CAAC,EAAE;AAAA,IACrE;AAAA,EACF;AAEA,QAAM,eAAe;AAAA,IACnB;AAAA,EACF;AAEA,QAAM,EAAE,MAAM,MAAM,IAAI;AAGxB,aAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA,GAAI,MAAM;AAAA,EACZ;AACF;","names":["element"]}

package/dist/esm/IntlayerNode.mjs

@@ -0,0 +1,27 @@
+import {
+  Fragment,
+  h,
+  isValidElement
+} from "preact";
+const renderIntlayerNode = ({
+  children,
+  value,
+  additionalProps
+}) => {
+  const element = isValidElement(children) ? children : h(Fragment, {}, children);
+  return new Proxy(element, {
+    get(target, prop, receiver) {
+      if (prop === "value") {
+        return value;
+      }
+      if (additionalProps && Object.keys(additionalProps).includes(prop)) {
+        return additionalProps[prop];
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+};
+export {
+  renderIntlayerNode
+};
+//# sourceMappingURL=IntlayerNode.mjs.map