@intlayer/core 5.3.1 → 5.3.3

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) {
+    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) {
       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    ) {\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,WAChC;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.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":[]}

package/dist/cjs/dictionaryManipulator/getNodeType.cjs

@@ -27,20 +27,8 @@ const getNodeType = (content) => {
   if (typeof content === "string") {
     return import_types.NodeType.Text;
   }
-  if (content?.nodeType === import_types.NodeType.Translation) {
-    return import_types.NodeType.Translation;
-  }
-  if (content?.nodeType === import_types.NodeType.Enumeration) {
-    return import_types.NodeType.Enumeration;
-  }
-  if (content?.nodeType === import_types.NodeType.Condition) {
-    return import_types.NodeType.Condition;
-  }
-  if (content?.nodeType === import_types.NodeType.Markdown) {
-    return import_types.NodeType.Markdown;
-  }
-  if (content?.nodeType === import_types.NodeType.Nested) {
-    return import_types.NodeType.Nested;
+  if (typeof content?.nodeType === "string") {
+    return content.nodeType;
   }
   if (Array.isArray(content)) {
     return import_types.NodeType.Array;

package/dist/cjs/dictionaryManipulator/getNodeType.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"sourcesContent":["import type {\n  TranslationContent,\n  EnumerationContent,\n  ConditionContent,\n  MarkdownContent,\n  NestedContent,\n} from '../transpiler';\nimport { NodeType, type DictionaryKeys } from '../types';\nimport type { ContentNode } from '../types/dictionary';\nimport { isValidElement } from '../utils/isValidReactElement';\n\nexport const getNodeType = (content: ContentNode): NodeType => {\n  if (typeof content === 'string') {\n    return NodeType.Text;\n  }\n\n  if ((content as TranslationContent)?.nodeType === NodeType.Translation) {\n    return NodeType.Translation;\n  }\n\n  if ((content as EnumerationContent)?.nodeType === NodeType.Enumeration) {\n    return NodeType.Enumeration;\n  }\n\n  if ((content as ConditionContent)?.nodeType === NodeType.Condition) {\n    return NodeType.Condition;\n  }\n\n  if ((content as MarkdownContent)?.nodeType === NodeType.Markdown) {\n    return NodeType.Markdown;\n  }\n\n  if (\n    (content as NestedContent<DictionaryKeys>)?.nodeType === NodeType.Nested\n  ) {\n    return NodeType.Nested;\n  }\n\n  if (Array.isArray(content)) {\n    return NodeType.Array;\n  }\n\n  if (isValidElement(content)) {\n    return NodeType.ReactNode;\n  }\n\n  if (typeof content === 'number') {\n    return NodeType.Number;\n  }\n\n  if (typeof content === 'boolean') {\n    return NodeType.Boolean;\n  }\n\n  if (content && typeof content === 'object') {\n    return NodeType.Object;\n  }\n\n  return NodeType.Unknown;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,mBAA8C;AAE9C,iCAA+B;AAExB,MAAM,cAAc,CAAC,YAAmC;AAC7D,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAAgC,aAAa,sBAAS,aAAa;AACtE,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAAgC,aAAa,sBAAS,aAAa;AACtE,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAA8B,aAAa,sBAAS,WAAW;AAClE,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAK,SAA6B,aAAa,sBAAS,UAAU;AAChE,WAAO,sBAAS;AAAA,EAClB;AAEA,MACG,SAA2C,aAAa,sBAAS,QAClE;AACA,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAO,sBAAS;AAAA,EAClB;AAEA,UAAI,2CAAe,OAAO,GAAG;AAC3B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,WAAW,OAAO,YAAY,UAAU;AAC1C,WAAO,sBAAS;AAAA,EAClB;AAEA,SAAO,sBAAS;AAClB;","names":[]}
+{"version":3,"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"sourcesContent":["import { NodeType, type TypedNode } from '../types';\nimport type { ContentNode } from '../types/dictionary';\nimport { isValidElement } from '../utils/isValidReactElement';\n\nexport const getNodeType = (content: ContentNode): NodeType => {\n  if (typeof content === 'string') {\n    return NodeType.Text;\n  }\n\n  if (typeof (content as TypedNode)?.nodeType === 'string') {\n    return (content as TypedNode).nodeType as NodeType;\n  }\n\n  if (Array.isArray(content)) {\n    return NodeType.Array;\n  }\n\n  if (isValidElement(content)) {\n    return NodeType.ReactNode;\n  }\n\n  if (typeof content === 'number') {\n    return NodeType.Number;\n  }\n\n  if (typeof content === 'boolean') {\n    return NodeType.Boolean;\n  }\n\n  if (content && typeof content === 'object') {\n    return NodeType.Object;\n  }\n\n  return NodeType.Unknown;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyC;AAEzC,iCAA+B;AAExB,MAAM,cAAc,CAAC,YAAmC;AAC7D,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAQ,SAAuB,aAAa,UAAU;AACxD,WAAQ,QAAsB;AAAA,EAChC;AAEA,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,WAAO,sBAAS;AAAA,EAClB;AAEA,UAAI,2CAAe,OAAO,GAAG;AAC3B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,OAAO,YAAY,WAAW;AAChC,WAAO,sBAAS;AAAA,EAClB;AAEA,MAAI,WAAW,OAAO,YAAY,UAAU;AAC1C,WAAO,sBAAS;AAAA,EAClB;AAEA,SAAO,sBAAS;AAClB;","names":[]}

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

@@ -36,10 +36,12 @@ var import_deepTransform = require('./deepTransform.cjs');
 var import_plugins = require('./plugins.cjs');
 const getContent = (node, nodeProps, locale = import_built.default.internationalization.defaultLocale) => {
   const plugins = [
+    import_plugins.insertionPlugin,
     (0, import_plugins.translationPlugin)(locale),
     import_plugins.enumerationPlugin,
     import_plugins.conditionPlugin,
     import_plugins.nestedPlugin,
+    import_plugins.filePlugin,
     ...nodeProps.plugins ?? []
   ];
   return (0, import_deepTransform.deepTransformNode)(node, {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/interpreter/getContent/getContent.ts"],"sourcesContent":["import { type Locales, type LocalesValues } from '@intlayer/config/client';\nimport configuration from '@intlayer/config/built';\n\nimport type { ContentNode } from '../../types';\nimport { deepTransformNode } from './deepTransform';\nimport {\n  translationPlugin,\n  enumerationPlugin,\n  conditionPlugin,\n  nestedPlugin,\n  type DeepTransformContent,\n  type NodeProps,\n  type Plugins,\n} from './plugins';\n\n/**\n * Transforms a node in a single pass, applying each plugin as needed.\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 getContent = <\n  T extends ContentNode,\n  L extends LocalesValues = Locales,\n>(\n  node: T,\n  nodeProps: NodeProps,\n  locale: L = configuration.internationalization.defaultLocale as L\n) => {\n  const plugins: Plugins[] = [\n    translationPlugin(locale),\n    enumerationPlugin,\n    conditionPlugin,\n    nestedPlugin,\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;AACA,mBAA0B;AAG1B,2BAAkC;AAClC,qBAQO;AAQA,MAAM,aAAa,CAIxB,MACA,WACA,SAAY,aAAAA,QAAc,qBAAqB,kBAC5C;AACH,QAAM,UAAqB;AAAA,QACzB,kCAAkB,MAAM;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,UAAU,WAAW,CAAC;AAAA,EAC5B;AAEA,aAAO,wCAAkB,MAAM;AAAA,IAC7B,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AACH;","names":["configuration"]}
+{"version":3,"sources":["../../../../src/interpreter/getContent/getContent.ts"],"sourcesContent":["import { type Locales, type LocalesValues } from '@intlayer/config/client';\nimport configuration from '@intlayer/config/built';\n\nimport type { ContentNode } from '../../types';\nimport { deepTransformNode } from './deepTransform';\nimport {\n  translationPlugin,\n  enumerationPlugin,\n  conditionPlugin,\n  nestedPlugin,\n  insertionPlugin,\n  filePlugin,\n  type DeepTransformContent,\n  type NodeProps,\n  type Plugins,\n} from './plugins';\n\n/**\n * Transforms a node in a single pass, applying each plugin as needed.\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 getContent = <\n  T extends ContentNode,\n  L extends LocalesValues = Locales,\n>(\n  node: T,\n  nodeProps: NodeProps,\n  locale: L = configuration.internationalization.defaultLocale as L\n) => {\n  const plugins: Plugins[] = [\n    insertionPlugin,\n    translationPlugin(locale),\n    enumerationPlugin,\n    conditionPlugin,\n    nestedPlugin,\n    filePlugin,\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;AACA,mBAA0B;AAG1B,2BAAkC;AAClC,qBAUO;AAQA,MAAM,aAAa,CAIxB,MACA,WACA,SAAY,aAAAA,QAAc,qBAAqB,kBAC5C;AACH,QAAM,UAAqB;AAAA,IACzB;AAAA,QACA,kCAAkB,MAAM;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,UAAU,WAAW,CAAC;AAAA,EAC5B;AAEA,aAAO,wCAAkB,MAAM;AAAA,IAC7B,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AACH;","names":["configuration"]}

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

@@ -20,6 +20,8 @@ var plugins_exports = {};
 __export(plugins_exports, {
   conditionPlugin: () => conditionPlugin,
   enumerationPlugin: () => enumerationPlugin,
+  filePlugin: () => filePlugin,
+  insertionPlugin: () => insertionPlugin,
   nestedPlugin: () => nestedPlugin,
   translationPlugin: () => translationPlugin
 });
@@ -29,10 +31,12 @@ var import_getCondition = require('../getCondition.cjs');
 var import_getEnumeration = require('../getEnumeration.cjs');
 var import_getNesting = require('../getNesting.cjs');
 var import_getTranslation = require('../getTranslation.cjs');
+var import_getInsertion = require('../getInsertion.cjs');
 const translationPlugin = (locale) => ({
+  id: "translation-plugin",
   canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Translation,
   transform: (node, props, deepTransformNode) => {
-    const result = structuredClone(node.translation);
+    const result = structuredClone(node[import_types.NodeType.Translation]);
     for (const key in result) {
       const childProps = {
         ...props,
@@ -51,9 +55,10 @@ const translationPlugin = (locale) => ({
   }
 });
 const enumerationPlugin = {
+  id: "enumeration-plugin",
   canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Enumeration,
   transform: (node, props, deepTransformNode) => {
-    const result = structuredClone(node.enumeration);
+    const result = structuredClone(node[import_types.NodeType.Enumeration]);
     for (const key in result) {
       const child = result[key];
       const childProps = {
@@ -73,9 +78,10 @@ const enumerationPlugin = {
   }
 };
 const conditionPlugin = {
+  id: "condition-plugin",
   canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Condition,
   transform: (node, props, deepTransformNode) => {
-    const result = structuredClone(node.condition);
+    const result = structuredClone(node[import_types.NodeType.Condition]);
     for (const key in result) {
       const child = result[key];
       const childProps = {
@@ -94,14 +100,67 @@ const conditionPlugin = {
     return (value) => (0, import_getCondition.getCondition)(result, value);
   }
 };
+const insertionPlugin = {
+  id: "insertion-plugin",
+  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Insertion,
+  transform: (node, props, deepTransformNode) => {
+    const newKeyPath = [
+      ...props.keyPath,
+      {
+        type: import_types.NodeType.Insertion
+      }
+    ];
+    const children = node[import_types.NodeType.Insertion];
+    const insertionStringPlugin = {
+      id: "insertion-string-plugin",
+      canHandle: (node2) => typeof node2 === "string",
+      transform: (node2, subProps, deepTransformNode2) => {
+        const transformedResult = deepTransformNode2(node2, {
+          ...subProps,
+          children: node2,
+          plugins: [
+            ...(props.plugins ?? []).filter(
+              (plugin) => plugin.id !== "intlayer-node-plugin"
+            )
+          ]
+        });
+        return (values) => {
+          const children2 = (0, import_getInsertion.getInsertion)(transformedResult, values);
+          return deepTransformNode2(children2, {
+            ...subProps,
+            plugins: props.plugins,
+            children: children2
+          });
+        };
+      }
+    };
+    return deepTransformNode(children, {
+      ...props,
+      children,
+      keyPath: newKeyPath,
+      plugins: [insertionStringPlugin, ...props.plugins ?? []]
+    });
+  }
+};
 const nestedPlugin = {
+  id: "nested-plugin",
   canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Nested,
   transform: (node, props) => (0, import_getNesting.getNesting)(node.nested.dictionaryKey, node.nested.path, props)
 };
+const filePlugin = {
+  id: "file-plugin",
+  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.File,
+  transform: (node, props, deepTransform) => deepTransform(node.content, {
+    ...props,
+    children: node.content
+  })
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   conditionPlugin,
   enumerationPlugin,
+  filePlugin,
+  insertionPlugin,
   nestedPlugin,
   translationPlugin
 });

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/interpreter/getContent/plugins.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config/client';\nimport type {\n  ConditionContent,\n  EnumerationContent,\n  NestedContent,\n  TranslationContent,\n} from '../../transpiler';\nimport { type DictionaryKeys, type KeyPath, NodeType } from '../../types/index';\nimport { getCondition } from '../getCondition';\nimport { getEnumeration } from '../getEnumeration';\nimport { type GetNestingResult, getNesting } from '../getNesting';\nimport { getTranslation } from '../getTranslation';\n\n/** ---------------------------------------------\n *  PLUGIN DEFINITION\n *  --------------------------------------------- */\n\n/**\n * A plugin/transformer that can optionally transform a node during a single DFS pass.\n * - `canHandle` decides if the node is transformable by this plugin.\n * - `transform` returns the transformed node (and does not recurse further).\n *\n * > `transformFn` is a function that can be used to deeply transform inside the plugin.\n */\nexport type Plugins = {\n  canHandle: (node: any) => boolean;\n  transform: (\n    node: any,\n    props: NodeProps,\n    transformFn: (node: any, props: NodeProps) => any\n  ) => any;\n};\n\n/** ---------------------------------------------\n *  TRANSLATION PLUGIN\n *  --------------------------------------------- */\n\nexport type TranslationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Translation]: object;\n}\n  ? DeepTransformContent<\n      T[NodeType.Translation][keyof T[NodeType.Translation]],\n      S\n    >\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const translationPlugin = (locale: LocalesValues): Plugins => ({\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Translation,\n  transform: (node: TranslationContent, props, deepTransformNode) => {\n    const result = structuredClone(node.translation);\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        childProps\n      );\n    }\n    return getTranslation(result, locale);\n  },\n});\n\n/** ---------------------------------------------\n *  ENUMERATION PLUGIN\n *  --------------------------------------------- */\n\nexport type EnumerationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Enumeration]: object;\n}\n  ? (\n      quantity: number\n    ) => DeepTransformContent<\n      T[NodeType.Enumeration][keyof T[NodeType.Enumeration]],\n      S\n    >\n  : never;\n\n/** Enumeration plugin. Replaces node with a function that takes quantity => string. */\nexport const enumerationPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Enumeration,\n  transform: (node: EnumerationContent, props, deepTransformNode) => {\n    const result = structuredClone(node.enumeration);\n\n    for (const key in result) {\n      const child = result[key as unknown as keyof typeof result];\n      const childProps = {\n        ...props,\n        children: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Enumeration, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (quantity: number) => getEnumeration(result, quantity);\n  },\n};\n\n/** ---------------------------------------------\n *  CONDITION PLUGIN\n *  --------------------------------------------- */\n\nexport type ConditionCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Condition]: object;\n}\n  ? (\n      value: boolean\n    ) => DeepTransformContent<\n      T[NodeType.Condition][keyof T[NodeType.Condition]],\n      S\n    >\n  : never;\n\n/** Condition plugin. Replaces node with a function that takes boolean => string. */\nexport const conditionPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Condition,\n  transform: (node: ConditionContent, props, deepTransformNode) => {\n    const result = structuredClone(node.condition);\n\n    for (const key in result) {\n      const child = result[key as keyof typeof result];\n      const childProps = {\n        ...props,\n        children: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Condition, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (value: boolean) => getCondition(result, value);\n  },\n};\n\n/** ---------------------------------------------\n *  NESTED PLUGIN\n *  --------------------------------------------- */\n\nexport type NestedCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Nested]: infer U;\n}\n  ? U extends {\n      dictionaryKey: infer K extends DictionaryKeys;\n      path?: infer P;\n    }\n    ? GetNestingResult<K, P, S>\n    : never\n  : never;\n\n/** Nested plugin. Replaces node with the result of `getNesting`. */\nexport const nestedPlugin: Plugins = {\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Nested,\n  transform: (node: NestedContent, props) =>\n    getNesting(node.nested.dictionaryKey, node.nested.path, props),\n};\n\n/**\n * PLUGIN RESULT\n */\n\n/**\n * Interface that defines the properties of a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface NodeProps {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  plugins?: Plugins[];\n  locale?: Locales;\n  dictionaryPath?: string;\n  children?: any;\n}\n\n/**\n * Interface that defines the plugins that can be used to transform a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface IInterpreterPlugin<T, S> {\n  translation: TranslationCond<T, S>;\n  enumeration: EnumerationCond<T, S>;\n  condition: ConditionCond<T, S>;\n  nested: NestedCond<T, S>;\n}\n\n/**\n * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.\n */\nexport type IInterpreterPluginState = {\n  translation: true;\n  enumeration: true;\n  condition: true;\n  nested: true;\n};\n\n/**\n * Utility type to check if a plugin can be applied to a node.\n */\ntype CheckApplyPlugin<T, K extends keyof IInterpreterPlugin<T, S>, S> =\n  // Test if the key is a key of S.\n  K extends keyof S\n    ? // Test if the key of S is true. Then the plugin can be applied.\n      S[K] extends true\n      ? // Test if the key of S exist\n        IInterpreterPlugin<T, S>[K] extends never\n        ? never\n        : // Test if the plugin condition is true (if it's not, the plugin is skipped for this node)\n          IInterpreterPlugin<T, S>[K]\n      : never\n    : never;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\ntype Traverse<T, S> =\n  // Turn any read-only array into a plain mutable array\n  T extends ReadonlyArray<infer U>\n    ? Array<DeepTransformContent<U, S>>\n    : T extends object\n      ? { [K in keyof T]: DeepTransformContent<T[K], S> }\n      : T;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\nexport type DeepTransformContent<T, S = IInterpreterPluginState> =\n  // Check if there is a plugin for T:\n  CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S>, S> extends never\n    ? // No plugin was found, so try to transform T recursively:\n      Traverse<T, S>\n    : // A plugin was found – use the plugin’s transformation.\n      IInterpreterPlugin<T, S>[keyof IInterpreterPlugin<T, S>];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,mBAA4D;AAC5D,0BAA6B;AAC7B,4BAA+B;AAC/B,wBAAkD;AAClD,4BAA+B;AAqCxB,MAAM,oBAAoB,CAAC,YAAoC;AAAA,EACpE,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAA0B,OAAO,sBAAsB;AACjE,UAAM,SAAS,gBAAgB,KAAK,WAAW;AAE/C,eAAW,OAAO,QAAQ;AACxB,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,UAAU,OAAO,GAAqC;AAAA,QACtD,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,aAAa,IAAI;AAAA,QACpC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C,OAAO,GAAqC;AAAA,QAC5C;AAAA,MACF;AAAA,IACF;AACA,eAAO,sCAAe,QAAQ,MAAM;AAAA,EACtC;AACF;AAmBO,MAAM,oBAA6B;AAAA,EACxC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAA0B,OAAO,sBAAsB;AACjE,UAAM,SAAS,gBAAgB,KAAK,WAAW;AAE/C,eAAW,OAAO,QAAQ;AACxB,YAAM,QAAQ,OAAO,GAAqC;AAC1D,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,UAAU;AAAA,QACV,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,aAAa,IAAI;AAAA,QACpC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,WAAO,CAAC,iBAAqB,sCAAe,QAAQ,QAAQ;AAAA,EAC9D;AACF;AAmBO,MAAM,kBAA2B;AAAA,EACtC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAAwB,OAAO,sBAAsB;AAC/D,UAAM,SAAS,gBAAgB,KAAK,SAAS;AAE7C,eAAW,OAAO,QAAQ;AACxB,YAAM,QAAQ,OAAO,GAA0B;AAC/C,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,QACH,UAAU;AAAA,QACV,SAAS;AAAA,UACP,GAAG,MAAM;AAAA,UACT,EAAE,MAAM,sBAAS,WAAW,IAAI;AAAA,QAClC;AAAA,MACF;AACA,aAAO,GAAqC,IAAI;AAAA,QAC9C;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,WAAO,CAAC,cAAmB,kCAAa,QAAQ,KAAK;AAAA,EACvD;AACF;AAmBO,MAAM,eAAwB;AAAA,EACnC,WAAW,CAAC,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,sBAAS;AAAA,EAC1D,WAAW,CAAC,MAAqB,cAC/B,8BAAW,KAAK,OAAO,eAAe,KAAK,OAAO,MAAM,KAAK;AACjE;","names":[]}
+{"version":3,"sources":["../../../../src/interpreter/getContent/plugins.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config/client';\nimport type {\n  ConditionContent,\n  EnumerationContent,\n  NestedContent,\n  TranslationContent,\n  InsertionContent,\n  FileContent,\n} from '../../transpiler';\nimport { type DictionaryKeys, type KeyPath, NodeType } from '../../types/index';\nimport { getCondition } from '../getCondition';\nimport { getEnumeration } from '../getEnumeration';\nimport { type GetNestingResult, getNesting } from '../getNesting';\nimport { getTranslation } from '../getTranslation';\nimport { getInsertion } from '../getInsertion';\n\n/** ---------------------------------------------\n *  PLUGIN DEFINITION\n *  --------------------------------------------- */\n\n/**\n * A plugin/transformer that can optionally transform a node during a single DFS pass.\n * - `canHandle` decides if the node is transformable by this plugin.\n * - `transform` returns the transformed node (and does not recurse further).\n *\n * > `transformFn` is a function that can be used to deeply transform inside the plugin.\n */\nexport type Plugins = {\n  id: string;\n  canHandle: (node: any) => boolean;\n  transform: (\n    node: any,\n    props: NodeProps,\n    transformFn: (node: any, props: NodeProps) => any\n  ) => any;\n};\n\n/** ---------------------------------------------\n *  TRANSLATION PLUGIN\n *  --------------------------------------------- */\n\nexport type TranslationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Translation]: object;\n}\n  ? DeepTransformContent<\n      T[NodeType.Translation][keyof T[NodeType.Translation]],\n      S\n    >\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const translationPlugin = (locale: LocalesValues): Plugins => ({\n  id: 'translation-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Translation,\n  transform: (node: TranslationContent, props, deepTransformNode) => {\n    const result = structuredClone(node[NodeType.Translation]);\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        childProps\n      );\n    }\n    return getTranslation(result, locale);\n  },\n});\n\n/** ---------------------------------------------\n *  ENUMERATION PLUGIN\n *  --------------------------------------------- */\n\nexport type EnumerationCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Enumeration]: object;\n}\n  ? (\n      quantity: number\n    ) => DeepTransformContent<\n      T[NodeType.Enumeration][keyof T[NodeType.Enumeration]],\n      S\n    >\n  : never;\n\n/** Enumeration plugin. Replaces node with a function that takes quantity => string. */\nexport const enumerationPlugin: Plugins = {\n  id: 'enumeration-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Enumeration,\n  transform: (node: EnumerationContent, props, deepTransformNode) => {\n    const result = structuredClone(node[NodeType.Enumeration]);\n\n    for (const key in result) {\n      const child = result[key as unknown as keyof typeof result];\n      const childProps = {\n        ...props,\n        children: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Enumeration, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (quantity: number) => getEnumeration(result, quantity);\n  },\n};\n\n/** ---------------------------------------------\n *  CONDITION PLUGIN\n *  --------------------------------------------- */\n\nexport type ConditionCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Condition]: object;\n}\n  ? (\n      value: boolean\n    ) => DeepTransformContent<\n      T[NodeType.Condition][keyof T[NodeType.Condition]],\n      S\n    >\n  : never;\n\n/** Condition plugin. Replaces node with a function that takes boolean => string. */\nexport const conditionPlugin: Plugins = {\n  id: 'condition-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Condition,\n  transform: (node: ConditionContent, props, deepTransformNode) => {\n    const result = structuredClone(node[NodeType.Condition]);\n\n    for (const key in result) {\n      const child = result[key as keyof typeof result];\n      const childProps = {\n        ...props,\n        children: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeType.Condition, key } as KeyPath,\n        ],\n      };\n      result[key as unknown as keyof typeof result] = deepTransformNode(\n        child,\n        childProps\n      );\n    }\n\n    return (value: boolean) => getCondition(result, value);\n  },\n};\n\n/** ---------------------------------------------\n *  INSERTION PLUGIN\n *  --------------------------------------------- */\n\nexport type InsertionCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Insertion]: infer I;\n  fields?: infer U;\n}\n  ? U extends readonly string[]\n    ? (data: Record<U[number], string>) => DeepTransformContent<I, S>\n    : (data: Record<string, string>) => DeepTransformContent<I, S>\n  : never;\n\nexport const insertionPlugin: Plugins = {\n  id: 'insertion-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Insertion,\n  transform: (node: InsertionContent, props, deepTransformNode) => {\n    const newKeyPath: KeyPath[] = [\n      ...props.keyPath,\n      {\n        type: NodeType.Insertion,\n      },\n    ];\n\n    const children = node[NodeType.Insertion];\n\n    /** Insertion string plugin. Replaces string node with a component that render the insertion. */\n    const insertionStringPlugin: Plugins = {\n      id: 'insertion-string-plugin',\n      canHandle: (node) => typeof node === 'string',\n      transform: (node: string, subProps, deepTransformNode) => {\n        const transformedResult = deepTransformNode(node, {\n          ...subProps,\n          children: node,\n          plugins: [\n            ...(props.plugins ?? ([] as Plugins[])).filter(\n              (plugin) => plugin.id !== 'intlayer-node-plugin'\n            ),\n          ],\n        });\n\n        return (values: {\n          [K in InsertionContent['fields'][number]]: string;\n        }) => {\n          const children = getInsertion(transformedResult, values);\n\n          return deepTransformNode(children, {\n            ...subProps,\n            plugins: props.plugins,\n            children,\n          });\n        };\n      },\n    };\n\n    return deepTransformNode(children, {\n      ...props,\n      children,\n      keyPath: newKeyPath,\n      plugins: [insertionStringPlugin, ...(props.plugins ?? [])],\n    });\n  },\n};\n\n/** ---------------------------------------------\n *  NESTED PLUGIN\n *  --------------------------------------------- */\n\nexport type NestedCond<T, S> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.Nested]: infer U;\n}\n  ? U extends {\n      dictionaryKey: infer K extends DictionaryKeys;\n      path?: infer P;\n    }\n    ? GetNestingResult<K, P, S>\n    : never\n  : never;\n\n/** Nested plugin. Replaces node with the result of `getNesting`. */\nexport const nestedPlugin: Plugins = {\n  id: 'nested-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.Nested,\n  transform: (node: NestedContent, props) =>\n    getNesting(node.nested.dictionaryKey, node.nested.path, props),\n};\n\n// /** ---------------------------------------------\n//  *  FILE PLUGIN\n//  *  --------------------------------------------- */\n\nexport type FileCond<T> = T extends {\n  nodeType: NodeType | string;\n  [NodeType.File]: string;\n  content?: string;\n}\n  ? string\n  : never;\n\n/** File plugin. Replaces node with the result of `getNesting`. */\nexport const filePlugin: Plugins = {\n  id: 'file-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeType.File,\n  transform: (node: FileContent, props, deepTransform) =>\n    deepTransform(node.content, {\n      ...props,\n      children: node.content,\n    }),\n};\n\n/**\n * PLUGIN RESULT\n */\n\n/**\n * Interface that defines the properties of a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface NodeProps {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  plugins?: Plugins[];\n  locale?: Locales;\n  dictionaryPath?: string;\n  children?: any;\n}\n\n/**\n * Interface that defines the plugins that can be used to transform a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface IInterpreterPlugin<T, S> {\n  translation: TranslationCond<T, S>;\n  insertion: InsertionCond<T, S>;\n  enumeration: EnumerationCond<T, S>;\n  condition: ConditionCond<T, S>;\n  nested: NestedCond<T, S>;\n  // file: FileCond<T>;\n}\n\n/**\n * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.\n */\nexport type IInterpreterPluginState = {\n  translation: true;\n  enumeration: true;\n  condition: true;\n  insertion: true;\n  nested: true;\n  // file: true;\n};\n\n/**\n * Utility type to check if a plugin can be applied to a node.\n */\ntype CheckApplyPlugin<T, K extends keyof IInterpreterPlugin<T, S>, S> =\n  // Test if the key is a key of S.\n  K extends keyof S\n    ? // Test if the key of S is true. Then the plugin can be applied.\n      S[K] extends true\n      ? // Test if the key of S exist\n        IInterpreterPlugin<T, S>[K] extends never\n        ? never\n        : // Test if the plugin condition is true (if it's not, the plugin is skipped for this node)\n          IInterpreterPlugin<T, S>[K]\n      : never\n    : never;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\ntype Traverse<T, S> =\n  // Turn any read-only array into a plain mutable array\n  T extends ReadonlyArray<infer U>\n    ? Array<DeepTransformContent<U, S>>\n    : T extends object\n      ? { [K in keyof T]: DeepTransformContent<T[K], S> }\n      : T;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\nexport type DeepTransformContent<T, S = IInterpreterPluginState> =\n  // Check if there is a plugin for T:\n  CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S>, S> extends never\n    ? // No plugin was found, so try to transform T recursively:\n      Traverse<T, S>\n    : // A plugin was found – use the plugin’s transformation.\n      IInterpreterPlugin<T, S>[keyof IInterpreterPlugin<T, S>];\n"],"mappings":"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","names":["node","deepTransformNode","children"]}

package/dist/cjs/interpreter/getInsertion.cjs

@@ -0,0 +1,29 @@
+"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 getInsertion_exports = {};
+__export(getInsertion_exports, {
+  getInsertion: () => getInsertion
+});
+module.exports = __toCommonJS(getInsertion_exports);
+const getInsertion = (content, values) => content.replace(/\{\{(.*?)\}\}/g, (_, key) => values[key] ?? "");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getInsertion
+});
+//# sourceMappingURL=getInsertion.cjs.map

package/dist/cjs/interpreter/getInsertion.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/interpreter/getInsertion.ts"],"sourcesContent":["import type { InsertionContent } from '../transpiler';\n\n/**\n * Allow to insert values in a string.\n *\n * Usage:\n *\n * ```ts\n * const content = getInsertion('Hello {{name}}!', {\n *  name: 'John',\n * });\n * // 'Hello John!'\n * ```\n *\n */\nexport const getInsertion = (\n  content: string,\n  values: { [K in InsertionContent['fields'][number]]: string }\n) => content.replace(/\\{\\{(.*?)\\}\\}/g, (_, key) => values[key] ?? '');\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,MAAM,eAAe,CAC1B,SACA,WACG,QAAQ,QAAQ,kBAAkB,CAAC,GAAG,QAAQ,OAAO,GAAG,KAAK,EAAE;","names":[]}

package/dist/cjs/interpreter/getTranslation.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/interpreter/getTranslation.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport configuration from '@intlayer/config/built';\n\nimport type { LanguageContent } from '../transpiler/translation/types';\n\n/**\n *\n * Allow to pick a content based on a locale.\n * If not locale found, it will return the content related to the default locale.\n *\n * Return either the content editor, or the content itself depending on the configuration.\n *\n * Usage:\n *\n * ```ts\n * const content = getTranslation<string>({\n * en: 'Hello',\n * fr: 'Bonjour',\n * }, 'fr');\n * // 'Bonjour'\n * ```\n *\n * Using TypeScript:\n * - this function will require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nexport const getTranslation = <Content = string>(\n  languageContent: LanguageContent<Content>,\n  locale?: LocalesValues\n): Content => {\n  const { defaultLocale } = configuration?.internationalization;\n\n  const result =\n    languageContent[\n      (locale ?? defaultLocale) as unknown as keyof typeof languageContent\n    ] ??\n    (languageContent[\n      defaultLocale as unknown as keyof typeof languageContent\n    ] as Content);\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA0B;AAyBnB,MAAM,iBAAiB,CAC5B,iBACA,WACY;AACZ,QAAM,EAAE,cAAc,IAAI,aAAAA,SAAe;AAEzC,QAAM,SACJ,gBACG,UAAU,aACb,KACC,gBACC,aACF;AAEF,SAAO;AACT;","names":["configuration"]}
+{"version":3,"sources":["../../../src/interpreter/getTranslation.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/config/client';\nimport configuration from '@intlayer/config/built';\nimport { LanguageContent } from '../types';\n\n/**\n *\n * Allow to pick a content based on a locale.\n * If not locale found, it will return the content related to the default locale.\n *\n * Return either the content editor, or the content itself depending on the configuration.\n *\n * Usage:\n *\n * ```ts\n * const content = getTranslation<string>({\n * en: 'Hello',\n * fr: 'Bonjour',\n * }, 'fr');\n * // 'Bonjour'\n * ```\n *\n * Using TypeScript:\n * - this function will require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nexport const getTranslation = <Content = string>(\n  languageContent: LanguageContent<Content>,\n  locale?: LocalesValues\n): Content => {\n  const { defaultLocale } = configuration?.internationalization;\n\n  const result =\n    languageContent[\n      (locale ?? defaultLocale) as unknown as keyof typeof languageContent\n    ] ??\n    (languageContent[\n      defaultLocale as unknown as keyof typeof languageContent\n    ] as Content);\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA0B;AAwBnB,MAAM,iBAAiB,CAC5B,iBACA,WACY;AACZ,QAAM,EAAE,cAAc,IAAI,aAAAA,SAAe;AAEzC,QAAM,SACJ,gBACG,UAAU,aACb,KACC,gBACC,aACF;AAEF,SAAO;AACT;","names":["configuration"]}

package/dist/cjs/transpiler/file/file.cjs

@@ -0,0 +1,60 @@
+"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 file_exports = {};
+__export(file_exports, {
+  file: () => file
+});
+module.exports = __toCommonJS(file_exports);
+var import_fs = require("fs");
+var import_types = require('../../types/index.cjs');
+var import_path = require("path");
+var import_config = require("@intlayer/config");
+const file = (path) => {
+  const callerDir = intlayer_file_dir ?? process.cwd();
+  const isAbsolutePath = path.startsWith("/");
+  const isRelativePath = path.startsWith("./") || path.startsWith("../");
+  let filePath;
+  if (isAbsolutePath) {
+    (0, import_config.appLogger)(
+      `Using absolute path for file is not recommended. Use relative paths instead. Path: ${path}, imported from: ${intlayer_file_path}`,
+      { level: "warn" }
+    );
+    filePath = path;
+  } else if (isRelativePath) {
+    filePath = (0, import_path.resolve)(callerDir, path);
+  } else {
+    filePath = (0, import_path.resolve)(process.cwd(), path);
+  }
+  let content;
+  if ((0, import_fs.existsSync)(filePath)) {
+    content = (0, import_fs.readFileSync)(filePath, "utf8");
+  } else {
+    (0, import_config.appLogger)(`File not found: ${filePath}`, { level: "warn" });
+    content = `File not found`;
+  }
+  return (0, import_types.formatNodeType)(import_types.NodeType.File, path, {
+    content,
+    fixedPath: (0, import_path.relative)(process.cwd(), filePath)
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  file
+});
+//# sourceMappingURL=file.cjs.map

package/dist/cjs/transpiler/file/file.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/file/file.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'fs';\nimport {\n  formatNodeType,\n  NodeType,\n  type TypedNodeModel,\n} from '../../types/index';\nimport { relative, resolve } from 'path';\nimport { appLogger } from '@intlayer/config';\n\nexport type FileContent = TypedNodeModel<\n  NodeType.File,\n  string,\n  {\n    content: string;\n    fixedPath?: string;\n  }\n>;\n\ndeclare const intlayer_file_path: string; // Injected by esbuild to track the file content\ndeclare const intlayer_file_dir: string; // Injected by esbuild to track the file path\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow identify the usage of an external resource.\n *\n * Usage:\n *\n * ```ts\n * file('/path/to/file.md') // absolute path\n *\n * // or\n *\n * file('path/to/file.md') // relative path\n * ```\n */\nexport const file = (path: string): FileContent => {\n  const callerDir = intlayer_file_dir ?? process.cwd();\n\n  const isAbsolutePath = path.startsWith('/');\n  const isRelativePath = path.startsWith('./') || path.startsWith('../');\n\n  let filePath: string;\n  if (isAbsolutePath) {\n    appLogger(\n      `Using absolute path for file is not recommended. Use relative paths instead. Path: ${path}, imported from: ${intlayer_file_path}`,\n      { level: 'warn' }\n    );\n    filePath = path;\n  } else if (isRelativePath) {\n    filePath = resolve(callerDir, path);\n  } else {\n    filePath = resolve(process.cwd(), path);\n  }\n\n  let content: string;\n\n  if (existsSync(filePath)) {\n    content = readFileSync(filePath, 'utf8');\n  } else {\n    appLogger(`File not found: ${filePath}`, { level: 'warn' });\n\n    content = `File not found`;\n  }\n\n  return formatNodeType(NodeType.File, path, {\n    content,\n    fixedPath: relative(process.cwd(), filePath),\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAyC;AACzC,mBAIO;AACP,kBAAkC;AAClC,oBAA0B;AA6BnB,MAAM,OAAO,CAAC,SAA8B;AACjD,QAAM,YAAY,qBAAqB,QAAQ,IAAI;AAEnD,QAAM,iBAAiB,KAAK,WAAW,GAAG;AAC1C,QAAM,iBAAiB,KAAK,WAAW,IAAI,KAAK,KAAK,WAAW,KAAK;AAErE,MAAI;AACJ,MAAI,gBAAgB;AAClB;AAAA,MACE,sFAAsF,IAAI,oBAAoB,kBAAkB;AAAA,MAChI,EAAE,OAAO,OAAO;AAAA,IAClB;AACA,eAAW;AAAA,EACb,WAAW,gBAAgB;AACzB,mBAAW,qBAAQ,WAAW,IAAI;AAAA,EACpC,OAAO;AACL,mBAAW,qBAAQ,QAAQ,IAAI,GAAG,IAAI;AAAA,EACxC;AAEA,MAAI;AAEJ,UAAI,sBAAW,QAAQ,GAAG;AACxB,kBAAU,wBAAa,UAAU,MAAM;AAAA,EACzC,OAAO;AACL,iCAAU,mBAAmB,QAAQ,IAAI,EAAE,OAAO,OAAO,CAAC;AAE1D,cAAU;AAAA,EACZ;AAEA,aAAO,6BAAe,sBAAS,MAAM,MAAM;AAAA,IACzC;AAAA,IACA,eAAW,sBAAS,QAAQ,IAAI,GAAG,QAAQ;AAAA,EAC7C,CAAC;AACH;","names":[]}

package/dist/cjs/transpiler/file/fileBrowser.cjs

@@ -0,0 +1,36 @@
+"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 fileBrowser_exports = {};
+__export(fileBrowser_exports, {
+  file: () => file
+});
+module.exports = __toCommonJS(fileBrowser_exports);
+var import_types = require('../../types/index.cjs');
+const file = (path) => {
+  throw new Error("file is not available in browser");
+  return (0, import_types.formatNodeType)(import_types.NodeType.File, path, {
+    content: "",
+    fixedPath: ""
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  file
+});
+//# sourceMappingURL=fileBrowser.cjs.map

package/dist/cjs/transpiler/file/fileBrowser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/file/fileBrowser.ts"],"sourcesContent":["import { formatNodeType, NodeType } from '../../types';\nimport type { FileContent } from './file';\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow identify the usage of an external resource.\n *\n * Usage:\n *\n * ```ts\n * file('/path/to/file.md') // absolute path\n *\n * // or\n *\n * file('path/to/file.md') // relative path\n * ```\n */\nexport const file = (path: string): FileContent => {\n  throw new Error('file is not available in browser');\n\n  return formatNodeType(NodeType.File, path, {\n    content: '',\n    fixedPath: '',\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyC;AAkBlC,MAAM,OAAO,CAAC,SAA8B;AACjD,QAAM,IAAI,MAAM,kCAAkC;AAElD,aAAO,6BAAe,sBAAS,MAAM,MAAM;AAAA,IACzC,SAAS;AAAA,IACT,WAAW;AAAA,EACb,CAAC;AACH;","names":[]}

package/dist/cjs/transpiler/file/index.cjs

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

package/dist/cjs/transpiler/file/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/file/index.ts"],"sourcesContent":["export * from './file';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,yBAAc,mBAAd;","names":[]}

package/dist/cjs/transpiler/index.cjs

@@ -18,6 +18,7 @@ module.exports = __toCommonJS(transpiler_exports);
 __reExport(transpiler_exports, require('./translation/index.cjs'), module.exports);
 __reExport(transpiler_exports, require('./enumeration/index.cjs'), module.exports);
 __reExport(transpiler_exports, require('./condition/index.cjs'), module.exports);
+__reExport(transpiler_exports, require('./insertion/index.cjs'), module.exports);
 __reExport(transpiler_exports, require('./markdown/index.cjs'), module.exports);
 __reExport(transpiler_exports, require('./nesting/index.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
@@ -25,6 +26,7 @@ __reExport(transpiler_exports, require('./nesting/index.cjs'), module.exports);
   ...require('./translation/index.cjs'),
   ...require('./enumeration/index.cjs'),
   ...require('./condition/index.cjs'),
+  ...require('./insertion/index.cjs'),
   ...require('./markdown/index.cjs'),
   ...require('./nesting/index.cjs')
 });

package/dist/cjs/transpiler/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/transpiler/index.ts"],"sourcesContent":["export * from './translation/index';\nexport * from './enumeration/index';\nexport * from './condition/index';\nexport * from './markdown/index';\nexport * from './nesting/index';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,gCAAd;AACA,+BAAc,gCADd;AAEA,+BAAc,8BAFd;AAGA,+BAAc,6BAHd;AAIA,+BAAc,4BAJd;","names":[]}
+{"version":3,"sources":["../../../src/transpiler/index.ts"],"sourcesContent":["export * from './translation/index';\nexport * from './enumeration/index';\nexport * from './condition/index';\nexport * from './insertion/index';\nexport * from './markdown/index';\nexport * from './nesting/index';\nexport type * from './file/index'; // Export type only because of file transpiler is based on node js function and block build\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,gCAAd;AACA,+BAAc,gCADd;AAEA,+BAAc,8BAFd;AAGA,+BAAc,8BAHd;AAIA,+BAAc,6BAJd;AAKA,+BAAc,4BALd;","names":[]}

package/dist/cjs/transpiler/insertion/getInsertionValues.cjs

@@ -0,0 +1,34 @@
+"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 getInsertionValues_exports = {};
+__export(getInsertionValues_exports, {
+  getInsertionValues: () => getInsertionValues
+});
+module.exports = __toCommonJS(getInsertionValues_exports);
+const getInsertionValues = (content) => {
+  const regex = /{{\s*(\w+)\s*}}/g;
+  const matches = [...content.matchAll(regex)];
+  if (matches.length === 0) return [];
+  return matches.map((match) => match[1]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getInsertionValues
+});
+//# sourceMappingURL=getInsertionValues.cjs.map

package/dist/cjs/transpiler/insertion/getInsertionValues.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/insertion/getInsertionValues.ts"],"sourcesContent":["export const getInsertionValues = (content: string): string[] => {\n  // Regular expression to match {{field}} patterns\n  const regex = /{{\\s*(\\w+)\\s*}}/g;\n  const matches = [...content.matchAll(regex)];\n\n  // If no matches are found, return undefined\n  if (matches.length === 0) return [];\n\n  // Extract field names from matches and return as an object with the field names\n  return matches.map((match) => match[1]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,qBAAqB,CAAC,YAA8B;AAE/D,QAAM,QAAQ;AACd,QAAM,UAAU,CAAC,GAAG,QAAQ,SAAS,KAAK,CAAC;AAG3C,MAAI,QAAQ,WAAW,EAAG,QAAO,CAAC;AAGlC,SAAO,QAAQ,IAAI,CAAC,UAAU,MAAM,CAAC,CAAC;AACxC;","names":[]}

package/dist/cjs/transpiler/insertion/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 insertion_exports = {};
+module.exports = __toCommonJS(insertion_exports);
+__reExport(insertion_exports, require('./insertion.cjs'), module.exports);
+__reExport(insertion_exports, require('./getInsertionValues.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./insertion.cjs'),
+  ...require('./getInsertionValues.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/transpiler/insertion/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/insertion/index.ts"],"sourcesContent":["export * from './insertion';\nexport * from './getInsertionValues';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,8BAAc,wBAAd;AACA,8BAAc,iCADd;","names":[]}

package/dist/cjs/transpiler/insertion/insertion.cjs

@@ -0,0 +1,54 @@
+"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 insertion_exports = {};
+__export(insertion_exports, {
+  insert: () => insertion
+});
+module.exports = __toCommonJS(insertion_exports);
+var import_types = require('../../types/index.cjs');
+var import_getInsertionValues = require('./getInsertionValues.cjs');
+const insertion = (content) => {
+  const getInsertions = () => {
+    if (typeof content === "string") {
+      return (0, import_getInsertionValues.getInsertionValues)(content);
+    }
+    let stringContent = void 0;
+    if (typeof content === "function") {
+      stringContent = content();
+    } else if (typeof content.then === "function") {
+      stringContent = async () => (0, import_getInsertionValues.getInsertionValues)(await content);
+    }
+    if (typeof stringContent === "string") {
+      return (0, import_getInsertionValues.getInsertionValues)(stringContent);
+    }
+    try {
+      return (0, import_getInsertionValues.getInsertionValues)(JSON.stringify(content));
+    } catch (e) {
+      return [];
+    }
+  };
+  return (0, import_types.formatNodeType)(import_types.NodeType.Insertion, content, {
+    fields: getInsertions()
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  insert
+});
+//# sourceMappingURL=insertion.cjs.map

package/dist/cjs/transpiler/insertion/insertion.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/insertion/insertion.ts"],"sourcesContent":["import {\n  formatNodeType,\n  NodeType,\n  type TypedNodeModel,\n} from '../../types/index';\nimport { getInsertionValues } from './getInsertionValues';\n\nexport type InsertionContent<Content = unknown> = TypedNodeModel<\n  NodeType.Insertion,\n  Content,\n  { fields: string[] }\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to identify insertions inside a content.\n *\n * Usage:\n *\n * ```ts\n * insertion('Hi, my name is {{name}} and I am {{age}} years old.')\n * ```\n *\n */\nconst insertion = <Content = unknown>(\n  content: Content\n): InsertionContent<Content> => {\n  const getInsertions = () => {\n    if (typeof content === 'string') {\n      return getInsertionValues(content);\n    }\n\n    let stringContent = undefined;\n\n    if (typeof content === 'function') {\n      stringContent = content();\n    } else if (typeof (content as Promise<string>).then === 'function') {\n      stringContent = async () =>\n        getInsertionValues(await (content as Promise<string>));\n    }\n\n    if (typeof stringContent === 'string') {\n      return getInsertionValues(stringContent);\n    }\n\n    try {\n      return getInsertionValues(JSON.stringify(content));\n    } catch (e) {\n      return [];\n    }\n  };\n\n  return formatNodeType(NodeType.Insertion, content, {\n    fields: getInsertions(),\n  });\n};\n\nexport { insertion as insert };\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAIO;AACP,gCAAmC;AAoBnC,MAAM,YAAY,CAChB,YAC8B;AAC9B,QAAM,gBAAgB,MAAM;AAC1B,QAAI,OAAO,YAAY,UAAU;AAC/B,iBAAO,8CAAmB,OAAO;AAAA,IACnC;AAEA,QAAI,gBAAgB;AAEpB,QAAI,OAAO,YAAY,YAAY;AACjC,sBAAgB,QAAQ;AAAA,IAC1B,WAAW,OAAQ,QAA4B,SAAS,YAAY;AAClE,sBAAgB,gBACd,8CAAmB,MAAO,OAA2B;AAAA,IACzD;AAEA,QAAI,OAAO,kBAAkB,UAAU;AACrC,iBAAO,8CAAmB,aAAa;AAAA,IACzC;AAEA,QAAI;AACF,iBAAO,8CAAmB,KAAK,UAAU,OAAO,CAAC;AAAA,IACnD,SAAS,GAAG;AACV,aAAO,CAAC;AAAA,IACV;AAAA,EACF;AAEA,aAAO,6BAAe,sBAAS,WAAW,SAAS;AAAA,IACjD,QAAQ,cAAc;AAAA,EACxB,CAAC;AACH;","names":[]}