@intlayer/core 7.0.1 → 7.0.2

package/dist/cjs/deepTransformPlugins/getSplittedContent.cjs

@@ -0,0 +1,123 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let __intlayer_types = require("@intlayer/types");
+__intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
+
+//#region src/deepTransformPlugins/getSplittedContent.ts
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const hasNodeType = (value) => isObject(value) && typeof value.nodeType === "string";
+const mergeValues = (a, b) => {
+	if (a === void 0) return b;
+	if (b === void 0) return a;
+	if (Array.isArray(a) && Array.isArray(b)) return [...a, ...b];
+	if (isObject(a) && isObject(b) && !hasNodeType(a) && !hasNodeType(b)) {
+		const result = { ...a };
+		for (const key of Object.keys(b)) result[key] = mergeValues(result[key], b[key]);
+		return result;
+	}
+	return b;
+};
+const mergeSplitResults = (base, addition) => {
+	const result = { ...base };
+	result.common = mergeValues(base.common, addition.common);
+	const localeKeys = new Set([...Object.keys(base).filter((k) => k !== "common"), ...Object.keys(addition).filter((k) => k !== "common")]);
+	for (const key of localeKeys) result[key] = mergeValues(base[key], addition[key]);
+	return result;
+};
+const splitNode = (node) => {
+	if (isObject(node) && node?.nodeType === __intlayer_types.NodeType.Translation) {
+		const translations = node[__intlayer_types.NodeType.Translation];
+		const result = {};
+		for (const locale of Object.keys(translations)) {
+			const child = translations[locale];
+			const childSplit = splitNode(child);
+			const mergedForLocale = mergeValues(childSplit.common, void 0);
+			let recomposed;
+			for (const key of Object.keys(childSplit)) {
+				if (key === "common") continue;
+				recomposed = mergeValues(recomposed, childSplit[key]);
+			}
+			const finalLocaleNode = mergeValues(mergedForLocale, recomposed);
+			if (finalLocaleNode !== void 0) result[locale] = finalLocaleNode;
+		}
+		return result;
+	}
+	if (Array.isArray(node)) {
+		const commonArray = [];
+		const perLocaleArrays = {};
+		node.forEach((child) => {
+			const childSplit = splitNode(child);
+			if (childSplit.common !== void 0) commonArray.push(childSplit.common);
+			for (const key of Object.keys(childSplit)) {
+				if (key === "common") continue;
+				if (!perLocaleArrays[key]) perLocaleArrays[key] = [];
+				const value = childSplit[key];
+				if (value !== void 0) perLocaleArrays[key].push(value);
+			}
+		});
+		const result = {};
+		if (commonArray.length > 0) result.common = commonArray;
+		for (const key of Object.keys(perLocaleArrays)) result[key] = perLocaleArrays[key];
+		return result;
+	}
+	if (isObject(node) && !hasNodeType(node)) {
+		let accumulated = {};
+		for (const key of Object.keys(node)) {
+			const childSplit = splitNode(node[key]);
+			if (childSplit.common !== void 0) accumulated = mergeSplitResults(accumulated, { common: { [key]: childSplit.common } });
+			for (const locale of Object.keys(childSplit)) {
+				if (locale === "common") continue;
+				accumulated = mergeSplitResults(accumulated, { [locale]: { [key]: childSplit[locale] } });
+			}
+		}
+		return accumulated;
+	}
+	return { common: node };
+};
+const getSplittedContent = (content) => {
+	const split = splitNode(content);
+	const output = {};
+	if (split.common !== void 0) output.common = split.common;
+	for (const key of Object.keys(split)) {
+		if (key === "common") continue;
+		const value = split[key];
+		if (value !== void 0) output[key] = value;
+	}
+	return output;
+};
+/**
+* Splits the `content` field of a Dictionary into "common" and per-locale buckets.
+*
+* Given a dictionary like:
+* ```js
+* {
+*   key: "my-key",
+*   content: {
+*     commonContent: "common content",
+*     multilingualContent: t({
+*       en: "english content",
+*       fr: "french content",
+*       de: "german content",
+*     }),
+*   },
+* }
+* ```
+*
+* It produces:
+* ```js
+* {
+*   common: { commonContent: "common content" },
+*   en: { multilingualContent: "english content" },
+*   fr: { multilingualContent: "french content" },
+*   de: { multilingualContent: "german content" },
+* }
+* ```
+*
+* @param dictionary - The input dictionary object with possible multilingual or common content.
+* @returns An object mapping "common" and each locale to their corresponding content subtrees.
+*/
+const getSplittedDictionaryContent = (dictionary) => getSplittedContent(dictionary.content);
+
+//#endregion
+exports.getSplittedContent = getSplittedContent;
+exports.getSplittedDictionaryContent = getSplittedDictionaryContent;
+//# sourceMappingURL=getSplittedContent.cjs.map

package/dist/cjs/deepTransformPlugins/getSplittedContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSplittedContent.cjs","names":["result: Record<string, any>","result: SplitResult","NodeType","recomposed: ContentNode | undefined","commonArray: any[]","perLocaleArrays: Record<string, any[]>","accumulated: SplitResult","output: Record<string, ContentNode>"],"sources":["../../../src/deepTransformPlugins/getSplittedContent.ts"],"sourcesContent":["import {\n  type ContentNode,\n  type DeclaredLocales,\n  type Dictionary,\n  NodeType,\n} from '@intlayer/types';\n\ntype SplittedContentOutput<T = ContentNode> = Record<DeclaredLocales, T> & {\n  common: T;\n};\n\ntype SplitResult = Record<string, ContentNode | undefined> & {\n  common?: ContentNode;\n};\n\nconst isObject = (value: unknown): value is Record<string, any> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\nconst hasNodeType = (value: unknown): value is { nodeType: string } =>\n  isObject(value) && typeof (value as any).nodeType === 'string';\n\nconst mergeValues = (\n  a: ContentNode | undefined,\n  b: ContentNode | undefined\n): ContentNode | undefined => {\n  if (a === undefined) return b;\n  if (b === undefined) return a;\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    // Concatenate arrays when merging sibling results\n    return [...a, ...b] as unknown as ContentNode;\n  }\n\n  if (isObject(a) && isObject(b) && !hasNodeType(a) && !hasNodeType(b)) {\n    const result: Record<string, any> = { ...a };\n    for (const key of Object.keys(b)) {\n      result[key] = mergeValues(\n        result[key] as unknown as ContentNode | undefined,\n        (b as Record<string, any>)[key] as unknown as ContentNode | undefined\n      );\n    }\n    return result as ContentNode;\n  }\n\n  // For primitives or differing structures, prefer b (more recent)\n  return b;\n};\n\nconst mergeSplitResults = (\n  base: SplitResult,\n  addition: SplitResult\n): SplitResult => {\n  const result: SplitResult = { ...base };\n\n  // Merge common\n  result.common = mergeValues(base.common, addition.common);\n\n  // Merge each locale key present in either side\n  const localeKeys = new Set<string>([\n    ...Object.keys(base).filter((k) => k !== 'common'),\n    ...Object.keys(addition).filter((k) => k !== 'common'),\n  ]);\n\n  for (const key of localeKeys) {\n    // @ts-ignore: dynamic keys for locales\n    result[key] = mergeValues(\n      base[key] as ContentNode | undefined,\n      addition[key] as ContentNode | undefined\n    );\n  }\n\n  return result;\n};\n\nconst splitNode = (node: ContentNode): SplitResult => {\n  // Translation node: allocate entirely to per-locale buckets\n  if (isObject(node) && (node as any)?.nodeType === NodeType.Translation) {\n    const translations = (node as any)[NodeType.Translation] as Record<\n      string,\n      ContentNode\n    >;\n\n    const result: SplitResult = {};\n    for (const locale of Object.keys(translations)) {\n      const child = translations[locale];\n      const childSplit = splitNode(child);\n\n      // The content under a translation belongs to the locale, not common\n      // Merge common portion of the child (if any) into the locale as well\n      const mergedForLocale = mergeValues(childSplit.common, undefined);\n\n      // Compose locale content: prefer the fully rebuilt child by resolving deeper translations recursively\n      // which are already split inside childSplit. We need to recompose a single node for this locale.\n      // Recompose by merging all keys in childSplit except 'common' into a single node, then merge child's common.\n      let recomposed: ContentNode | undefined;\n      for (const key of Object.keys(childSplit)) {\n        if (key === 'common') continue;\n        recomposed = mergeValues(\n          recomposed,\n          childSplit[key] as ContentNode | undefined\n        );\n      }\n      const finalLocaleNode = mergeValues(mergedForLocale, recomposed);\n\n      if (finalLocaleNode !== undefined) {\n        // @ts-ignore dynamic locale key\n        result[locale] = finalLocaleNode;\n      }\n    }\n\n    return result;\n  }\n\n  // Arrays: split each element and merge results index-wise\n  if (Array.isArray(node)) {\n    const commonArray: any[] = [];\n    const perLocaleArrays: Record<string, any[]> = {};\n\n    node.forEach((child) => {\n      const childSplit = splitNode(child as ContentNode);\n\n      if (childSplit.common !== undefined) {\n        commonArray.push(childSplit.common);\n      }\n\n      for (const key of Object.keys(childSplit)) {\n        if (key === 'common') continue;\n        if (!perLocaleArrays[key]) perLocaleArrays[key] = [];\n        const value = childSplit[key];\n        if (value !== undefined) perLocaleArrays[key].push(value);\n      }\n    });\n\n    const result: SplitResult = {};\n    if (commonArray.length > 0)\n      result.common = commonArray as unknown as ContentNode;\n    for (const key of Object.keys(perLocaleArrays)) {\n      // @ts-ignore dynamic locale key\n      result[key] = perLocaleArrays[key] as unknown as ContentNode;\n    }\n    return result;\n  }\n\n  // Objects (non-typed): recursively split properties\n  if (isObject(node) && !hasNodeType(node)) {\n    let accumulated: SplitResult = {};\n\n    for (const key of Object.keys(node)) {\n      const childSplit = splitNode((node as any)[key] as ContentNode);\n\n      // Assign property into common\n      if (childSplit.common !== undefined) {\n        accumulated = mergeSplitResults(accumulated, {\n          common: { [key]: childSplit.common } as unknown as ContentNode,\n        });\n      }\n\n      // Assign property into each locale bucket\n      for (const locale of Object.keys(childSplit)) {\n        if (locale === 'common') continue;\n        accumulated = mergeSplitResults(accumulated, {\n          // @ts-ignore dynamic locale key\n          [locale]: { [key]: childSplit[locale] } as unknown as ContentNode,\n        });\n      }\n    }\n\n    return accumulated;\n  }\n\n  // Primitives or typed nodes (non-translation): entirely common\n  return { common: node } as SplitResult;\n};\n\nexport const getSplittedContent = (\n  content: ContentNode\n): SplittedContentOutput => {\n  const split = splitNode(content);\n\n  // Build final output with only defined sections\n  const output: Record<string, ContentNode> = {};\n  if (split.common !== undefined) {\n    output.common = split.common;\n  }\n  for (const key of Object.keys(split)) {\n    if (key === 'common') continue;\n    const value = split[key] as ContentNode | undefined;\n    if (value !== undefined) {\n      output[key] = value;\n    }\n  }\n\n  return output as unknown as SplittedContentOutput;\n};\n\n/**\n * Splits the `content` field of a Dictionary into \"common\" and per-locale buckets.\n *\n * Given a dictionary like:\n * ```js\n * {\n *   key: \"my-key\",\n *   content: {\n *     commonContent: \"common content\",\n *     multilingualContent: t({\n *       en: \"english content\",\n *       fr: \"french content\",\n *       de: \"german content\",\n *     }),\n *   },\n * }\n * ```\n *\n * It produces:\n * ```js\n * {\n *   common: { commonContent: \"common content\" },\n *   en: { multilingualContent: \"english content\" },\n *   fr: { multilingualContent: \"french content\" },\n *   de: { multilingualContent: \"german content\" },\n * }\n * ```\n *\n * @param dictionary - The input dictionary object with possible multilingual or common content.\n * @returns An object mapping \"common\" and each locale to their corresponding content subtrees.\n */\nexport const getSplittedDictionaryContent = (\n  dictionary: Dictionary\n): SplittedContentOutput<Dictionary['content']> =>\n  getSplittedContent(dictionary.content);\n"],"mappings":";;;;;AAeA,MAAM,YAAY,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM;AAEtE,MAAM,eAAe,UACnB,SAAS,MAAM,IAAI,OAAQ,MAAc,aAAa;AAExD,MAAM,eACJ,GACA,MAC4B;AAC5B,KAAI,MAAM,OAAW,QAAO;AAC5B,KAAI,MAAM,OAAW,QAAO;AAE5B,KAAI,MAAM,QAAQ,EAAE,IAAI,MAAM,QAAQ,EAAE,CAEtC,QAAO,CAAC,GAAG,GAAG,GAAG,EAAE;AAGrB,KAAI,SAAS,EAAE,IAAI,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE;EACpE,MAAMA,SAA8B,EAAE,GAAG,GAAG;AAC5C,OAAK,MAAM,OAAO,OAAO,KAAK,EAAE,CAC9B,QAAO,OAAO,YACZ,OAAO,MACN,EAA0B,KAC5B;AAEH,SAAO;;AAIT,QAAO;;AAGT,MAAM,qBACJ,MACA,aACgB;CAChB,MAAMC,SAAsB,EAAE,GAAG,MAAM;AAGvC,QAAO,SAAS,YAAY,KAAK,QAAQ,SAAS,OAAO;CAGzD,MAAM,aAAa,IAAI,IAAY,CACjC,GAAG,OAAO,KAAK,KAAK,CAAC,QAAQ,MAAM,MAAM,SAAS,EAClD,GAAG,OAAO,KAAK,SAAS,CAAC,QAAQ,MAAM,MAAM,SAAS,CACvD,CAAC;AAEF,MAAK,MAAM,OAAO,WAEhB,QAAO,OAAO,YACZ,KAAK,MACL,SAAS,KACV;AAGH,QAAO;;AAGT,MAAM,aAAa,SAAmC;AAEpD,KAAI,SAAS,KAAK,IAAK,MAAc,aAAaC,0BAAS,aAAa;EACtE,MAAM,eAAgB,KAAaA,0BAAS;EAK5C,MAAMD,SAAsB,EAAE;AAC9B,OAAK,MAAM,UAAU,OAAO,KAAK,aAAa,EAAE;GAC9C,MAAM,QAAQ,aAAa;GAC3B,MAAM,aAAa,UAAU,MAAM;GAInC,MAAM,kBAAkB,YAAY,WAAW,QAAQ,OAAU;GAKjE,IAAIE;AACJ,QAAK,MAAM,OAAO,OAAO,KAAK,WAAW,EAAE;AACzC,QAAI,QAAQ,SAAU;AACtB,iBAAa,YACX,YACA,WAAW,KACZ;;GAEH,MAAM,kBAAkB,YAAY,iBAAiB,WAAW;AAEhE,OAAI,oBAAoB,OAEtB,QAAO,UAAU;;AAIrB,SAAO;;AAIT,KAAI,MAAM,QAAQ,KAAK,EAAE;EACvB,MAAMC,cAAqB,EAAE;EAC7B,MAAMC,kBAAyC,EAAE;AAEjD,OAAK,SAAS,UAAU;GACtB,MAAM,aAAa,UAAU,MAAqB;AAElD,OAAI,WAAW,WAAW,OACxB,aAAY,KAAK,WAAW,OAAO;AAGrC,QAAK,MAAM,OAAO,OAAO,KAAK,WAAW,EAAE;AACzC,QAAI,QAAQ,SAAU;AACtB,QAAI,CAAC,gBAAgB,KAAM,iBAAgB,OAAO,EAAE;IACpD,MAAM,QAAQ,WAAW;AACzB,QAAI,UAAU,OAAW,iBAAgB,KAAK,KAAK,MAAM;;IAE3D;EAEF,MAAMJ,SAAsB,EAAE;AAC9B,MAAI,YAAY,SAAS,EACvB,QAAO,SAAS;AAClB,OAAK,MAAM,OAAO,OAAO,KAAK,gBAAgB,CAE5C,QAAO,OAAO,gBAAgB;AAEhC,SAAO;;AAIT,KAAI,SAAS,KAAK,IAAI,CAAC,YAAY,KAAK,EAAE;EACxC,IAAIK,cAA2B,EAAE;AAEjC,OAAK,MAAM,OAAO,OAAO,KAAK,KAAK,EAAE;GACnC,MAAM,aAAa,UAAW,KAAa,KAAoB;AAG/D,OAAI,WAAW,WAAW,OACxB,eAAc,kBAAkB,aAAa,EAC3C,QAAQ,GAAG,MAAM,WAAW,QAAQ,EACrC,CAAC;AAIJ,QAAK,MAAM,UAAU,OAAO,KAAK,WAAW,EAAE;AAC5C,QAAI,WAAW,SAAU;AACzB,kBAAc,kBAAkB,aAAa,GAE1C,SAAS,GAAG,MAAM,WAAW,SAAS,EACxC,CAAC;;;AAIN,SAAO;;AAIT,QAAO,EAAE,QAAQ,MAAM;;AAGzB,MAAa,sBACX,YAC0B;CAC1B,MAAM,QAAQ,UAAU,QAAQ;CAGhC,MAAMC,SAAsC,EAAE;AAC9C,KAAI,MAAM,WAAW,OACnB,QAAO,SAAS,MAAM;AAExB,MAAK,MAAM,OAAO,OAAO,KAAK,MAAM,EAAE;AACpC,MAAI,QAAQ,SAAU;EACtB,MAAM,QAAQ,MAAM;AACpB,MAAI,UAAU,OACZ,QAAO,OAAO;;AAIlB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCT,MAAa,gCACX,eAEA,mBAAmB,WAAW,QAAQ"}

package/dist/cjs/deepTransformPlugins/index.cjs

@@ -5,6 +5,7 @@ const require_deepTransformPlugins_getLocalizedContent = require('./getLocalized
 const require_deepTransformPlugins_getMaskContent = require('./getMaskContent.cjs');
 const require_deepTransformPlugins_getMissingLocalesContent = require('./getMissingLocalesContent.cjs');
 const require_deepTransformPlugins_getReplacedValuesContent = require('./getReplacedValuesContent.cjs');
+const require_deepTransformPlugins_getSplittedContent = require('./getSplittedContent.cjs');
 const require_deepTransformPlugins_insertContentInDictionary = require('./insertContentInDictionary.cjs');
 
 exports.buildMaskPlugin = require_deepTransformPlugins_getMaskContent.buildMaskPlugin;
@@ -22,4 +23,6 @@ exports.getMaskContent = require_deepTransformPlugins_getMaskContent.getMaskCont
 exports.getMissingLocalesContent = require_deepTransformPlugins_getMissingLocalesContent.getMissingLocalesContent;
 exports.getPerLocaleDictionary = require_deepTransformPlugins_getLocalizedContent.getPerLocaleDictionary;
 exports.getReplacedValuesContent = require_deepTransformPlugins_getReplacedValuesContent.getReplacedValuesContent;
+exports.getSplittedContent = require_deepTransformPlugins_getSplittedContent.getSplittedContent;
+exports.getSplittedDictionaryContent = require_deepTransformPlugins_getSplittedContent.getSplittedDictionaryContent;
 exports.insertContentInDictionary = require_deepTransformPlugins_insertContentInDictionary.insertContentInDictionary;

package/dist/cjs/dictionaryManipulator/getContentNodeByKeyPath.cjs

@@ -3,11 +3,14 @@ let __intlayer_types = require("@intlayer/types");
 __intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
 
 //#region src/dictionaryManipulator/getContentNodeByKeyPath.ts
-const getContentNodeByKeyPath = (dictionaryContent, keyPath) => {
+const getContentNodeByKeyPath = (dictionaryContent, keyPath, fallbackLocale) => {
 	let currentValue = structuredClone(dictionaryContent);
-	for (const keyObj of keyPath) if (keyObj.type === __intlayer_types.NodeType.Object || keyObj.type === __intlayer_types.NodeType.Array) currentValue = currentValue?.[keyObj.key];
-	else if (keyObj.type === __intlayer_types.NodeType.Translation || keyObj.type === __intlayer_types.NodeType.Condition || keyObj.type === __intlayer_types.NodeType.Enumeration) currentValue = currentValue?.[keyObj.type]?.[keyObj.key];
-	else if (keyObj.type === __intlayer_types.NodeType.Markdown || keyObj.type === __intlayer_types.NodeType.Insertion || keyObj.type === __intlayer_types.NodeType.File) currentValue = currentValue?.[keyObj.type];
+	for (const keyObj of keyPath) {
+		if (fallbackLocale && currentValue?.nodeType === __intlayer_types.NodeType.Translation) currentValue = currentValue?.[__intlayer_types.NodeType.Translation]?.[fallbackLocale];
+		if (keyObj.type === __intlayer_types.NodeType.Object || keyObj.type === __intlayer_types.NodeType.Array) currentValue = currentValue?.[keyObj.key];
+		if (keyObj.type === __intlayer_types.NodeType.Translation || keyObj.type === __intlayer_types.NodeType.Condition || keyObj.type === __intlayer_types.NodeType.Enumeration) currentValue = currentValue?.[keyObj.type]?.[keyObj.key];
+		if (keyObj.type === __intlayer_types.NodeType.Markdown || keyObj.type === __intlayer_types.NodeType.Insertion || keyObj.type === __intlayer_types.NodeType.File) currentValue = currentValue?.[keyObj.type];
+	}
 	return currentValue;
 };
 

package/dist/cjs/dictionaryManipulator/getContentNodeByKeyPath.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getContentNodeByKeyPath.cjs","names":["currentValue: any","NodeType"],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"sourcesContent":["import { type ContentNode, type KeyPath, NodeType } from '@intlayer/types';\n\nexport const getContentNodeByKeyPath = (\n  dictionaryContent: ContentNode,\n  keyPath: KeyPath[]\n): ContentNode => {\n  let currentValue: any = structuredClone(dictionaryContent);\n\n  for (const keyObj of keyPath) {\n    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {\n      currentValue = currentValue?.[keyObj.key];\n    } else if (\n      keyObj.type === NodeType.Translation ||\n      keyObj.type === NodeType.Condition ||\n      keyObj.type === NodeType.Enumeration\n    ) {\n      currentValue = currentValue?.[keyObj.type]?.[keyObj.key];\n    } else if (\n      keyObj.type === NodeType.Markdown ||\n      keyObj.type === NodeType.Insertion ||\n      keyObj.type === NodeType.File\n    ) {\n      currentValue = currentValue?.[keyObj.type];\n    }\n  }\n\n  return currentValue as ContentNode;\n};\n"],"mappings":";;;;;AAEA,MAAa,2BACX,mBACA,YACgB;CAChB,IAAIA,eAAoB,gBAAgB,kBAAkB;AAE1D,MAAK,MAAM,UAAU,QACnB,KAAI,OAAO,SAASC,0BAAS,UAAU,OAAO,SAASA,0BAAS,MAC9D,gBAAe,eAAe,OAAO;UAErC,OAAO,SAASA,0BAAS,eACzB,OAAO,SAASA,0BAAS,aACzB,OAAO,SAASA,0BAAS,YAEzB,gBAAe,eAAe,OAAO,QAAQ,OAAO;UAEpD,OAAO,SAASA,0BAAS,YACzB,OAAO,SAASA,0BAAS,aACzB,OAAO,SAASA,0BAAS,KAEzB,gBAAe,eAAe,OAAO;AAIzC,QAAO"}
+{"version":3,"file":"getContentNodeByKeyPath.cjs","names":["currentValue: any","NodeType"],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"sourcesContent":["import {\n  type ContentNode,\n  type KeyPath,\n  type Locale,\n  NodeType,\n} from '@intlayer/types';\n\nexport const getContentNodeByKeyPath = (\n  dictionaryContent: ContentNode,\n  keyPath: KeyPath[],\n  fallbackLocale?: Locale\n): ContentNode => {\n  let currentValue: any = structuredClone(dictionaryContent);\n\n  for (const keyObj of keyPath) {\n    // Auto-resolve translation nodes when fallbackLocale is provided\n    if (fallbackLocale && currentValue?.nodeType === NodeType.Translation) {\n      currentValue = currentValue?.[NodeType.Translation]?.[fallbackLocale];\n    }\n\n    if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {\n      currentValue = currentValue?.[keyObj.key];\n    }\n\n    if (\n      keyObj.type === NodeType.Translation ||\n      keyObj.type === NodeType.Condition ||\n      keyObj.type === NodeType.Enumeration\n    ) {\n      currentValue = currentValue?.[keyObj.type]?.[keyObj.key];\n    }\n\n    if (\n      keyObj.type === NodeType.Markdown ||\n      keyObj.type === NodeType.Insertion ||\n      keyObj.type === NodeType.File\n    ) {\n      currentValue = currentValue?.[keyObj.type];\n    }\n  }\n\n  return currentValue as ContentNode;\n};\n"],"mappings":";;;;;AAOA,MAAa,2BACX,mBACA,SACA,mBACgB;CAChB,IAAIA,eAAoB,gBAAgB,kBAAkB;AAE1D,MAAK,MAAM,UAAU,SAAS;AAE5B,MAAI,kBAAkB,cAAc,aAAaC,0BAAS,YACxD,gBAAe,eAAeA,0BAAS,eAAe;AAGxD,MAAI,OAAO,SAASA,0BAAS,UAAU,OAAO,SAASA,0BAAS,MAC9D,gBAAe,eAAe,OAAO;AAGvC,MACE,OAAO,SAASA,0BAAS,eACzB,OAAO,SAASA,0BAAS,aACzB,OAAO,SAASA,0BAAS,YAEzB,gBAAe,eAAe,OAAO,QAAQ,OAAO;AAGtD,MACE,OAAO,SAASA,0BAAS,YACzB,OAAO,SAASA,0BAAS,aACzB,OAAO,SAASA,0BAAS,KAEzB,gBAAe,eAAe,OAAO;;AAIzC,QAAO"}

package/dist/cjs/dictionaryManipulator/getUnmergedDictionaryByKeyPath.cjs

@@ -11,7 +11,7 @@ const getUnmergedDictionaryByKeyPath = (dictionaryKey, keyPath, dictionariesReco
 	const unmergedEntries = (dictionariesRecord ?? (0, __intlayer_unmerged_dictionaries_entry.getUnmergedDictionaries)(configuration))?.[dictionaryKey];
 	if (!unmergedEntries) return null;
 	const normalizedUnmergedEntries = require_dictionaryManipulator_normalizeDictionary.normalizeDictionaries(unmergedEntries, configuration);
-	for (const dictionary of normalizedUnmergedEntries) if (require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath(dictionary.content, keyPath)) return dictionary;
+	for (const dictionary of normalizedUnmergedEntries) if (require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath(dictionary.content, keyPath)) return unmergedEntries.find((entry) => entry.localId === dictionary.localId);
 	for (const dictionary of unmergedEntries) if (require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath(dictionary.content, keyPath)) return dictionary;
 };
 

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

@@ -1 +1 @@
-{"version":3,"file":"getUnmergedDictionaryByKeyPath.cjs","names":["intlayerConfiguration","normalizeDictionaries","getContentNodeByKeyPath"],"sources":["../../../src/dictionaryManipulator/getUnmergedDictionaryByKeyPath.ts"],"sourcesContent":["import intlayerConfiguration from '@intlayer/config/built';\nimport type { IntlayerConfig, KeyPath } from '@intlayer/types';\nimport {\n  getUnmergedDictionaries,\n  type UnmergedDictionaries,\n} from '@intlayer/unmerged-dictionaries-entry';\nimport { getContentNodeByKeyPath } from './getContentNodeByKeyPath';\nimport { normalizeDictionaries } from './normalizeDictionary';\n\nexport const getUnmergedDictionaryByKeyPath = (\n  dictionaryKey: string,\n  keyPath: KeyPath[],\n  dictionariesRecord?: UnmergedDictionaries,\n  configuration: IntlayerConfig = intlayerConfiguration\n) => {\n  const unmergedEntries = (dictionariesRecord ??\n    getUnmergedDictionaries(configuration))?.[dictionaryKey];\n\n  if (!unmergedEntries) {\n    return null;\n  }\n\n  const normalizedUnmergedEntries = normalizeDictionaries(\n    unmergedEntries,\n    configuration\n  );\n\n  for (const dictionary of normalizedUnmergedEntries) {\n    const content = getContentNodeByKeyPath(dictionary.content, keyPath);\n\n    if (content) {\n      return dictionary;\n    }\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":";;;;;;;;;AASA,MAAa,kCACX,eACA,SACA,oBACA,gBAAgCA,oCAC7B;CACH,MAAM,mBAAmB,0FACC,cAAc,IAAI;AAE5C,KAAI,CAAC,gBACH,QAAO;CAGT,MAAM,4BAA4BC,wEAChC,iBACA,cACD;AAED,MAAK,MAAM,cAAc,0BAGvB,KAFgBC,8EAAwB,WAAW,SAAS,QAAQ,CAGlE,QAAO;AAIX,MAAK,MAAM,cAAc,gBAGvB,KAFgBA,8EAAwB,WAAW,SAAS,QAAQ,CAGlE,QAAO"}
+{"version":3,"file":"getUnmergedDictionaryByKeyPath.cjs","names":["intlayerConfiguration","normalizeDictionaries","getContentNodeByKeyPath"],"sources":["../../../src/dictionaryManipulator/getUnmergedDictionaryByKeyPath.ts"],"sourcesContent":["import intlayerConfiguration from '@intlayer/config/built';\nimport type { IntlayerConfig, KeyPath } from '@intlayer/types';\nimport {\n  getUnmergedDictionaries,\n  type UnmergedDictionaries,\n} from '@intlayer/unmerged-dictionaries-entry';\nimport { getContentNodeByKeyPath } from './getContentNodeByKeyPath';\nimport { normalizeDictionaries } from './normalizeDictionary';\n\nexport const getUnmergedDictionaryByKeyPath = (\n  dictionaryKey: string,\n  keyPath: KeyPath[],\n  dictionariesRecord?: UnmergedDictionaries,\n  configuration: IntlayerConfig = intlayerConfiguration\n) => {\n  const unmergedEntries = (dictionariesRecord ??\n    getUnmergedDictionaries(configuration))?.[dictionaryKey];\n\n  if (!unmergedEntries) {\n    return null;\n  }\n\n  // First search for the dictionary in the normalized dictionaries as it's what see the client editor selector\n  // Then return the original unmerged dictionary if not found in the normalized dictionaries\n\n  const normalizedUnmergedEntries = normalizeDictionaries(\n    unmergedEntries,\n    configuration\n  );\n\n  for (const dictionary of normalizedUnmergedEntries) {\n    const content = getContentNodeByKeyPath(dictionary.content, keyPath);\n\n    if (content) {\n      return unmergedEntries.find(\n        (entry) => entry.localId === dictionary.localId\n      );\n    }\n  }\n\n  // If not found in the normalized dictionaries, search in the original unmerged dictionaries directly\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":";;;;;;;;;AASA,MAAa,kCACX,eACA,SACA,oBACA,gBAAgCA,oCAC7B;CACH,MAAM,mBAAmB,0FACC,cAAc,IAAI;AAE5C,KAAI,CAAC,gBACH,QAAO;CAMT,MAAM,4BAA4BC,wEAChC,iBACA,cACD;AAED,MAAK,MAAM,cAAc,0BAGvB,KAFgBC,8EAAwB,WAAW,SAAS,QAAQ,CAGlE,QAAO,gBAAgB,MACpB,UAAU,MAAM,YAAY,WAAW,QACzC;AAML,MAAK,MAAM,cAAc,gBAGvB,KAFgBA,8EAAwB,WAAW,SAAS,QAAQ,CAGlE,QAAO"}

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -4,10 +4,9 @@ const require_dictionaryManipulator_getDefaultNode = require('./getDefaultNode.c
 const require_dictionaryManipulator_getEmptyNode = require('./getEmptyNode.cjs');
 const require_dictionaryManipulator_getNodeChildren = require('./getNodeChildren.cjs');
 const require_dictionaryManipulator_getNodeType = require('./getNodeType.cjs');
+const require_dictionaryManipulator_mergeDictionaries = require('./mergeDictionaries.cjs');
 const require_dictionaryManipulator_orderDictionaries = require('./orderDictionaries.cjs');
 const require_dictionaryManipulator_normalizeDictionary = require('./normalizeDictionary.cjs');
-const require_dictionaryManipulator_getUnmergedDictionaryByKeyPath = require('./getUnmergedDictionaryByKeyPath.cjs');
-const require_dictionaryManipulator_mergeDictionaries = require('./mergeDictionaries.cjs');
 const require_dictionaryManipulator_removeContentNodeByKeyPath = require('./removeContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_renameContentNodeByKeyPath = require('./renameContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_updateNodeChildren = require('./updateNodeChildren.cjs');
@@ -18,7 +17,6 @@ exports.getDefaultNode = require_dictionaryManipulator_getDefaultNode.getDefault
 exports.getEmptyNode = require_dictionaryManipulator_getEmptyNode.getEmptyNode;
 exports.getNodeChildren = require_dictionaryManipulator_getNodeChildren.getNodeChildren;
 exports.getNodeType = require_dictionaryManipulator_getNodeType.getNodeType;
-exports.getUnmergedDictionaryByKeyPath = require_dictionaryManipulator_getUnmergedDictionaryByKeyPath.getUnmergedDictionaryByKeyPath;
 exports.mergeDictionaries = require_dictionaryManipulator_mergeDictionaries.mergeDictionaries;
 exports.normalizeDictionaries = require_dictionaryManipulator_normalizeDictionary.normalizeDictionaries;
 exports.normalizeDictionary = require_dictionaryManipulator_normalizeDictionary.normalizeDictionary;

package/dist/cjs/index.cjs

@@ -25,6 +25,7 @@ const require_deepTransformPlugins_getLocalizedContent = require('./deepTransfor
 const require_deepTransformPlugins_getMaskContent = require('./deepTransformPlugins/getMaskContent.cjs');
 const require_deepTransformPlugins_getMissingLocalesContent = require('./deepTransformPlugins/getMissingLocalesContent.cjs');
 const require_deepTransformPlugins_getReplacedValuesContent = require('./deepTransformPlugins/getReplacedValuesContent.cjs');
+const require_deepTransformPlugins_getSplittedContent = require('./deepTransformPlugins/getSplittedContent.cjs');
 const require_deepTransformPlugins_insertContentInDictionary = require('./deepTransformPlugins/insertContentInDictionary.cjs');
 const require_dictionaryManipulator_editDictionaryByKeyPath = require('./dictionaryManipulator/editDictionaryByKeyPath.cjs');
 const require_dictionaryManipulator_getContentNodeByKeyPath = require('./dictionaryManipulator/getContentNodeByKeyPath.cjs');
@@ -33,10 +34,9 @@ const require_dictionaryManipulator_getEmptyNode = require('./dictionaryManipula
 const require_dictionaryManipulator_getNodeChildren = require('./dictionaryManipulator/getNodeChildren.cjs');
 const require_utils_isValidReactElement = require('./utils/isValidReactElement.cjs');
 const require_dictionaryManipulator_getNodeType = require('./dictionaryManipulator/getNodeType.cjs');
+const require_dictionaryManipulator_mergeDictionaries = require('./dictionaryManipulator/mergeDictionaries.cjs');
 const require_dictionaryManipulator_orderDictionaries = require('./dictionaryManipulator/orderDictionaries.cjs');
 const require_dictionaryManipulator_normalizeDictionary = require('./dictionaryManipulator/normalizeDictionary.cjs');
-const require_dictionaryManipulator_getUnmergedDictionaryByKeyPath = require('./dictionaryManipulator/getUnmergedDictionaryByKeyPath.cjs');
-const require_dictionaryManipulator_mergeDictionaries = require('./dictionaryManipulator/mergeDictionaries.cjs');
 const require_dictionaryManipulator_removeContentNodeByKeyPath = require('./dictionaryManipulator/removeContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_renameContentNodeByKeyPath = require('./dictionaryManipulator/renameContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_updateNodeChildren = require('./dictionaryManipulator/updateNodeChildren.cjs');
@@ -119,9 +119,10 @@ exports.getNodeType = require_dictionaryManipulator_getNodeType.getNodeType;
 exports.getPathWithoutLocale = require_localization_getPathWithoutLocale.getPathWithoutLocale;
 exports.getPerLocaleDictionary = require_deepTransformPlugins_getLocalizedContent.getPerLocaleDictionary;
 exports.getReplacedValuesContent = require_deepTransformPlugins_getReplacedValuesContent.getReplacedValuesContent;
+exports.getSplittedContent = require_deepTransformPlugins_getSplittedContent.getSplittedContent;
+exports.getSplittedDictionaryContent = require_deepTransformPlugins_getSplittedContent.getSplittedDictionaryContent;
 exports.getStorageAttributes = require_getStorageAttributes.getStorageAttributes;
 exports.getTranslation = require_interpreter_getTranslation.getTranslation;
-exports.getUnmergedDictionaryByKeyPath = require_dictionaryManipulator_getUnmergedDictionaryByKeyPath.getUnmergedDictionaryByKeyPath;
 exports.insert = require_transpiler_insertion_insertion.insert;
 exports.insertContentInDictionary = require_deepTransformPlugins_insertContentInDictionary.insertContentInDictionary;
 exports.insertionPlugin = require_interpreter_getContent_plugins.insertionPlugin;

package/dist/cjs/localization/getMultilingualUrls.cjs

@@ -1,10 +1,10 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_utils_checkIsURLAbsolute = require('../utils/checkIsURLAbsolute.cjs');
 const require_localization_getPathWithoutLocale = require('./getPathWithoutLocale.cjs');
+let __intlayer_config_client = require("@intlayer/config/client");
+__intlayer_config_client = require_rolldown_runtime.__toESM(__intlayer_config_client);
 let __intlayer_config_built = require("@intlayer/config/built");
 __intlayer_config_built = require_rolldown_runtime.__toESM(__intlayer_config_built);
-let __intlayer_config = require("@intlayer/config");
-__intlayer_config = require_rolldown_runtime.__toESM(__intlayer_config);
 
 //#region src/localization/getMultilingualUrls.ts
 /**
@@ -47,7 +47,7 @@ const getMultilingualUrls = (url, locales = __intlayer_config_built.default?.int
 	let pathname = parsedUrl.pathname;
 	if (!pathname.startsWith("/")) pathname = `/${pathname}`;
 	const baseUrl = isAbsoluteUrl ? `${parsedUrl.protocol}//${parsedUrl.host}` : "";
-	const routingMode = mode ?? __intlayer_config.DefaultValues.Routing.ROUTING_MODE;
+	const routingMode = mode ?? __intlayer_config_client.DefaultValues.Routing.ROUTING_MODE;
 	return (locales ?? []).reduce((acc, locale) => {
 		const isDefaultLocale = locale?.toString() === defaultLocale?.toString();
 		let localizedUrl;

package/dist/cjs/localization/getMultilingualUrls.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getMultilingualUrls.cjs","names":["configuration","getPathWithoutLocale","checkIsURLAbsolute","DefaultValues","localizedUrl: string"],"sources":["../../../src/localization/getMultilingualUrls.ts"],"sourcesContent":["import { DefaultValues } from '@intlayer/config';\nimport configuration from '@intlayer/config/built';\nimport type { LocalesValues, StrictModeLocaleMap } from '@intlayer/types';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\n\n/**\n * Generates multilingual URLs by prefixing the given URL with each supported locale\n * or adding search parameters based on the routing mode.\n * Handles both absolute and relative URLs appropriately.\n *\n * This function gets the locales, default locale, and routing mode from the configuration if not provided.\n *\n * Example:\n *\n * ```ts\n *  // prefix-no-default mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-no-default')\n *     // Returns { en: '/dashboard', fr: '/fr/dashboard' }\n *\n *  // prefix-all mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-all')\n *     // Returns { en: '/en/dashboard', fr: '/fr/dashboard' }\n *\n *  // search-params mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'search-params')\n *     // Returns { en: '/dashboard?locale=en', fr: '/dashboard?locale=fr' }\n *\n *  // no-prefix mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'no-prefix')\n *     // Returns { en: '/dashboard', fr: '/dashboard' }\n * ```\n *\n * @param url - The original URL string to be processed.\n * @param locales - Optional array of supported locales. Defaults to configured locales.\n * @param defaultLocale - The default locale. Defaults to configured default locale.\n * @param mode - URL routing mode for locale handling. Defaults to configured mode.\n * @returns An object mapping each locale to its corresponding multilingual URL.\n */\nexport const getMultilingualUrls = (\n  url: string,\n  locales: LocalesValues[] | undefined = configuration?.internationalization\n    ?.locales,\n  defaultLocale: LocalesValues | undefined = configuration?.internationalization\n    ?.defaultLocale,\n  mode:\n    | 'prefix-no-default'\n    | 'prefix-all'\n    | 'no-prefix'\n    | 'search-params'\n    | undefined = configuration?.routing?.mode\n): StrictModeLocaleMap<string> => {\n  // Remove any existing locale segment from the URL\n  const urlWithoutLocale = getPathWithoutLocale(url, locales);\n\n  // Determine if the original URL is absolute (includes protocol)\n  const isAbsoluteUrl = checkIsURLAbsolute(urlWithoutLocale);\n\n  // Initialize a URL object if the URL is absolute\n  // For relative URLs, use a dummy base to leverage the URL API\n  const parsedUrl = isAbsoluteUrl\n    ? new URL(urlWithoutLocale)\n    : new URL(urlWithoutLocale, 'http://example.com');\n\n  // Extract the pathname from the parsed URL\n  let pathname = parsedUrl.pathname;\n\n  // Ensure the pathname starts with a '/'\n  if (!pathname.startsWith('/')) {\n    pathname = `/${pathname}`;\n  }\n\n  // Prepare the base URL (protocol + host) if it's absolute\n  const baseUrl = isAbsoluteUrl\n    ? `${parsedUrl.protocol}//${parsedUrl.host}`\n    : '';\n\n  // Default mode to 'prefix-no-default' if not provided\n  const routingMode = mode ?? DefaultValues.Routing.ROUTING_MODE;\n\n  // Generate multilingual URLs by iterating over each locale\n  const multilingualUrls = (locales ?? []).reduce<StrictModeLocaleMap<string>>(\n    (acc, locale) => {\n      // Determine if the current locale is the default locale\n      const isDefaultLocale = locale?.toString() === defaultLocale?.toString();\n\n      let localizedUrl: string;\n\n      if (routingMode === 'search-params') {\n        // Use search parameters for locale handling\n        const searchParams = new URLSearchParams(parsedUrl.search);\n        searchParams.set('locale', locale.toString());\n\n        const queryString = searchParams.toString();\n        const pathWithQuery = queryString\n          ? `${pathname}?${queryString}`\n          : pathname;\n\n        localizedUrl = isAbsoluteUrl\n          ? `${baseUrl}${pathWithQuery}${parsedUrl.hash}`\n          : `${pathWithQuery}${parsedUrl.hash}`;\n      } else if (routingMode === 'no-prefix') {\n        // No locale prefixing\n        localizedUrl = isAbsoluteUrl\n          ? `${baseUrl}${pathname}${parsedUrl.search}${parsedUrl.hash}`\n          : `${pathname}${parsedUrl.search}${parsedUrl.hash}`;\n      } else {\n        // Handle prefix-based modes (prefix-all or prefix-no-default)\n        const shouldPrefix =\n          routingMode === 'prefix-all' ||\n          (routingMode === 'prefix-no-default' && !isDefaultLocale);\n\n        // Construct the new pathname with or without the locale prefix\n        let localizedPath = shouldPrefix ? `/${locale}${pathname}` : pathname;\n\n        if (localizedPath.length > 1 && localizedPath.endsWith('/')) {\n          localizedPath = localizedPath.slice(0, -1);\n        }\n\n        // Combine with the base URL if the original URL was absolute\n        localizedUrl = isAbsoluteUrl\n          ? `${baseUrl}${localizedPath}${parsedUrl.search}${parsedUrl.hash}`\n          : `${localizedPath}${parsedUrl.search}${parsedUrl.hash}`;\n      }\n\n      // Assign the constructed URL to the corresponding locale key\n      acc[locale as unknown as keyof typeof acc] = localizedUrl;\n\n      return acc;\n    },\n    {} as StrictModeLocaleMap<string>\n  );\n\n  return multilingualUrls;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,uBACX,KACA,UAAuCA,iCAAe,sBAClD,SACJ,gBAA2CA,iCAAe,sBACtD,eACJ,OAKgBA,iCAAe,SAAS,SACR;CAEhC,MAAM,mBAAmBC,+DAAqB,KAAK,QAAQ;CAG3D,MAAM,gBAAgBC,oDAAmB,iBAAiB;CAI1D,MAAM,YAAY,gBACd,IAAI,IAAI,iBAAiB,GACzB,IAAI,IAAI,kBAAkB,qBAAqB;CAGnD,IAAI,WAAW,UAAU;AAGzB,KAAI,CAAC,SAAS,WAAW,IAAI,CAC3B,YAAW,IAAI;CAIjB,MAAM,UAAU,gBACZ,GAAG,UAAU,SAAS,IAAI,UAAU,SACpC;CAGJ,MAAM,cAAc,QAAQC,gCAAc,QAAQ;AAuDlD,SApD0B,WAAW,EAAE,EAAE,QACtC,KAAK,WAAW;EAEf,MAAM,kBAAkB,QAAQ,UAAU,KAAK,eAAe,UAAU;EAExE,IAAIC;AAEJ,MAAI,gBAAgB,iBAAiB;GAEnC,MAAM,eAAe,IAAI,gBAAgB,UAAU,OAAO;AAC1D,gBAAa,IAAI,UAAU,OAAO,UAAU,CAAC;GAE7C,MAAM,cAAc,aAAa,UAAU;GAC3C,MAAM,gBAAgB,cAClB,GAAG,SAAS,GAAG,gBACf;AAEJ,kBAAe,gBACX,GAAG,UAAU,gBAAgB,UAAU,SACvC,GAAG,gBAAgB,UAAU;aACxB,gBAAgB,YAEzB,gBAAe,gBACX,GAAG,UAAU,WAAW,UAAU,SAAS,UAAU,SACrD,GAAG,WAAW,UAAU,SAAS,UAAU;OAC1C;GAOL,IAAI,gBAJF,gBAAgB,gBACf,gBAAgB,uBAAuB,CAAC,kBAGR,IAAI,SAAS,aAAa;AAE7D,OAAI,cAAc,SAAS,KAAK,cAAc,SAAS,IAAI,CACzD,iBAAgB,cAAc,MAAM,GAAG,GAAG;AAI5C,kBAAe,gBACX,GAAG,UAAU,gBAAgB,UAAU,SAAS,UAAU,SAC1D,GAAG,gBAAgB,UAAU,SAAS,UAAU;;AAItD,MAAI,UAAyC;AAE7C,SAAO;IAET,EAAE,CACH"}
+{"version":3,"file":"getMultilingualUrls.cjs","names":["configuration","getPathWithoutLocale","checkIsURLAbsolute","DefaultValues","localizedUrl: string"],"sources":["../../../src/localization/getMultilingualUrls.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { DefaultValues } from '@intlayer/config/client';\nimport type { LocalesValues, StrictModeLocaleMap } from '@intlayer/types';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\n\n/**\n * Generates multilingual URLs by prefixing the given URL with each supported locale\n * or adding search parameters based on the routing mode.\n * Handles both absolute and relative URLs appropriately.\n *\n * This function gets the locales, default locale, and routing mode from the configuration if not provided.\n *\n * Example:\n *\n * ```ts\n *  // prefix-no-default mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-no-default')\n *     // Returns { en: '/dashboard', fr: '/fr/dashboard' }\n *\n *  // prefix-all mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-all')\n *     // Returns { en: '/en/dashboard', fr: '/fr/dashboard' }\n *\n *  // search-params mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'search-params')\n *     // Returns { en: '/dashboard?locale=en', fr: '/dashboard?locale=fr' }\n *\n *  // no-prefix mode\n *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'no-prefix')\n *     // Returns { en: '/dashboard', fr: '/dashboard' }\n * ```\n *\n * @param url - The original URL string to be processed.\n * @param locales - Optional array of supported locales. Defaults to configured locales.\n * @param defaultLocale - The default locale. Defaults to configured default locale.\n * @param mode - URL routing mode for locale handling. Defaults to configured mode.\n * @returns An object mapping each locale to its corresponding multilingual URL.\n */\nexport const getMultilingualUrls = (\n  url: string,\n  locales: LocalesValues[] | undefined = configuration?.internationalization\n    ?.locales,\n  defaultLocale: LocalesValues | undefined = configuration?.internationalization\n    ?.defaultLocale,\n  mode:\n    | 'prefix-no-default'\n    | 'prefix-all'\n    | 'no-prefix'\n    | 'search-params'\n    | undefined = configuration?.routing?.mode\n): StrictModeLocaleMap<string> => {\n  // Remove any existing locale segment from the URL\n  const urlWithoutLocale = getPathWithoutLocale(url, locales);\n\n  // Determine if the original URL is absolute (includes protocol)\n  const isAbsoluteUrl = checkIsURLAbsolute(urlWithoutLocale);\n\n  // Initialize a URL object if the URL is absolute\n  // For relative URLs, use a dummy base to leverage the URL API\n  const parsedUrl = isAbsoluteUrl\n    ? new URL(urlWithoutLocale)\n    : new URL(urlWithoutLocale, 'http://example.com');\n\n  // Extract the pathname from the parsed URL\n  let pathname = parsedUrl.pathname;\n\n  // Ensure the pathname starts with a '/'\n  if (!pathname.startsWith('/')) {\n    pathname = `/${pathname}`;\n  }\n\n  // Prepare the base URL (protocol + host) if it's absolute\n  const baseUrl = isAbsoluteUrl\n    ? `${parsedUrl.protocol}//${parsedUrl.host}`\n    : '';\n\n  // Default mode to 'prefix-no-default' if not provided\n  const routingMode = mode ?? DefaultValues.Routing.ROUTING_MODE;\n\n  // Generate multilingual URLs by iterating over each locale\n  const multilingualUrls = (locales ?? []).reduce<StrictModeLocaleMap<string>>(\n    (acc, locale) => {\n      // Determine if the current locale is the default locale\n      const isDefaultLocale = locale?.toString() === defaultLocale?.toString();\n\n      let localizedUrl: string;\n\n      if (routingMode === 'search-params') {\n        // Use search parameters for locale handling\n        const searchParams = new URLSearchParams(parsedUrl.search);\n        searchParams.set('locale', locale.toString());\n\n        const queryString = searchParams.toString();\n        const pathWithQuery = queryString\n          ? `${pathname}?${queryString}`\n          : pathname;\n\n        localizedUrl = isAbsoluteUrl\n          ? `${baseUrl}${pathWithQuery}${parsedUrl.hash}`\n          : `${pathWithQuery}${parsedUrl.hash}`;\n      } else if (routingMode === 'no-prefix') {\n        // No locale prefixing\n        localizedUrl = isAbsoluteUrl\n          ? `${baseUrl}${pathname}${parsedUrl.search}${parsedUrl.hash}`\n          : `${pathname}${parsedUrl.search}${parsedUrl.hash}`;\n      } else {\n        // Handle prefix-based modes (prefix-all or prefix-no-default)\n        const shouldPrefix =\n          routingMode === 'prefix-all' ||\n          (routingMode === 'prefix-no-default' && !isDefaultLocale);\n\n        // Construct the new pathname with or without the locale prefix\n        let localizedPath = shouldPrefix ? `/${locale}${pathname}` : pathname;\n\n        if (localizedPath.length > 1 && localizedPath.endsWith('/')) {\n          localizedPath = localizedPath.slice(0, -1);\n        }\n\n        // Combine with the base URL if the original URL was absolute\n        localizedUrl = isAbsoluteUrl\n          ? `${baseUrl}${localizedPath}${parsedUrl.search}${parsedUrl.hash}`\n          : `${localizedPath}${parsedUrl.search}${parsedUrl.hash}`;\n      }\n\n      // Assign the constructed URL to the corresponding locale key\n      acc[locale as unknown as keyof typeof acc] = localizedUrl;\n\n      return acc;\n    },\n    {} as StrictModeLocaleMap<string>\n  );\n\n  return multilingualUrls;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,uBACX,KACA,UAAuCA,iCAAe,sBAClD,SACJ,gBAA2CA,iCAAe,sBACtD,eACJ,OAKgBA,iCAAe,SAAS,SACR;CAEhC,MAAM,mBAAmBC,+DAAqB,KAAK,QAAQ;CAG3D,MAAM,gBAAgBC,oDAAmB,iBAAiB;CAI1D,MAAM,YAAY,gBACd,IAAI,IAAI,iBAAiB,GACzB,IAAI,IAAI,kBAAkB,qBAAqB;CAGnD,IAAI,WAAW,UAAU;AAGzB,KAAI,CAAC,SAAS,WAAW,IAAI,CAC3B,YAAW,IAAI;CAIjB,MAAM,UAAU,gBACZ,GAAG,UAAU,SAAS,IAAI,UAAU,SACpC;CAGJ,MAAM,cAAc,QAAQC,uCAAc,QAAQ;AAuDlD,SApD0B,WAAW,EAAE,EAAE,QACtC,KAAK,WAAW;EAEf,MAAM,kBAAkB,QAAQ,UAAU,KAAK,eAAe,UAAU;EAExE,IAAIC;AAEJ,MAAI,gBAAgB,iBAAiB;GAEnC,MAAM,eAAe,IAAI,gBAAgB,UAAU,OAAO;AAC1D,gBAAa,IAAI,UAAU,OAAO,UAAU,CAAC;GAE7C,MAAM,cAAc,aAAa,UAAU;GAC3C,MAAM,gBAAgB,cAClB,GAAG,SAAS,GAAG,gBACf;AAEJ,kBAAe,gBACX,GAAG,UAAU,gBAAgB,UAAU,SACvC,GAAG,gBAAgB,UAAU;aACxB,gBAAgB,YAEzB,gBAAe,gBACX,GAAG,UAAU,WAAW,UAAU,SAAS,UAAU,SACrD,GAAG,WAAW,UAAU,SAAS,UAAU;OAC1C;GAOL,IAAI,gBAJF,gBAAgB,gBACf,gBAAgB,uBAAuB,CAAC,kBAGR,IAAI,SAAS,aAAa;AAE7D,OAAI,cAAc,SAAS,KAAK,cAAc,SAAS,IAAI,CACzD,iBAAgB,cAAc,MAAM,GAAG,GAAG;AAI5C,kBAAe,gBACX,GAAG,UAAU,gBAAgB,UAAU,SAAS,UAAU,SAC1D,GAAG,gBAAgB,UAAU,SAAS,UAAU;;AAItD,MAAI,UAAyC;AAE7C,SAAO;IAET,EAAE,CACH"}

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

@@ -1,12 +1,12 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
 let __intlayer_types = require("@intlayer/types");
 __intlayer_types = require_rolldown_runtime.__toESM(__intlayer_types);
-let __intlayer_config = require("@intlayer/config");
-__intlayer_config = require_rolldown_runtime.__toESM(__intlayer_config);
 let node_fs = require("node:fs");
 node_fs = require_rolldown_runtime.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path);
+let __intlayer_config = require("@intlayer/config");
+__intlayer_config = require_rolldown_runtime.__toESM(__intlayer_config);
 
 //#region src/transpiler/file/file.ts
 const fileContent = (path, callerDir, baseDir) => {

package/dist/cjs/transpiler/markdown/getMarkdownMetadata.cjs

@@ -6,46 +6,13 @@ const getMarkdownMetadata = (markdown) => {
 		const lines = markdown.split(/\r?\n/);
 		const firstNonEmptyLine = lines.find((line) => line.trim() !== "");
 		if (!firstNonEmptyLine || firstNonEmptyLine.trim() !== "---") return {};
-		const metadata = {};
-		let inMetadataBlock = false;
-		let currentKey = null;
-		let currentArrayItems = [];
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i];
-			if (line.trim() === "---") if (!inMetadataBlock) {
-				inMetadataBlock = true;
-				continue;
-			} else {
-				if (currentKey && currentArrayItems.length > 0) metadata[currentKey] = currentArrayItems;
-				break;
-			}
-			if (inMetadataBlock) {
-				const arrayItemMatch = line.match(/^\s*-\s+(.+)$/);
-				if (arrayItemMatch && currentKey) {
-					currentArrayItems.push(arrayItemMatch[1].trim());
-					continue;
-				}
-				if (currentKey && currentArrayItems.length > 0) {
-					metadata[currentKey] = currentArrayItems;
-					currentKey = null;
-					currentArrayItems = [];
-				}
-				const match = line.match(/^([^:]+)\s*:\s*(.*)$/);
-				if (match) {
-					const key = match[1].trim();
-					const value = match[2].trim();
-					if (value === "") {
-						currentKey = key;
-						currentArrayItems = [];
-					} else try {
-						metadata[key] = require_utils_parseYaml.parseYaml(value);
-					} catch (_e) {
-						metadata[key] = value;
-					}
-				}
-			}
+		let metadataEndIndex = -1;
+		for (let i = 1; i < lines.length; i++) if (lines[i].trim() === "---") {
+			metadataEndIndex = i;
+			break;
 		}
-		return metadata;
+		if (metadataEndIndex === -1) return {};
+		return require_utils_parseYaml.parseYaml(lines.slice(1, metadataEndIndex).join("\n")) ?? {};
 	} catch (_e) {
 		return {};
 	}

package/dist/cjs/transpiler/markdown/getMarkdownMetadata.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getMarkdownMetadata.cjs","names":["metadata: T","currentKey: string | null","currentArrayItems: string[]","parseYaml"],"sources":["../../../../src/transpiler/markdown/getMarkdownMetadata.ts"],"sourcesContent":["import { parseYaml } from '../../utils/parseYaml';\n\nexport const getMarkdownMetadata = <T extends Record<string, any>>(\n  markdown: string\n): T => {\n  try {\n    const lines = markdown.split(/\\r?\\n/);\n\n    // Check if the very first non-empty line is the metadata start delimiter.\n    const firstNonEmptyLine = lines.find((line) => line.trim() !== '');\n\n    if (!firstNonEmptyLine || firstNonEmptyLine.trim() !== '---') {\n      const result: T = {} as T;\n      return result;\n    }\n\n    const metadata: T = {} as T;\n    let inMetadataBlock = false;\n    let currentKey: string | null = null;\n    let currentArrayItems: string[] = [];\n\n    for (let i = 0; i < lines.length; i++) {\n      const line = lines[i];\n      const trimmedLine = line.trim();\n\n      // Toggle metadata block on encountering the delimiter.\n      if (trimmedLine === '---') {\n        if (!inMetadataBlock) {\n          // Begin metadata block.\n          inMetadataBlock = true;\n          continue;\n        } else {\n          // End of metadata block; finalize any pending array and stop processing.\n          if (currentKey && currentArrayItems.length > 0) {\n            (metadata as Record<string, any>)[currentKey] = currentArrayItems;\n          }\n          break;\n        }\n      }\n\n      // If we're inside the metadata block, parse key: value pairs.\n      if (inMetadataBlock) {\n        // Check if this line is an array item (starts with - )\n        const arrayItemMatch = line.match(/^\\s*-\\s+(.+)$/);\n        if (arrayItemMatch && currentKey) {\n          // This is an array item for the current key\n          currentArrayItems.push(arrayItemMatch[1].trim());\n          continue;\n        }\n\n        // If we have a pending array from a previous key, save it\n        if (currentKey && currentArrayItems.length > 0) {\n          (metadata as Record<string, any>)[currentKey] = currentArrayItems;\n          currentKey = null;\n          currentArrayItems = [];\n        }\n\n        // Check for key: value pairs\n        const match = line.match(/^([^:]+)\\s*:\\s*(.*)$/);\n        if (match) {\n          const key = match[1].trim();\n          const value = match[2].trim();\n\n          if (value === '') {\n            // This might be the start of a multi-line structure (like an array)\n            currentKey = key;\n            currentArrayItems = [];\n          } else {\n            try {\n              (metadata as Record<string, any>)[key] = parseYaml(value);\n            } catch (_e) {\n              (metadata as Record<string, any>)[key] = value;\n            }\n          }\n        }\n      }\n    }\n\n    return metadata;\n  } catch (_e) {\n    const result: T = {} as T;\n    return result;\n  }\n};\n"],"mappings":";;;AAEA,MAAa,uBACX,aACM;AACN,KAAI;EACF,MAAM,QAAQ,SAAS,MAAM,QAAQ;EAGrC,MAAM,oBAAoB,MAAM,MAAM,SAAS,KAAK,MAAM,KAAK,GAAG;AAElE,MAAI,CAAC,qBAAqB,kBAAkB,MAAM,KAAK,MAErD,QADkB,EAAE;EAItB,MAAMA,WAAc,EAAE;EACtB,IAAI,kBAAkB;EACtB,IAAIC,aAA4B;EAChC,IAAIC,oBAA8B,EAAE;AAEpC,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;AAInB,OAHoB,KAAK,MAAM,KAGX,MAClB,KAAI,CAAC,iBAAiB;AAEpB,sBAAkB;AAClB;UACK;AAEL,QAAI,cAAc,kBAAkB,SAAS,EAC3C,CAAC,SAAiC,cAAc;AAElD;;AAKJ,OAAI,iBAAiB;IAEnB,MAAM,iBAAiB,KAAK,MAAM,gBAAgB;AAClD,QAAI,kBAAkB,YAAY;AAEhC,uBAAkB,KAAK,eAAe,GAAG,MAAM,CAAC;AAChD;;AAIF,QAAI,cAAc,kBAAkB,SAAS,GAAG;AAC9C,KAAC,SAAiC,cAAc;AAChD,kBAAa;AACb,yBAAoB,EAAE;;IAIxB,MAAM,QAAQ,KAAK,MAAM,uBAAuB;AAChD,QAAI,OAAO;KACT,MAAM,MAAM,MAAM,GAAG,MAAM;KAC3B,MAAM,QAAQ,MAAM,GAAG,MAAM;AAE7B,SAAI,UAAU,IAAI;AAEhB,mBAAa;AACb,0BAAoB,EAAE;WAEtB,KAAI;AACF,MAAC,SAAiC,OAAOC,kCAAU,MAAM;cAClD,IAAI;AACX,MAAC,SAAiC,OAAO;;;;;AAOnD,SAAO;UACA,IAAI;AAEX,SADkB,EAAE"}
+{"version":3,"file":"getMarkdownMetadata.cjs","names":["parseYaml"],"sources":["../../../../src/transpiler/markdown/getMarkdownMetadata.ts"],"sourcesContent":["import { parseYaml } from '../../utils/parseYaml';\n\nexport const getMarkdownMetadata = <T extends Record<string, any>>(\n  markdown: string\n): T => {\n  try {\n    const lines = markdown.split(/\\r?\\n/);\n\n    // Check if the very first non-empty line is the metadata start delimiter.\n    const firstNonEmptyLine = lines.find((line) => line.trim() !== '');\n\n    if (!firstNonEmptyLine || firstNonEmptyLine.trim() !== '---') {\n      const result: T = {} as T;\n      return result;\n    }\n\n    // Find the end of the metadata block\n    let metadataEndIndex = -1;\n    for (let i = 1; i < lines.length; i++) {\n      if (lines[i].trim() === '---') {\n        metadataEndIndex = i;\n        break;\n      }\n    }\n\n    if (metadataEndIndex === -1) {\n      // No closing delimiter found\n      const result: T = {} as T;\n      return result;\n    }\n\n    // Extract the metadata content between the delimiters\n    const metadataLines = lines.slice(1, metadataEndIndex);\n    const metadataContent = metadataLines.join('\\n');\n\n    // Use the improved parseYaml function to parse the entire metadata block\n    const metadata = parseYaml<T>(metadataContent);\n\n    return metadata ?? ({} as T);\n  } catch (_e) {\n    const result: T = {} as T;\n    return result;\n  }\n};\n"],"mappings":";;;AAEA,MAAa,uBACX,aACM;AACN,KAAI;EACF,MAAM,QAAQ,SAAS,MAAM,QAAQ;EAGrC,MAAM,oBAAoB,MAAM,MAAM,SAAS,KAAK,MAAM,KAAK,GAAG;AAElE,MAAI,CAAC,qBAAqB,kBAAkB,MAAM,KAAK,MAErD,QADkB,EAAE;EAKtB,IAAI,mBAAmB;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,IAChC,KAAI,MAAM,GAAG,MAAM,KAAK,OAAO;AAC7B,sBAAmB;AACnB;;AAIJ,MAAI,qBAAqB,GAGvB,QADkB,EAAE;AAWtB,SAFiBA,kCAJK,MAAM,MAAM,GAAG,iBAAiB,CAChB,KAAK,KAAK,CAGF,IAE1B,EAAE;UACf,IAAI;AAEX,SADkB,EAAE"}

package/dist/cjs/utils/parseYaml.cjs

@@ -74,11 +74,94 @@ const parseYaml = (input) => {
 		}
 		return arr;
 	};
+	const parseYamlListItem = () => {
+		next();
+		skipWhitespace();
+		if (peek() === "{") return parseObject();
+		const ch = peek();
+		if (ch === "\"" || ch === "'") return parseQuotedString(ch);
+		let hasColon = false;
+		let tempIdx = index;
+		while (tempIdx < text.length && text[tempIdx] !== "\n") {
+			if (text[tempIdx] === ":" && tempIdx + 1 < text.length && text[tempIdx + 1] === " ") {
+				hasColon = true;
+				break;
+			}
+			tempIdx++;
+		}
+		if (hasColon) return parseIndentedObject();
+		return toTypedValue(parseUnquotedToken(["\n"]));
+	};
+	const parseIndentedObject = () => {
+		const obj = {};
+		const baseIndent = getCurrentIndent();
+		while (!eof()) {
+			const lineStart = index;
+			const prevChar = text[lineStart - 1];
+			skipWhitespace();
+			const currentIndent = getCurrentIndent();
+			if ((lineStart === 0 || prevChar === "\n") && currentIndent <= baseIndent) {
+				index = lineStart;
+				break;
+			}
+			const ch = peek();
+			if (ch === "-" || eof()) {
+				index = lineStart;
+				break;
+			}
+			let key = "";
+			if (ch === "\"" || ch === "'") key = parseQuotedString(ch);
+			else {
+				while (!eof() && peek() !== ":") key += next();
+				key = key.trim();
+			}
+			if (eof() || next() !== ":") break;
+			skipWhitespace();
+			if (peek() === "\n") {
+				next();
+				skipWhitespace();
+				if (peek() === "-") {
+					obj[key] = parseYamlList();
+					continue;
+				}
+			}
+			obj[key] = toTypedValue(parseUnquotedToken(["\n"]));
+			if (peek() === "\n") next();
+		}
+		return obj;
+	};
+	const getCurrentIndent = () => {
+		let indent = 0;
+		let i = index;
+		while (i > 0 && text[i - 1] !== "\n") i--;
+		while (i < text.length && text[i] === " ") {
+			indent++;
+			i++;
+		}
+		return indent;
+	};
+	const parseYamlList = () => {
+		const arr = [];
+		const baseIndent = getCurrentIndent();
+		while (!eof()) {
+			while (!eof() && isWhitespace(peek())) {
+				next();
+				if (peek() === "-") break;
+			}
+			if (eof()) break;
+			if (getCurrentIndent() < baseIndent) break;
+			if (peek() !== "-") break;
+			arr.push(parseYamlListItem());
+		}
+		return arr;
+	};
 	const parseObjectBody = (stops) => {
 		const obj = {};
 		skipWhitespace();
 		while (true) {
 			skipWhitespace();
+			if (eof()) return obj;
+			if (isStopChar(peek(), stops)) return obj;
 			let key = "";
 			const ch = peek();
 			if (ch === "\"" || ch === "'") key = parseQuotedString(ch);
@@ -86,22 +169,72 @@ const parseYaml = (input) => {
 				while (!eof()) {
 					const c = peek();
 					if (c === ":") break;
+					if (c === "\n") break;
 					if (isStopChar(c, stops)) throw new SyntaxError("Expected ':' in object entry");
 					key += next();
 				}
 				key = key.trim();
 			}
+			if (!key) return obj;
 			if (eof() || next() !== ":") throw new SyntaxError("Expected ':' after key");
-			skipWhitespace();
-			obj[key] = parseValue([",", ...stops]);
-			skipWhitespace();
-			const sep = peek();
+			if (!eof() && peek() === " ") next();
+			while (!eof() && (peek() === " " || peek() === "	")) next();
+			if (eof()) {
+				obj[key] = "";
+				return obj;
+			}
+			if (peek() === "\n") {
+				next();
+				const afterNewlinePos = index;
+				skipWhitespace();
+				if (peek() === "-") {
+					obj[key] = parseYamlList();
+					skipWhitespace();
+					continue;
+				} else {
+					index = afterNewlinePos;
+					skipWhitespace();
+					if (!eof()) {
+						const nextChar = peek();
+						if (nextChar && !isStopChar(nextChar, stops) && nextChar !== "-") {
+							obj[key] = "";
+							continue;
+						}
+					}
+					obj[key] = "";
+					return obj;
+				}
+			}
+			obj[key] = parseValue(stops.includes("}") ? [
+				",",
+				"\n",
+				...stops
+			] : ["\n", ...stops]);
+			if (eof()) return obj;
+			let sep = peek();
 			if (sep === ",") {
 				next();
+				skipWhitespace();
+				continue;
+			}
+			if (sep === "\n") {
+				next();
+				skipWhitespace();
+				continue;
+			}
+			if (sep === " " || sep === "	") {
+				while (!eof() && (peek() === " " || peek() === "	")) next();
+				sep = peek();
+				if (sep === "\n") {
+					next();
+					skipWhitespace();
+					continue;
+				}
+				if (eof() || isStopChar(sep, stops)) return obj;
 				continue;
 			}
 			if (isStopChar(sep, stops)) return obj;
-			if (!eof()) throw new SyntaxError("Expected ',' or end of object");
+			if (!eof()) continue;
 			return obj;
 		}
 	};
@@ -152,7 +285,8 @@ const parseYaml = (input) => {
 				continue;
 			}
 			if (depth === 0 && char === ":") {
-				if (s[i + 1] === " ") return true;
+				const nextCh = s[i + 1];
+				if (nextCh === " " || nextCh === "\n" || nextCh === void 0) return true;
 			}
 			i++;
 		}