@intlayer/core 5.8.1-canary.0 → 6.0.0-canary.0

package/dist/cjs/deepTranformPlugins/getFilterTranslationsOnlyContent.cjs

@@ -0,0 +1,130 @@
+"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 getFilterTranslationsOnlyContent_exports = {};
+__export(getFilterTranslationsOnlyContent_exports, {
+  filterTranslationsOnlyPlugin: () => filterTranslationsOnlyPlugin,
+  getFilterTranslationsOnlyContent: () => getFilterTranslationsOnlyContent
+});
+module.exports = __toCommonJS(getFilterTranslationsOnlyContent_exports);
+var import_built = __toESM(require("@intlayer/config/built"));
+var import_interpreter = require('../interpreter/index.cjs');
+var import_deepTransform = require('../interpreter/getContent/deepTransform.cjs');
+var import_types = require('../types/index.cjs');
+const hasTranslationNodes = (node) => {
+  if (typeof node !== "object" || node === null) {
+    return false;
+  }
+  if (node?.nodeType === import_types.NodeType.Translation) {
+    return true;
+  }
+  if (Array.isArray(node)) {
+    return node.some(hasTranslationNodes);
+  }
+  return Object.values(node).some(hasTranslationNodes);
+};
+const filterTranslationsOnlyPlugin = (locale, fallback) => ({
+  id: "filter-translations-only-plugin",
+  canHandle: (node) => {
+    return typeof node === "object" && node !== null;
+  },
+  transform: (node, props, deepTransformNode2) => {
+    if (typeof node === "object" && node?.nodeType === import_types.NodeType.Translation) {
+      const result = structuredClone(
+        node[import_types.NodeType.Translation]
+      );
+      for (const key in result) {
+        const childProps = {
+          ...props,
+          children: result[key],
+          keyPath: [
+            ...props.keyPath,
+            { type: import_types.NodeType.Translation, key }
+          ]
+        };
+        result[key] = deepTransformNode2(
+          result[key],
+          {
+            ...childProps,
+            plugins: [
+              ...(props.plugins ?? []).filter(
+                (plugin) => plugin.id !== "filter-translations-only-plugin"
+              )
+            ]
+          }
+        );
+      }
+      return (0, import_interpreter.getTranslation)(result, locale, fallback);
+    } else if (typeof node === "object" && node !== null && !Array.isArray(node) && !node?.nodeType) {
+      const result = {};
+      for (const key in node) {
+        if (hasTranslationNodes(node[key])) {
+          const childProps = {
+            ...props,
+            children: node[key],
+            keyPath: [
+              ...props.keyPath,
+              { type: import_types.NodeType.Object, key }
+            ]
+          };
+          result[key] = deepTransformNode2(node[key], childProps);
+        }
+      }
+      return result;
+    } else if (Array.isArray(node)) {
+      return node.map((child, index) => {
+        const childProps = {
+          ...props,
+          children: child,
+          keyPath: [
+            ...props.keyPath,
+            { type: import_types.NodeType.Array, key: index }
+          ]
+        };
+        return deepTransformNode2(child, childProps);
+      });
+    }
+    return "to remove from the object";
+  }
+});
+const getFilterTranslationsOnlyContent = (node, locale = import_built.default?.internationalization.defaultLocale, nodeProps, fallback) => {
+  const plugins = [
+    filterTranslationsOnlyPlugin(locale, fallback),
+    ...nodeProps.plugins ?? []
+  ];
+  return (0, import_deepTransform.deepTransformNode)(node, {
+    ...nodeProps,
+    plugins
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterTranslationsOnlyPlugin,
+  getFilterTranslationsOnlyContent
+});
+//# sourceMappingURL=getFilterTranslationsOnlyContent.cjs.map

package/dist/cjs/deepTranformPlugins/getFilterTranslationsOnlyContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/deepTranformPlugins/getFilterTranslationsOnlyContent.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { Locales, LocalesValues } from '@intlayer/config/client';\nimport { getTranslation } from '../interpreter';\nimport { deepTransformNode } from '../interpreter/getContent/deepTransform';\nimport {\n  type DeepTransformContent,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter/getContent/plugins';\nimport { TranslationContent } from '../transpiler';\nimport { KeyPath, NodeType, type ContentNode } from '../types';\n\n/**\n * Helper function to check if a node or its children contain translation nodes\n */\nconst hasTranslationNodes = (node: any): boolean => {\n  if (typeof node !== 'object' || node === null) {\n    return false;\n  }\n\n  if (node?.nodeType === NodeType.Translation) {\n    return true;\n  }\n\n  if (Array.isArray(node)) {\n    return node.some(hasTranslationNodes);\n  }\n\n  return Object.values(node).some(hasTranslationNodes);\n};\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const filterTranslationsOnlyPlugin = (\n  locale: LocalesValues,\n  fallback?: LocalesValues\n): Plugins => ({\n  id: 'filter-translations-only-plugin',\n  canHandle: (node: ContentNode) => {\n    // Only handle objects and arrays, not primitives\n    return typeof node === 'object' && node !== null;\n  },\n  transform: (node: ContentNode, props, deepTransformNode) => {\n    if (typeof node === 'object' && node?.nodeType === NodeType.Translation) {\n      const result = structuredClone(\n        (node as TranslationContent)[NodeType.Translation]\n      );\n\n      for (const key in result) {\n        const childProps = {\n          ...props,\n          children: result[key as unknown as keyof typeof result],\n          keyPath: [\n            ...props.keyPath,\n            { type: NodeType.Translation, key } as KeyPath,\n          ],\n        };\n        result[key as unknown as keyof typeof result] = deepTransformNode(\n          result[key as unknown as keyof typeof result],\n          {\n            ...childProps,\n            plugins: [\n              ...(props.plugins ?? ([] as Plugins[])).filter(\n                (plugin) => plugin.id !== 'filter-translations-only-plugin'\n              ),\n            ],\n          }\n        );\n      }\n      return getTranslation(result, locale, fallback);\n    } else if (\n      typeof node === 'object' &&\n      node !== null &&\n      !Array.isArray(node) &&\n      !node?.nodeType\n    ) {\n      // For regular objects, filter out properties that don't contain translations\n      const result: Record<string, any> = {};\n      for (const key in node as any) {\n        if (hasTranslationNodes(node[key])) {\n          const childProps = {\n            ...props,\n            children: node[key],\n            keyPath: [\n              ...props.keyPath,\n              { type: NodeType.Object, key } as KeyPath,\n            ],\n          };\n          result[key] = deepTransformNode(node[key], childProps);\n        }\n      }\n      return result;\n    } else if (Array.isArray(node)) {\n      // For arrays, keep all items but transform them\n      return node.map((child, index) => {\n        const childProps = {\n          ...props,\n          children: child,\n          keyPath: [\n            ...props.keyPath,\n            { type: NodeType.Array, key: index } as KeyPath,\n          ],\n        };\n        return deepTransformNode(child, childProps);\n      });\n    }\n\n    return 'to remove from the object';\n  },\n});\n\n/**\n * Return the content of a node with only the translation plugin.\n *\n * @param node The node to transform.\n * @param locale The locale to use if your transformers need it (e.g. for translations).\n */\nexport const getFilterTranslationsOnlyContent = <\n  T extends ContentNode,\n  L extends LocalesValues = Locales,\n>(\n  node: T,\n  locale: L = configuration?.internationalization.defaultLocale as L,\n  nodeProps: NodeProps,\n  fallback?: LocalesValues\n) => {\n  const plugins: Plugins[] = [\n    filterTranslationsOnlyPlugin(locale, fallback),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  return deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  }) as DeepTransformContent<T>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAE1B,yBAA+B;AAC/B,2BAAkC;AAOlC,mBAAoD;AAKpD,MAAM,sBAAsB,CAAC,SAAuB;AAClD,MAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,aAAa,sBAAS,aAAa;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,WAAO,KAAK,KAAK,mBAAmB;AAAA,EACtC;AAEA,SAAO,OAAO,OAAO,IAAI,EAAE,KAAK,mBAAmB;AACrD;AAGO,MAAM,+BAA+B,CAC1C,QACA,cACa;AAAA,EACb,IAAI;AAAA,EACJ,WAAW,CAAC,SAAsB;AAEhC,WAAO,OAAO,SAAS,YAAY,SAAS;AAAA,EAC9C;AAAA,EACA,WAAW,CAAC,MAAmB,OAAOA,uBAAsB;AAC1D,QAAI,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS,aAAa;AACvE,YAAM,SAAS;AAAA,QACZ,KAA4B,sBAAS,WAAW;AAAA,MACnD;AAEA,iBAAW,OAAO,QAAQ;AACxB,cAAM,aAAa;AAAA,UACjB,GAAG;AAAA,UACH,UAAU,OAAO,GAAqC;AAAA,UACtD,SAAS;AAAA,YACP,GAAG,MAAM;AAAA,YACT,EAAE,MAAM,sBAAS,aAAa,IAAI;AAAA,UACpC;AAAA,QACF;AACA,eAAO,GAAqC,IAAIA;AAAA,UAC9C,OAAO,GAAqC;AAAA,UAC5C;AAAA,YACE,GAAG;AAAA,YACH,SAAS;AAAA,cACP,IAAI,MAAM,WAAY,CAAC,GAAiB;AAAA,gBACtC,CAAC,WAAW,OAAO,OAAO;AAAA,cAC5B;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF;AACA,iBAAO,mCAAe,QAAQ,QAAQ,QAAQ;AAAA,IAChD,WACE,OAAO,SAAS,YAChB,SAAS,QACT,CAAC,MAAM,QAAQ,IAAI,KACnB,CAAC,MAAM,UACP;AAEA,YAAM,SAA8B,CAAC;AACrC,iBAAW,OAAO,MAAa;AAC7B,YAAI,oBAAoB,KAAK,GAAG,CAAC,GAAG;AAClC,gBAAM,aAAa;AAAA,YACjB,GAAG;AAAA,YACH,UAAU,KAAK,GAAG;AAAA,YAClB,SAAS;AAAA,cACP,GAAG,MAAM;AAAA,cACT,EAAE,MAAM,sBAAS,QAAQ,IAAI;AAAA,YAC/B;AAAA,UACF;AACA,iBAAO,GAAG,IAAIA,mBAAkB,KAAK,GAAG,GAAG,UAAU;AAAA,QACvD;AAAA,MACF;AACA,aAAO;AAAA,IACT,WAAW,MAAM,QAAQ,IAAI,GAAG;AAE9B,aAAO,KAAK,IAAI,CAAC,OAAO,UAAU;AAChC,cAAM,aAAa;AAAA,UACjB,GAAG;AAAA,UACH,UAAU;AAAA,UACV,SAAS;AAAA,YACP,GAAG,MAAM;AAAA,YACT,EAAE,MAAM,sBAAS,OAAO,KAAK,MAAM;AAAA,UACrC;AAAA,QACF;AACA,eAAOA,mBAAkB,OAAO,UAAU;AAAA,MAC5C,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AACF;AAQO,MAAM,mCAAmC,CAI9C,MACA,SAAY,aAAAC,SAAe,qBAAqB,eAChD,WACA,aACG;AACH,QAAM,UAAqB;AAAA,IACzB,6BAA6B,QAAQ,QAAQ;AAAA,IAC7C,GAAI,UAAU,WAAW,CAAC;AAAA,EAC5B;AAEA,aAAO,wCAAkB,MAAM;AAAA,IAC7B,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AACH;","names":["deepTransformNode","configuration"]}

package/dist/cjs/deepTranformPlugins/getFilteredLocalesContent.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 getFilteredLocalesContent_exports = {};
+__export(getFilteredLocalesContent_exports, {
+  getFilteredLocalesContent: () => getFilteredLocalesContent
+});
+module.exports = __toCommonJS(getFilteredLocalesContent_exports);
+var import_interpreter = require('../interpreter/index.cjs');
+var import_types = require('../types/index.cjs');
+const filterTranlationsPlugin = (locales) => ({
+  id: "filter-translations-plugin",
+  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Translation,
+  transform: (node, props, deepTransformNode2) => {
+    const translationMap = node.translation;
+    const filteredTranslationMap = Object.fromEntries(
+      Object.entries(translationMap).filter(
+        ([key]) => locales.includes(key)
+      )
+    );
+    return {
+      ...node,
+      translation: deepTransformNode2(filteredTranslationMap, {
+        ...props,
+        keyPath: [
+          ...props.keyPath,
+          { type: import_types.NodeType.Object, key: import_types.NodeType.Translation }
+        ]
+      })
+    };
+  }
+});
+const getFilteredLocalesContent = (node, locale, nodeProps) => {
+  const plugins = [
+    filterTranlationsPlugin(locale),
+    ...nodeProps.plugins ?? []
+  ];
+  return (0, import_interpreter.deepTransformNode)(node, {
+    ...nodeProps,
+    plugins
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFilteredLocalesContent
+});
+//# sourceMappingURL=getFilteredLocalesContent.cjs.map

package/dist/cjs/deepTranformPlugins/getFilteredLocalesContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/deepTranformPlugins/getFilteredLocalesContent.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config/client';\nimport {\n  type NodeProps,\n  type Plugins,\n  deepTransformNode,\n} from '../interpreter';\nimport { type ContentNode, NodeType } from '../types';\n\nconst filterTranlationsPlugin = (\n  locales: LocalesValues[] | LocalesValues\n): Plugins => ({\n  id: 'filter-translations-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Translation,\n  transform: (node, props, deepTransformNode) => {\n    const translationMap = node.translation as Record<Locales, string>;\n\n    const filteredTranslationMap = Object.fromEntries(\n      Object.entries(translationMap).filter(([key]) =>\n        locales.includes(key as Locales)\n      )\n    );\n\n    return {\n      ...node,\n      translation: deepTransformNode(filteredTranslationMap, {\n        ...props,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Object, key: NodeType.Translation },\n        ],\n      }),\n    };\n  },\n});\n\nexport const getFilteredLocalesContent = (\n  node: ContentNode,\n  locale: LocalesValues | LocalesValues[],\n  nodeProps: NodeProps\n) => {\n  const plugins: Plugins[] = [\n    filterTranlationsPlugin(locale),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  return deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,yBAIO;AACP,mBAA2C;AAE3C,MAAM,0BAA0B,CAC9B,aACa;AAAA,EACb,IAAI;AAAA,EACJ,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAAM,OAAOA,uBAAsB;AAC7C,UAAM,iBAAiB,KAAK;AAE5B,UAAM,yBAAyB,OAAO;AAAA,MACpC,OAAO,QAAQ,cAAc,EAAE;AAAA,QAAO,CAAC,CAAC,GAAG,MACzC,QAAQ,SAAS,GAAc;AAAA,MACjC;AAAA,IACF;AAEA,WAAO;AAAA,MACL,GAAG;AAAA,MACH,aAAaA,mBAAkB,wBAAwB;AAAA,QACrD,GAAG;AAAA,QACH,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,QAAQ,KAAK,sBAAS,YAAY;AAAA,QACrD;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEO,MAAM,4BAA4B,CACvC,MACA,QACA,cACG;AACH,QAAM,UAAqB;AAAA,IACzB,wBAAwB,MAAM;AAAA,IAC9B,GAAI,UAAU,WAAW,CAAC;AAAA,EAC5B;AAEA,aAAO,sCAAkB,MAAM;AAAA,IAC7B,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AACH;","names":["deepTransformNode"]}

package/dist/cjs/{interpreter/getContent → deepTranformPlugins}/getLocalisedContent.cjs

@@ -32,9 +32,9 @@ __export(getLocalisedContent_exports, {
 });
 module.exports = __toCommonJS(getLocalisedContent_exports);
 var import_built = __toESM(require("@intlayer/config/built"));
-var import_deepTransform = require('./deepTransform.cjs');
-var import_plugins = require('./plugins.cjs');
-const getLocalisedContent = (node, locale = import_built.default?.internationalization.defaultLocale, nodeProps, fallback = false) => {
+var import_deepTransform = require('../interpreter/getContent/deepTransform.cjs');
+var import_plugins = require('../interpreter/getContent/plugins.cjs');
+const getLocalisedContent = (node, locale = import_built.default?.internationalization.defaultLocale, nodeProps, fallback) => {
   const plugins = [
     (0, import_plugins.translationPlugin)(locale, fallback),
     ...nodeProps.plugins ?? []

package/dist/cjs/deepTranformPlugins/getLocalisedContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/deepTranformPlugins/getLocalisedContent.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { Locales, LocalesValues } from '@intlayer/config/client';\nimport { deepTransformNode } from '../interpreter/getContent/deepTransform';\nimport {\n  translationPlugin,\n  type DeepTransformContent,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter/getContent/plugins';\nimport type { ContentNode } from '../types';\n\n/**\n * Transforms a node in a single pass, applying each plugin as needed.\n * In comparison to `getContent`, this function will only apply the translation plugin.\n * It will not transform enumerations, insertions, or other content types.\n *\n * @param node The node to transform.\n * @param locale The locale to use if your transformers need it (e.g. for translations).\n */\nexport const getLocalisedContent = <\n  T extends ContentNode,\n  L extends LocalesValues = Locales,\n>(\n  node: T,\n  locale: L = configuration?.internationalization.defaultLocale as L,\n  nodeProps: NodeProps,\n  fallback?: LocalesValues // fallback mean that if field is not translated, it will use the default locale\n) => {\n  const plugins: Plugins[] = [\n    translationPlugin(locale, fallback),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  return deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  }) as DeepTransformContent<T>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAE1B,2BAAkC;AAClC,qBAKO;AAWA,MAAM,sBAAsB,CAIjC,MACA,SAAY,aAAAA,SAAe,qBAAqB,eAChD,WACA,aACG;AACH,QAAM,UAAqB;AAAA,QACzB,kCAAkB,QAAQ,QAAQ;AAAA,IAClC,GAAI,UAAU,WAAW,CAAC;AAAA,EAC5B;AAEA,aAAO,wCAAkB,MAAM;AAAA,IAC7B,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AACH;","names":["configuration"]}

package/dist/cjs/deepTranformPlugins/getMissingLocalesContent.cjs

@@ -0,0 +1,78 @@
+"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 getMissingLocalesContent_exports = {};
+__export(getMissingLocalesContent_exports, {
+  checkMissingLocalesPlugin: () => checkMissingLocalesPlugin,
+  getMissingLocalesContent: () => getMissingLocalesContent
+});
+module.exports = __toCommonJS(getMissingLocalesContent_exports);
+var import_built = __toESM(require("@intlayer/config/built"));
+var import_deepTransform = require('../interpreter/getContent/deepTransform.cjs');
+var import_types = require('../types/index.cjs');
+const checkMissingLocalesPlugin = (locales, onMissingLocale) => ({
+  id: "check-missing-locales-plugin",
+  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Translation,
+  transform: (node, props, deepTransformNode2) => {
+    for (const locale of locales) {
+      if (!node[import_types.NodeType.Translation][locale]) {
+        onMissingLocale(locale);
+      }
+    }
+    const translations = node[import_types.NodeType.Translation];
+    for (const key in translations) {
+      const child = translations[key];
+      deepTransformNode2(child, {
+        ...props,
+        children: child
+      });
+    }
+    return node;
+  }
+});
+const getMissingLocalesContent = (node, locales = import_built.default?.internationalization.locales, nodeProps) => {
+  const missingLocales = /* @__PURE__ */ new Set();
+  const plugins = [
+    checkMissingLocalesPlugin(
+      locales,
+      (locale) => missingLocales.add(locale)
+    ),
+    ...nodeProps.plugins ?? []
+  ];
+  (0, import_deepTransform.deepTransformNode)(node, {
+    ...nodeProps,
+    plugins
+  });
+  return Array.from(missingLocales);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkMissingLocalesPlugin,
+  getMissingLocalesContent
+});
+//# sourceMappingURL=getMissingLocalesContent.cjs.map

package/dist/cjs/deepTranformPlugins/getMissingLocalesContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/deepTranformPlugins/getMissingLocalesContent.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { Locales, LocalesValues } from '@intlayer/config/client';\nimport { deepTransformNode } from '../interpreter/getContent/deepTransform';\nimport {\n  type DeepTransformContent,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter/getContent/plugins';\nimport { TranslationContent } from '../transpiler';\nimport { NodeType, type ContentNode } from '../types';\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const checkMissingLocalesPlugin = (\n  locales: Locales[],\n  onMissingLocale: (locale: Locales) => void\n): Plugins => ({\n  id: 'check-missing-locales-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Translation,\n  transform: (node: TranslationContent, props, deepTransformNode) => {\n    for (const locale of locales) {\n      if (\n        !node[NodeType.Translation][\n          locale as keyof (typeof node)[NodeType.Translation]\n        ]\n      ) {\n        onMissingLocale(locale);\n      }\n    }\n\n    // Continue traversal inside the translation values, but avoid re-applying this plugin on the same node\n    const translations = node[NodeType.Translation] as Record<string, any>;\n    for (const key in translations) {\n      const child = translations[key];\n      deepTransformNode(child, {\n        ...props,\n        children: child,\n      });\n    }\n\n    // Return the original node; the return value is ignored by the caller\n    return node;\n  },\n});\n\n/**\n * Return the content of a node with only the translation plugin.\n *\n * @param node The node to transform.\n * @param locales The locales to check for missing translations.\n */\nexport const getMissingLocalesContent = <T extends ContentNode>(\n  node: T,\n  locales: LocalesValues[] = configuration?.internationalization.locales,\n  nodeProps: NodeProps\n): Locales[] => {\n  const missingLocales = new Set<Locales>();\n\n  const plugins: Plugins[] = [\n    checkMissingLocalesPlugin(locales as Locales[], (locale) =>\n      missingLocales.add(locale)\n    ),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  }) as DeepTransformContent<T>;\n\n  return Array.from(missingLocales);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAE1B,2BAAkC;AAOlC,mBAA2C;AAGpC,MAAM,4BAA4B,CACvC,SACA,qBACa;AAAA,EACb,IAAI;AAAA,EACJ,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAA0B,OAAOA,uBAAsB;AACjE,eAAW,UAAU,SAAS;AAC5B,UACE,CAAC,KAAK,sBAAS,WAAW,EACxB,MACF,GACA;AACA,wBAAgB,MAAM;AAAA,MACxB;AAAA,IACF;AAGA,UAAM,eAAe,KAAK,sBAAS,WAAW;AAC9C,eAAW,OAAO,cAAc;AAC9B,YAAM,QAAQ,aAAa,GAAG;AAC9B,MAAAA,mBAAkB,OAAO;AAAA,QACvB,GAAG;AAAA,QACH,UAAU;AAAA,MACZ,CAAC;AAAA,IACH;AAGA,WAAO;AAAA,EACT;AACF;AAQO,MAAM,2BAA2B,CACtC,MACA,UAA2B,aAAAC,SAAe,qBAAqB,SAC/D,cACc;AACd,QAAM,iBAAiB,oBAAI,IAAa;AAExC,QAAM,UAAqB;AAAA,IACzB;AAAA,MAA0B;AAAA,MAAsB,CAAC,WAC/C,eAAe,IAAI,MAAM;AAAA,IAC3B;AAAA,IACA,GAAI,UAAU,WAAW,CAAC;AAAA,EAC5B;AAEA,8CAAkB,MAAM;AAAA,IACtB,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AAED,SAAO,MAAM,KAAK,cAAc;AAClC;","names":["deepTransformNode","configuration"]}

package/dist/cjs/deepTranformPlugins/getReplacedValuesContent.cjs

@@ -0,0 +1,82 @@
+"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 getReplacedValuesContent_exports = {};
+__export(getReplacedValuesContent_exports, {
+  getReplacedValuesContent: () => getReplacedValuesContent
+});
+module.exports = __toCommonJS(getReplacedValuesContent_exports);
+var import_interpreter = require('../interpreter/index.cjs');
+const replaceValuesPlugin = (value) => ({
+  id: "replace-values-plugin",
+  canHandle: (node) => typeof node === "string" || typeof node === "number" || typeof node === "boolean",
+  transform: () => value
+});
+const skipTypedNodePlugin = {
+  id: "skip-typed-node-plugin",
+  canHandle: (node) => typeof node === "object" && typeof node?.nodeType === "string",
+  transform: (node, props, deepTransformNode2) => {
+    const nodeType = node.nodeType;
+    const result = structuredClone(
+      node[nodeType]
+    );
+    if (typeof result !== "object" || result === null) {
+      const transformedResult = deepTransformNode2(result, {
+        ...props,
+        children: result,
+        keyPath: [
+          ...props.keyPath,
+          { type: nodeType, key: nodeType }
+        ]
+      });
+      return {
+        ...node,
+        [nodeType]: transformedResult
+      };
+    }
+    for (const key in result) {
+      const childProps = {
+        ...props,
+        children: result[key],
+        keyPath: [...props.keyPath, { type: nodeType, key }]
+      };
+      result[key] = deepTransformNode2(
+        result[key],
+        childProps
+      );
+    }
+    return { ...node, [nodeType]: result };
+  }
+};
+const getReplacedValuesContent = (node, value, nodeProps) => {
+  const plugins = [
+    skipTypedNodePlugin,
+    replaceValuesPlugin(value),
+    ...nodeProps.plugins ?? []
+  ];
+  const JSONNode = JSON.parse(JSON.stringify(node));
+  return (0, import_interpreter.deepTransformNode)(JSONNode, {
+    ...nodeProps,
+    plugins
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getReplacedValuesContent
+});
+//# sourceMappingURL=getReplacedValuesContent.cjs.map

package/dist/cjs/deepTranformPlugins/getReplacedValuesContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/deepTranformPlugins/getReplacedValuesContent.ts"],"sourcesContent":["import {\n  deepTransformNode,\n  type NodeProps,\n  type Plugins,\n} from '../interpreter';\nimport { KeyPath, NodeType, TypedNode, type ContentNode } from '../types';\n\nconst replaceValuesPlugin = (value: string | number | boolean): Plugins => ({\n  id: 'replace-values-plugin',\n  canHandle: (node) =>\n    typeof node === 'string' ||\n    typeof node === 'number' ||\n    typeof node === 'boolean',\n  transform: () => value,\n});\n\nconst skipTypedNodePlugin: Plugins = {\n  id: 'skip-typed-node-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && typeof node?.nodeType === 'string',\n  transform: (node: TypedNode, props, deepTransformNode) => {\n    const nodeType = node.nodeType as NodeType;\n    const result = structuredClone(\n      node[nodeType as unknown as keyof TypedNode] as any\n    );\n\n    // If the result is a primitive value (string, number, boolean),\n    // we need to transform it directly instead of iterating over its properties\n    if (typeof result !== 'object' || result === null) {\n      const transformedResult = deepTransformNode(result, {\n        ...props,\n        children: result,\n        keyPath: [\n          ...props.keyPath,\n          { type: nodeType, key: nodeType } as KeyPath,\n        ],\n      });\n      return {\n        ...node,\n        [nodeType as unknown as keyof TypedNode]: transformedResult,\n      };\n    }\n\n    // For objects and arrays, iterate over their properties\n    for (const key in result) {\n      const childProps = {\n        ...props,\n        children: result[key as unknown as keyof typeof result],\n        keyPath: [...props.keyPath, { type: nodeType, key } as KeyPath],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        result[key as unknown as keyof typeof result],\n        childProps\n      );\n    }\n\n    return { ...node, [nodeType as unknown as keyof TypedNode]: result };\n  },\n};\n\nexport const getReplacedValuesContent = (\n  node: ContentNode,\n  value: string | number | boolean,\n  nodeProps: NodeProps\n) => {\n  const plugins: Plugins[] = [\n    skipTypedNodePlugin,\n    replaceValuesPlugin(value),\n    ...(nodeProps.plugins ?? []),\n  ];\n\n  const JSONNode = JSON.parse(JSON.stringify(node));\n\n  return deepTransformNode(JSONNode, {\n    ...nodeProps,\n    plugins,\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAIO;AAGP,MAAM,sBAAsB,CAAC,WAA+C;AAAA,EAC1E,IAAI;AAAA,EACJ,WAAW,CAAC,SACV,OAAO,SAAS,YAChB,OAAO,SAAS,YAChB,OAAO,SAAS;AAAA,EAClB,WAAW,MAAM;AACnB;AAEA,MAAM,sBAA+B;AAAA,EACnC,IAAI;AAAA,EACJ,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,OAAO,MAAM,aAAa;AAAA,EACxD,WAAW,CAAC,MAAiB,OAAOA,uBAAsB;AACxD,UAAM,WAAW,KAAK;AACtB,UAAM,SAAS;AAAA,MACb,KAAK,QAAsC;AAAA,IAC7C;AAIA,QAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,YAAM,oBAAoBA,mBAAkB,QAAQ;AAAA,QAClD,GAAG;AAAA,QACH,UAAU;AAAA,QACV,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,UAAU,KAAK,SAAS;AAAA,QAClC;AAAA,MACF,CAAC;AACD,aAAO;AAAA,QACL,GAAG;AAAA,QACH,CAAC,QAAsC,GAAG;AAAA,MAC5C;AAAA,IACF;AAGA,eAAW,OAAO,QAAQ;AACxB,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,UAAU,OAAO,GAAqC;AAAA,QACtD,SAAS,CAAC,GAAG,MAAM,SAAS,EAAE,MAAM,UAAU,IAAI,CAAY;AAAA,MAChE;AACA,aAAO,GAAqC,IAAIA;AAAA,QAC9C,OAAO,GAAqC;AAAA,QAC5C;AAAA,MACF;AAAA,IACF;AAEA,WAAO,EAAE,GAAG,MAAM,CAAC,QAAsC,GAAG,OAAO;AAAA,EACrE;AACF;AAEO,MAAM,2BAA2B,CACtC,MACA,OACA,cACG;AACH,QAAM,UAAqB;AAAA,IACzB;AAAA,IACA,oBAAoB,KAAK;AAAA,IACzB,GAAI,UAAU,WAAW,CAAC;AAAA,EAC5B;AAEA,QAAM,WAAW,KAAK,MAAM,KAAK,UAAU,IAAI,CAAC;AAEhD,aAAO,sCAAkB,UAAU;AAAA,IACjC,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AACH;","names":["deepTransformNode"]}

package/dist/cjs/deepTranformPlugins/index.cjs

@@ -0,0 +1,31 @@
+"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 deepTranformPlugins_exports = {};
+module.exports = __toCommonJS(deepTranformPlugins_exports);
+__reExport(deepTranformPlugins_exports, require('./getFilteredLocalesContent.cjs'), module.exports);
+__reExport(deepTranformPlugins_exports, require('./getFilterTranslationsOnlyContent.cjs'), module.exports);
+__reExport(deepTranformPlugins_exports, require('./getLocalisedContent.cjs'), module.exports);
+__reExport(deepTranformPlugins_exports, require('./getMissingLocalesContent.cjs'), module.exports);
+__reExport(deepTranformPlugins_exports, require('./getReplacedValuesContent.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./getFilteredLocalesContent.cjs'),
+  ...require('./getFilterTranslationsOnlyContent.cjs'),
+  ...require('./getLocalisedContent.cjs'),
+  ...require('./getMissingLocalesContent.cjs'),
+  ...require('./getReplacedValuesContent.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/deepTranformPlugins/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/deepTranformPlugins/index.ts"],"sourcesContent":["export * from './getFilteredLocalesContent';\nexport * from './getFilterTranslationsOnlyContent';\nexport * from './getLocalisedContent';\nexport * from './getMissingLocalesContent';\nexport * from './getReplacedValuesContent';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,wCAAc,wCAAd;AACA,wCAAc,+CADd;AAEA,wCAAc,kCAFd;AAGA,wCAAc,uCAHd;AAIA,wCAAc,uCAJd;","names":[]}

package/dist/cjs/dictionaryManipulator/getNodeChildren.cjs

@@ -35,7 +35,7 @@ const getNodeChildren = (section) => {
   if (typeof section?.nodeType === "string") {
     const typedNode = section;
     const content = typedNode[typedNode.nodeType];
-    if (typedNode.nodeType === import_types.NodeType.Translation || typedNode.nodeType === import_types.NodeType.Enumeration || typedNode.nodeType === import_types.NodeType.Condition || typedNode.nodeType === import_types.NodeType.Insertion || typedNode.nodeType === import_types.NodeType.File) {
+    if (typedNode.nodeType === import_types.NodeType.Translation || typedNode.nodeType === import_types.NodeType.Enumeration || typedNode.nodeType === import_types.NodeType.Condition || typedNode.nodeType === import_types.NodeType.Insertion || typedNode.nodeType === import_types.NodeType.Gender || typedNode.nodeType === import_types.NodeType.File || typedNode.nodeType === import_types.NodeType.Markdown) {
       const firstKey = Object.keys(content)[0];
       return content[firstKey];
     }

package/dist/cjs/dictionaryManipulator/getNodeChildren.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"sourcesContent":["import { type ContentNode, type TypedNode, NodeType } from '../types';\n\nexport const getNodeChildren = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return section;\n  }\n  if (typeof section === 'number') {\n    return section;\n  }\n  if (typeof section === 'boolean') {\n    return section;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content = typedNode[typedNode.nodeType as keyof TypedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition ||\n      typedNode.nodeType === NodeType.Insertion ||\n      typedNode.nodeType === NodeType.File\n    ) {\n      const firstKey = Object.keys(content)[0] as keyof typeof content;\n      return content[firstKey] as ContentNode;\n    }\n\n    if (typedNode.nodeType === NodeType.Nested) {\n      return undefined;\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[])[0];\n  }\n\n  return section;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2D;AAEpD,MAAM,kBAAkB,CAAC,YAAsC;AACpE,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO;AAAA,EACT;AACA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,UAAM,YAAY;AAClB,UAAM,UAAU,UAAU,UAAU,QAA2B;AAE/D,QACE,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,aAChC,UAAU,aAAa,sBAAS,aAChC,UAAU,aAAa,sBAAS,MAChC;AACA,YAAM,WAAW,OAAO,KAAK,OAAO,EAAE,CAAC;AACvC,aAAO,QAAQ,QAAQ;AAAA,IACzB;AAEA,QAAI,UAAU,aAAa,sBAAS,QAAQ;AAC1C,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,WAAW,OAAO,YAAY,UAAU;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAQ,QAA0B,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"sourcesContent":["import { type ContentNode, type TypedNode, NodeType } from '../types';\n\nexport const getNodeChildren = (section: ContentNode): ContentNode => {\n  if (typeof section === 'string') {\n    return section;\n  }\n  if (typeof section === 'number') {\n    return section;\n  }\n  if (typeof section === 'boolean') {\n    return section;\n  }\n  if (typeof (section as TypedNode)?.nodeType === 'string') {\n    const typedNode = section as TypedNode;\n    const content = typedNode[typedNode.nodeType as keyof TypedNode];\n\n    if (\n      typedNode.nodeType === NodeType.Translation ||\n      typedNode.nodeType === NodeType.Enumeration ||\n      typedNode.nodeType === NodeType.Condition ||\n      typedNode.nodeType === NodeType.Insertion ||\n      typedNode.nodeType === NodeType.Gender ||\n      typedNode.nodeType === NodeType.File ||\n      typedNode.nodeType === NodeType.Markdown\n    ) {\n      const firstKey = Object.keys(content)[0] as keyof typeof content;\n      return content[firstKey] as ContentNode;\n    }\n\n    if (typedNode.nodeType === NodeType.Nested) {\n      return undefined;\n    }\n\n    return content;\n  }\n\n  if (!section || typeof section !== 'object') {\n    return section;\n  }\n\n  if (Array.isArray(section)) {\n    return (section as ContentNode[])[0];\n  }\n\n  return section;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2D;AAEpD,MAAM,kBAAkB,CAAC,YAAsC;AACpE,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO;AAAA,EACT;AACA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,UAAM,YAAY;AAClB,UAAM,UAAU,UAAU,UAAU,QAA2B;AAE/D,QACE,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,eAChC,UAAU,aAAa,sBAAS,aAChC,UAAU,aAAa,sBAAS,aAChC,UAAU,aAAa,sBAAS,UAChC,UAAU,aAAa,sBAAS,QAChC,UAAU,aAAa,sBAAS,UAChC;AACA,YAAM,WAAW,OAAO,KAAK,OAAO,EAAE,CAAC;AACvC,aAAO,QAAQ,QAAQ;AAAA,IACzB;AAEA,QAAI,UAAU,aAAa,sBAAS,QAAQ;AAC1C,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,WAAW,OAAO,YAAY,UAAU;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAQ,QAA0B,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/dictionaryManipulator/getUnmergedDictionaryByKeyPath.cjs

@@ -0,0 +1,52 @@
+"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 getUnmergedDictionaryByKeyPath_exports = {};
+__export(getUnmergedDictionaryByKeyPath_exports, {
+  getUnmergedDictionaryByKeyPath: () => getUnmergedDictionaryByKeyPath
+});
+module.exports = __toCommonJS(getUnmergedDictionaryByKeyPath_exports);
+var import_unmerged_dictionaries_entry = __toESM(require("@intlayer/unmerged-dictionaries-entry"));
+var import_getContentNodeByKeyPath = require('./getContentNodeByKeyPath.cjs');
+const getUnmergedDictionaryByKeyPath = (dictionaryKey, keyPath, dictionariesRecord = import_unmerged_dictionaries_entry.default) => {
+  const unmergedEntries = dictionariesRecord?.[dictionaryKey];
+  if (!unmergedEntries) {
+    return null;
+  }
+  for (const dictionary of unmergedEntries) {
+    const content = (0, import_getContentNodeByKeyPath.getContentNodeByKeyPath)(dictionary.content, keyPath);
+    if (content) {
+      return dictionary;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUnmergedDictionaryByKeyPath
+});
+//# sourceMappingURL=getUnmergedDictionaryByKeyPath.cjs.map

package/dist/cjs/dictionaryManipulator/getUnmergedDictionaryByKeyPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dictionaryManipulator/getUnmergedDictionaryByKeyPath.ts"],"sourcesContent":["import unmergedDictionary from '@intlayer/unmerged-dictionaries-entry';\nimport { type KeyPath } from '../types';\nimport { getContentNodeByKeyPath } from './getContentNodeByKeyPath';\n\nexport const getUnmergedDictionaryByKeyPath = (\n  dictionaryKey: string,\n  keyPath: KeyPath[],\n  dictionariesRecord: keyof typeof unmergedDictionary = unmergedDictionary\n) => {\n  const unmergedEntries = dictionariesRecord?.[dictionaryKey];\n\n  if (!unmergedEntries) {\n    return null;\n  }\n\n  for (const dictionary of unmergedEntries) {\n    const content = getContentNodeByKeyPath(dictionary.content, keyPath);\n\n    if (content) {\n      return dictionary;\n    }\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yCAA+B;AAE/B,qCAAwC;AAEjC,MAAM,iCAAiC,CAC5C,eACA,SACA,qBAAsD,mCAAAA,YACnD;AACH,QAAM,kBAAkB,qBAAqB,aAAa;AAE1D,MAAI,CAAC,iBAAiB;AACpB,WAAO;AAAA,EACT;AAEA,aAAW,cAAc,iBAAiB;AACxC,UAAM,cAAU,wDAAwB,WAAW,SAAS,OAAO;AAEnE,QAAI,SAAS;AACX,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":["unmergedDictionary"]}

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -17,23 +17,25 @@ var dictionaryManipulator_exports = {};
 module.exports = __toCommonJS(dictionaryManipulator_exports);
 __reExport(dictionaryManipulator_exports, require('./editDictionaryByKeyPath.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./getContentNodeByKeyPath.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./getDefaultNode.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./getEmptyNode.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./getNodeChildren.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./getNodeType.cjs'), module.exports);
+__reExport(dictionaryManipulator_exports, require('./getUnmergedDictionaryByKeyPath.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./removeContentNodeByKeyPath.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./renameContentNodeByKeyPath.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getNodeType.cjs'), module.exports);
 __reExport(dictionaryManipulator_exports, require('./updateNodeChildren.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getDefaultNode.cjs'), module.exports);
-__reExport(dictionaryManipulator_exports, require('./getEmptyNode.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require('./editDictionaryByKeyPath.cjs'),
   ...require('./getContentNodeByKeyPath.cjs'),
+  ...require('./getDefaultNode.cjs'),
+  ...require('./getEmptyNode.cjs'),
   ...require('./getNodeChildren.cjs'),
+  ...require('./getNodeType.cjs'),
+  ...require('./getUnmergedDictionaryByKeyPath.cjs'),
   ...require('./removeContentNodeByKeyPath.cjs'),
   ...require('./renameContentNodeByKeyPath.cjs'),
-  ...require('./getNodeType.cjs'),
-  ...require('./updateNodeChildren.cjs'),
-  ...require('./getDefaultNode.cjs'),
-  ...require('./getEmptyNode.cjs')
+  ...require('./updateNodeChildren.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/dictionaryManipulator/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/index.ts"],"sourcesContent":["export * from './editDictionaryByKeyPath';\nexport * from './getContentNodeByKeyPath';\nexport * from './getNodeChildren';\nexport * from './removeContentNodeByKeyPath';\nexport * from './renameContentNodeByKeyPath';\nexport * from './getNodeType';\nexport * from './updateNodeChildren';\nexport * from './getDefaultNode';\nexport * from './getEmptyNode';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0CAAc,sCAAd;AACA,0CAAc,sCADd;AAEA,0CAAc,8BAFd;AAGA,0CAAc,yCAHd;AAIA,0CAAc,yCAJd;AAKA,0CAAc,0BALd;AAMA,0CAAc,iCANd;AAOA,0CAAc,6BAPd;AAQA,0CAAc,2BARd;","names":[]}
+{"version":3,"sources":["../../../src/dictionaryManipulator/index.ts"],"sourcesContent":["export * from './editDictionaryByKeyPath';\nexport * from './getContentNodeByKeyPath';\nexport * from './getDefaultNode';\nexport * from './getEmptyNode';\nexport * from './getNodeChildren';\nexport * from './getNodeType';\nexport * from './getUnmergedDictionaryByKeyPath';\nexport * from './removeContentNodeByKeyPath';\nexport * from './renameContentNodeByKeyPath';\nexport * from './updateNodeChildren';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0CAAc,sCAAd;AACA,0CAAc,sCADd;AAEA,0CAAc,6BAFd;AAGA,0CAAc,2BAHd;AAIA,0CAAc,8BAJd;AAKA,0CAAc,0BALd;AAMA,0CAAc,6CANd;AAOA,0CAAc,yCAPd;AAQA,0CAAc,yCARd;AASA,0CAAc,iCATd;","names":[]}

package/dist/cjs/index.cjs

@@ -15,6 +15,7 @@ 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('./deepTranformPlugins/index.cjs'), module.exports);
 __reExport(index_exports, require('./dictionaryManipulator/index.cjs'), module.exports);
 __reExport(index_exports, require('./formatters/index.cjs'), module.exports);
 __reExport(index_exports, require('./interpreter/index.cjs'), module.exports);
@@ -27,6 +28,7 @@ __reExport(index_exports, require('./utils/isSameKeyPath.cjs'), module.exports);
 __reExport(index_exports, require('./utils/isValidReactElement.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ...require('./deepTranformPlugins/index.cjs'),
   ...require('./dictionaryManipulator/index.cjs'),
   ...require('./formatters/index.cjs'),
   ...require('./interpreter/index.cjs'),

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './dictionaryManipulator/index';\nexport * from './formatters/index';\nexport * from './interpreter/index';\nexport * from './localization/index';\nexport * from './transpiler/index';\nexport * from './types/index';\nexport * from './utils/checkIsURLAbsolute';\nexport * from './utils/intl';\nexport * from './utils/isSameKeyPath';\nexport * from './utils/isValidReactElement';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,0CAAd;AACA,0BAAc,+BADd;AAEA,0BAAc,gCAFd;AAGA,0BAAc,iCAHd;AAIA,0BAAc,+BAJd;AAKA,0BAAc,0BALd;AAMA,0BAAc,uCANd;AAOA,0BAAc,yBAPd;AAQA,0BAAc,kCARd;AASA,0BAAc,wCATd;","names":[]}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './deepTranformPlugins';\nexport * from './dictionaryManipulator/index';\nexport * from './formatters/index';\nexport * from './interpreter/index';\nexport * from './localization/index';\nexport * from './transpiler/index';\nexport * from './types/index';\nexport * from './utils/checkIsURLAbsolute';\nexport * from './utils/intl';\nexport * from './utils/isSameKeyPath';\nexport * from './utils/isValidReactElement';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,kCAAd;AACA,0BAAc,0CADd;AAEA,0BAAc,+BAFd;AAGA,0BAAc,gCAHd;AAIA,0BAAc,iCAJd;AAKA,0BAAc,+BALd;AAMA,0BAAc,0BANd;AAOA,0BAAc,uCAPd;AAQA,0BAAc,yBARd;AASA,0BAAc,kCATd;AAUA,0BAAc,wCAVd;","names":[]}

package/dist/cjs/interpreter/getContent/index.cjs

@@ -17,13 +17,11 @@ var getContent_exports = {};
 module.exports = __toCommonJS(getContent_exports);
 __reExport(getContent_exports, require('./deepTransform.cjs'), module.exports);
 __reExport(getContent_exports, require('./getContent.cjs'), module.exports);
-__reExport(getContent_exports, require('./getLocalisedContent.cjs'), module.exports);
 __reExport(getContent_exports, require('./plugins.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require('./deepTransform.cjs'),
   ...require('./getContent.cjs'),
-  ...require('./getLocalisedContent.cjs'),
   ...require('./plugins.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/interpreter/getContent/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/interpreter/getContent/index.ts"],"sourcesContent":["export * from './deepTransform';\nexport * from './getContent';\nexport * from './getLocalisedContent';\nexport * from './plugins';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,4BAAd;AACA,+BAAc,yBADd;AAEA,+BAAc,kCAFd;AAGA,+BAAc,sBAHd;","names":[]}
+{"version":3,"sources":["../../../../src/interpreter/getContent/index.ts"],"sourcesContent":["export * from './deepTransform';\nexport * from './getContent';\nexport * from './plugins';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,4BAAd;AACA,+BAAc,yBADd;AAEA,+BAAc,sBAFd;","names":[]}

package/dist/cjs/interpreter/getContent/plugins.cjs

@@ -34,7 +34,7 @@ var import_getGender = require('../getGender.cjs');
 var import_getInsertion = require('../getInsertion.cjs');
 var import_getNesting = require('../getNesting.cjs');
 var import_getTranslation = require('../getTranslation.cjs');
-const translationPlugin = (locale, fallback = true) => ({
+const translationPlugin = (locale, fallback) => ({
   id: "translation-plugin",
   canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Translation,
   transform: (node, props, deepTransformNode) => {