@intlayer/cli 6.1.6 → 7.0.0-canary.0

package/dist/cjs/utils/mapChunksBetweenFiles.cjs

@@ -1,145 +1,103 @@
-"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 mapChunksBetweenFiles_exports = {};
-__export(mapChunksBetweenFiles_exports, {
-  mapChunksBetweenFiles: () => mapChunksBetweenFiles
-});
-module.exports = __toCommonJS(mapChunksBetweenFiles_exports);
-var import_calculateChunks = require('./calculateChunks.cjs');
-var import_splitTextByLine = require('./splitTextByLine.cjs');
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_calculateChunks = require('./calculateChunks.cjs');
+let __intlayer_chokidar = require("@intlayer/chokidar");
+__intlayer_chokidar = require_rolldown_runtime.__toESM(__intlayer_chokidar);
+
+//#region src/utils/mapChunksBetweenFiles.ts
+/**
+* Maps chunks from base file to corresponding chunks in updated file,
+* handling insertions, deletions, and modifications properly.
+*/
 const mapChunksBetweenFiles = (baseFileContent, updatedFileContent, maxCharsPerChunk = 800, changedLines) => {
-  const baseChunks = (0, import_calculateChunks.chunkText)(baseFileContent, maxCharsPerChunk, 0);
-  const baseLines = (0, import_splitTextByLine.splitTextByLines)(baseFileContent);
-  const updatedLines = (0, import_splitTextByLine.splitTextByLines)(updatedFileContent);
-  const lineMapping = createLineMapping(baseLines, updatedLines);
-  return baseChunks.map((baseChunk) => {
-    const mappedRange = mapLineRange(
-      baseChunk.lineStart,
-      baseChunk.lineLength,
-      lineMapping
-    );
-    if (!mappedRange) {
-      return {
-        baseChunk,
-        updatedChunk: null,
-        hasChanges: true
-      };
-    }
-    const updatedChunk = {
-      lineStart: mappedRange.start,
-      lineLength: mappedRange.length,
-      charStart: 0,
-      // Will be calculated when needed
-      charLength: 0,
-      // Will be calculated when needed
-      content: extractLinesFromRange(
-        updatedLines,
-        mappedRange.start,
-        mappedRange.length
-      )
-    };
-    updatedChunk.charStart = getCharStartForLine(
-      updatedFileContent,
-      updatedChunk.lineStart
-    );
-    updatedChunk.charLength = updatedChunk.content.length;
-    const hasChanges = determineIfChunkHasChanges(
-      baseChunk,
-      updatedChunk,
-      changedLines
-    );
-    return {
-      baseChunk,
-      updatedChunk,
-      hasChanges
-    };
-  });
+	const baseChunks = require_utils_calculateChunks.chunkText(baseFileContent, maxCharsPerChunk, 0);
+	const baseLines = (0, __intlayer_chokidar.splitTextByLines)(baseFileContent);
+	const updatedLines = (0, __intlayer_chokidar.splitTextByLines)(updatedFileContent);
+	const lineMapping = createLineMapping(baseLines, updatedLines);
+	return baseChunks.map((baseChunk) => {
+		const mappedRange = mapLineRange(baseChunk.lineStart, baseChunk.lineLength, lineMapping);
+		if (!mappedRange) return {
+			baseChunk,
+			updatedChunk: null,
+			hasChanges: true
+		};
+		const updatedChunk = {
+			lineStart: mappedRange.start,
+			lineLength: mappedRange.length,
+			charStart: 0,
+			charLength: 0,
+			content: extractLinesFromRange(updatedLines, mappedRange.start, mappedRange.length)
+		};
+		updatedChunk.charStart = getCharStartForLine(updatedFileContent, updatedChunk.lineStart);
+		updatedChunk.charLength = updatedChunk.content.length;
+		return {
+			baseChunk,
+			updatedChunk,
+			hasChanges: determineIfChunkHasChanges(baseChunk, updatedChunk, changedLines)
+		};
+	});
 };
+/**
+* Creates a mapping between line numbers in base file and updated file
+* Returns a map where key = base line number, value = updated line number (or null if deleted)
+*/
 const createLineMapping = (baseLines, updatedLines) => {
-  const mapping = /* @__PURE__ */ new Map();
-  const dp = Array(baseLines.length + 1).fill(null).map(() => Array(updatedLines.length + 1).fill(0));
-  for (let i2 = 1; i2 <= baseLines.length; i2++) {
-    for (let j2 = 1; j2 <= updatedLines.length; j2++) {
-      if (baseLines[i2 - 1] === updatedLines[j2 - 1]) {
-        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
-      } else {
-        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
-      }
-    }
-  }
-  let i = baseLines.length;
-  let j = updatedLines.length;
-  while (i > 0 || j > 0) {
-    if (i > 0 && j > 0 && baseLines[i - 1] === updatedLines[j - 1]) {
-      mapping.set(i - 1, j - 1);
-      i--;
-      j--;
-    } else if (i > 0 && (j === 0 || dp[i - 1][j] >= dp[i][j - 1])) {
-      mapping.set(i - 1, null);
-      i--;
-    } else {
-      j--;
-    }
-  }
-  return mapping;
+	const mapping = /* @__PURE__ */ new Map();
+	const dp = Array(baseLines.length + 1).fill(null).map(() => Array(updatedLines.length + 1).fill(0));
+	for (let i$1 = 1; i$1 <= baseLines.length; i$1++) for (let j$1 = 1; j$1 <= updatedLines.length; j$1++) if (baseLines[i$1 - 1] === updatedLines[j$1 - 1]) dp[i$1][j$1] = dp[i$1 - 1][j$1 - 1] + 1;
+	else dp[i$1][j$1] = Math.max(dp[i$1 - 1][j$1], dp[i$1][j$1 - 1]);
+	let i = baseLines.length;
+	let j = updatedLines.length;
+	while (i > 0 || j > 0) if (i > 0 && j > 0 && baseLines[i - 1] === updatedLines[j - 1]) {
+		mapping.set(i - 1, j - 1);
+		i--;
+		j--;
+	} else if (i > 0 && (j === 0 || dp[i - 1][j] >= dp[i][j - 1])) {
+		mapping.set(i - 1, null);
+		i--;
+	} else j--;
+	return mapping;
 };
+/**
+* Maps a line range from base file to updated file using the line mapping
+*/
 const mapLineRange = (baseStart, baseLength, lineMapping) => {
-  const mappedLines = [];
-  for (let i = baseStart; i < baseStart + baseLength; i++) {
-    const mappedLine = lineMapping.get(i);
-    if (mappedLine !== null && mappedLine !== void 0) {
-      mappedLines.push(mappedLine);
-    }
-  }
-  if (mappedLines.length === 0) {
-    return null;
-  }
-  mappedLines.sort((a, b) => a - b);
-  const start = mappedLines[0];
-  const end = mappedLines[mappedLines.length - 1];
-  return {
-    start,
-    length: end - start + 1
-  };
+	const mappedLines = [];
+	for (let i = baseStart; i < baseStart + baseLength; i++) {
+		const mappedLine = lineMapping.get(i);
+		if (mappedLine !== null && mappedLine !== void 0) mappedLines.push(mappedLine);
+	}
+	if (mappedLines.length === 0) return null;
+	mappedLines.sort((a, b) => a - b);
+	const start = mappedLines[0];
+	return {
+		start,
+		length: mappedLines[mappedLines.length - 1] - start + 1
+	};
 };
+/**
+* Extracts lines from a range in the lines array
+*/
 const extractLinesFromRange = (lines, start, length) => {
-  const endIndex = Math.min(start + length, lines.length);
-  return lines.slice(start, endIndex).join("");
+	const endIndex = Math.min(start + length, lines.length);
+	return lines.slice(start, endIndex).join("");
 };
+/**
+* Gets the character position where a line starts in the text
+*/
 const getCharStartForLine = (text, lineNumber) => {
-  const lines = (0, import_splitTextByLine.splitTextByLines)(text);
-  let charStart = 0;
-  for (let i = 0; i < Math.min(lineNumber, lines.length); i++) {
-    charStart += lines[i].length;
-  }
-  return charStart;
+	const lines = (0, __intlayer_chokidar.splitTextByLines)(text);
+	let charStart = 0;
+	for (let i = 0; i < Math.min(lineNumber, lines.length); i++) charStart += lines[i].length;
+	return charStart;
 };
+/**
+* Determines if a chunk has changes based on git changed lines or content comparison
+*/
 const determineIfChunkHasChanges = (baseChunk, updatedChunk, changedLines) => {
-  if (changedLines && changedLines.length > 0) {
-    return changedLines.some(
-      (line) => line >= updatedChunk.lineStart && line < updatedChunk.lineStart + updatedChunk.lineLength
-    );
-  }
-  return baseChunk.content !== updatedChunk.content;
+	if (changedLines && changedLines.length > 0) return changedLines.some((line) => line >= updatedChunk.lineStart && line < updatedChunk.lineStart + updatedChunk.lineLength);
+	return baseChunk.content !== updatedChunk.content;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  mapChunksBetweenFiles
-});
+
+//#endregion
+exports.mapChunksBetweenFiles = mapChunksBetweenFiles;
 //# sourceMappingURL=mapChunksBetweenFiles.cjs.map

package/dist/cjs/utils/mapChunksBetweenFiles.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/mapChunksBetweenFiles.ts"],"sourcesContent":["import { ChunkLineResult, chunkText } from './calculateChunks';\nimport { splitTextByLines } from './splitTextByLine';\n\nexport interface ChunkMapping {\n  baseChunk: ChunkLineResult;\n  updatedChunk: ChunkLineResult | null; // null if the chunk was deleted\n  hasChanges: boolean;\n}\n\n/**\n * Maps chunks from base file to corresponding chunks in updated file,\n * handling insertions, deletions, and modifications properly.\n */\nexport const mapChunksBetweenFiles = (\n  baseFileContent: string,\n  updatedFileContent: string,\n  maxCharsPerChunk: number = 800,\n  changedLines?: number[]\n): ChunkMapping[] => {\n  const baseChunks = chunkText(baseFileContent, maxCharsPerChunk, 0);\n  const baseLines = splitTextByLines(baseFileContent);\n  const updatedLines = splitTextByLines(updatedFileContent);\n\n  // Create a simple line mapping using LCS (Longest Common Subsequence) approach\n  const lineMapping = createLineMapping(baseLines, updatedLines);\n\n  return baseChunks.map((baseChunk): ChunkMapping => {\n    // Map the base chunk's line range to the updated file\n    const mappedRange = mapLineRange(\n      baseChunk.lineStart,\n      baseChunk.lineLength,\n      lineMapping\n    );\n\n    if (!mappedRange) {\n      // This chunk was completely deleted\n      return {\n        baseChunk,\n        updatedChunk: null,\n        hasChanges: true,\n      };\n    }\n\n    // Create the corresponding chunk in the updated file\n    const updatedChunk: ChunkLineResult = {\n      lineStart: mappedRange.start,\n      lineLength: mappedRange.length,\n      charStart: 0, // Will be calculated when needed\n      charLength: 0, // Will be calculated when needed\n      content: extractLinesFromRange(\n        updatedLines,\n        mappedRange.start,\n        mappedRange.length\n      ),\n    };\n\n    // Calculate character positions\n    updatedChunk.charStart = getCharStartForLine(\n      updatedFileContent,\n      updatedChunk.lineStart\n    );\n    updatedChunk.charLength = updatedChunk.content.length;\n\n    // Determine if this chunk has changes\n    const hasChanges = determineIfChunkHasChanges(\n      baseChunk,\n      updatedChunk,\n      changedLines\n    );\n\n    return {\n      baseChunk,\n      updatedChunk,\n      hasChanges,\n    };\n  });\n};\n\n/**\n * Creates a mapping between line numbers in base file and updated file\n * Returns a map where key = base line number, value = updated line number (or null if deleted)\n */\nconst createLineMapping = (\n  baseLines: string[],\n  updatedLines: string[]\n): Map<number, number | null> => {\n  const mapping = new Map<number, number | null>();\n\n  // Use a simple diff algorithm (similar to Myers algorithm but simplified)\n  const dp: number[][] = Array(baseLines.length + 1)\n    .fill(null)\n    .map(() => Array(updatedLines.length + 1).fill(0));\n\n  // Fill the DP table\n  for (let i = 1; i <= baseLines.length; i++) {\n    for (let j = 1; j <= updatedLines.length; j++) {\n      if (baseLines[i - 1] === updatedLines[j - 1]) {\n        dp[i][j] = dp[i - 1][j - 1] + 1;\n      } else {\n        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);\n      }\n    }\n  }\n\n  // Backtrack to create the mapping\n  let i = baseLines.length;\n  let j = updatedLines.length;\n\n  while (i > 0 || j > 0) {\n    if (i > 0 && j > 0 && baseLines[i - 1] === updatedLines[j - 1]) {\n      // Lines match\n      mapping.set(i - 1, j - 1);\n      i--;\n      j--;\n    } else if (i > 0 && (j === 0 || dp[i - 1][j] >= dp[i][j - 1])) {\n      // Line was deleted from base\n      mapping.set(i - 1, null);\n      i--;\n    } else {\n      // Line was added to updated (no mapping needed for base)\n      j--;\n    }\n  }\n\n  return mapping;\n};\n\n/**\n * Maps a line range from base file to updated file using the line mapping\n */\nconst mapLineRange = (\n  baseStart: number,\n  baseLength: number,\n  lineMapping: Map<number, number | null>\n): { start: number; length: number } | null => {\n  const mappedLines: number[] = [];\n\n  for (let i = baseStart; i < baseStart + baseLength; i++) {\n    const mappedLine = lineMapping.get(i);\n    if (mappedLine !== null && mappedLine !== undefined) {\n      mappedLines.push(mappedLine);\n    }\n  }\n\n  if (mappedLines.length === 0) {\n    return null; // All lines were deleted\n  }\n\n  // Find the continuous range in the mapped lines\n  mappedLines.sort((a, b) => a - b);\n  const start = mappedLines[0];\n  const end = mappedLines[mappedLines.length - 1];\n\n  return {\n    start,\n    length: end - start + 1,\n  };\n};\n\n/**\n * Extracts lines from a range in the lines array\n */\nconst extractLinesFromRange = (\n  lines: string[],\n  start: number,\n  length: number\n): string => {\n  const endIndex = Math.min(start + length, lines.length);\n  return lines.slice(start, endIndex).join('');\n};\n\n/**\n * Gets the character position where a line starts in the text\n */\nconst getCharStartForLine = (text: string, lineNumber: number): number => {\n  const lines = splitTextByLines(text);\n  let charStart = 0;\n\n  for (let i = 0; i < Math.min(lineNumber, lines.length); i++) {\n    charStart += lines[i].length;\n  }\n\n  return charStart;\n};\n\n/**\n * Determines if a chunk has changes based on git changed lines or content comparison\n */\nconst determineIfChunkHasChanges = (\n  baseChunk: ChunkLineResult,\n  updatedChunk: ChunkLineResult,\n  changedLines?: number[]\n): boolean => {\n  // If we have git changed lines, use them for precise detection\n  if (changedLines && changedLines.length > 0) {\n    return changedLines.some(\n      (line) =>\n        line >= updatedChunk.lineStart &&\n        line < updatedChunk.lineStart + updatedChunk.lineLength\n    );\n  }\n\n  // Fallback to content comparison\n  return baseChunk.content !== updatedChunk.content;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAA2C;AAC3C,6BAAiC;AAY1B,MAAM,wBAAwB,CACnC,iBACA,oBACA,mBAA2B,KAC3B,iBACmB;AACnB,QAAM,iBAAa,kCAAU,iBAAiB,kBAAkB,CAAC;AACjE,QAAM,gBAAY,yCAAiB,eAAe;AAClD,QAAM,mBAAe,yCAAiB,kBAAkB;AAGxD,QAAM,cAAc,kBAAkB,WAAW,YAAY;AAE7D,SAAO,WAAW,IAAI,CAAC,cAA4B;AAEjD,UAAM,cAAc;AAAA,MAClB,UAAU;AAAA,MACV,UAAU;AAAA,MACV;AAAA,IACF;AAEA,QAAI,CAAC,aAAa;AAEhB,aAAO;AAAA,QACL;AAAA,QACA,cAAc;AAAA,QACd,YAAY;AAAA,MACd;AAAA,IACF;AAGA,UAAM,eAAgC;AAAA,MACpC,WAAW,YAAY;AAAA,MACvB,YAAY,YAAY;AAAA,MACxB,WAAW;AAAA;AAAA,MACX,YAAY;AAAA;AAAA,MACZ,SAAS;AAAA,QACP;AAAA,QACA,YAAY;AAAA,QACZ,YAAY;AAAA,MACd;AAAA,IACF;AAGA,iBAAa,YAAY;AAAA,MACvB;AAAA,MACA,aAAa;AAAA,IACf;AACA,iBAAa,aAAa,aAAa,QAAQ;AAG/C,UAAM,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAMA,MAAM,oBAAoB,CACxB,WACA,iBAC+B;AAC/B,QAAM,UAAU,oBAAI,IAA2B;AAG/C,QAAM,KAAiB,MAAM,UAAU,SAAS,CAAC,EAC9C,KAAK,IAAI,EACT,IAAI,MAAM,MAAM,aAAa,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC;AAGnD,WAASA,KAAI,GAAGA,MAAK,UAAU,QAAQA,MAAK;AAC1C,aAASC,KAAI,GAAGA,MAAK,aAAa,QAAQA,MAAK;AAC7C,UAAI,UAAUD,KAAI,CAAC,MAAM,aAAaC,KAAI,CAAC,GAAG;AAC5C,WAAGD,EAAC,EAAEC,EAAC,IAAI,GAAGD,KAAI,CAAC,EAAEC,KAAI,CAAC,IAAI;AAAA,MAChC,OAAO;AACL,WAAGD,EAAC,EAAEC,EAAC,IAAI,KAAK,IAAI,GAAGD,KAAI,CAAC,EAAEC,EAAC,GAAG,GAAGD,EAAC,EAAEC,KAAI,CAAC,CAAC;AAAA,MAChD;AAAA,IACF;AAAA,EACF;AAGA,MAAI,IAAI,UAAU;AAClB,MAAI,IAAI,aAAa;AAErB,SAAO,IAAI,KAAK,IAAI,GAAG;AACrB,QAAI,IAAI,KAAK,IAAI,KAAK,UAAU,IAAI,CAAC,MAAM,aAAa,IAAI,CAAC,GAAG;AAE9D,cAAQ,IAAI,IAAI,GAAG,IAAI,CAAC;AACxB;AACA;AAAA,IACF,WAAW,IAAI,MAAM,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,EAAE,IAAI,CAAC,IAAI;AAE7D,cAAQ,IAAI,IAAI,GAAG,IAAI;AACvB;AAAA,IACF,OAAO;AAEL;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAKA,MAAM,eAAe,CACnB,WACA,YACA,gBAC6C;AAC7C,QAAM,cAAwB,CAAC;AAE/B,WAAS,IAAI,WAAW,IAAI,YAAY,YAAY,KAAK;AACvD,UAAM,aAAa,YAAY,IAAI,CAAC;AACpC,QAAI,eAAe,QAAQ,eAAe,QAAW;AACnD,kBAAY,KAAK,UAAU;AAAA,IAC7B;AAAA,EACF;AAEA,MAAI,YAAY,WAAW,GAAG;AAC5B,WAAO;AAAA,EACT;AAGA,cAAY,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AAChC,QAAM,QAAQ,YAAY,CAAC;AAC3B,QAAM,MAAM,YAAY,YAAY,SAAS,CAAC;AAE9C,SAAO;AAAA,IACL;AAAA,IACA,QAAQ,MAAM,QAAQ;AAAA,EACxB;AACF;AAKA,MAAM,wBAAwB,CAC5B,OACA,OACA,WACW;AACX,QAAM,WAAW,KAAK,IAAI,QAAQ,QAAQ,MAAM,MAAM;AACtD,SAAO,MAAM,MAAM,OAAO,QAAQ,EAAE,KAAK,EAAE;AAC7C;AAKA,MAAM,sBAAsB,CAAC,MAAc,eAA+B;AACxE,QAAM,YAAQ,yCAAiB,IAAI;AACnC,MAAI,YAAY;AAEhB,WAAS,IAAI,GAAG,IAAI,KAAK,IAAI,YAAY,MAAM,MAAM,GAAG,KAAK;AAC3D,iBAAa,MAAM,CAAC,EAAE;AAAA,EACxB;AAEA,SAAO;AACT;AAKA,MAAM,6BAA6B,CACjC,WACA,cACA,iBACY;AAEZ,MAAI,gBAAgB,aAAa,SAAS,GAAG;AAC3C,WAAO,aAAa;AAAA,MAClB,CAAC,SACC,QAAQ,aAAa,aACrB,OAAO,aAAa,YAAY,aAAa;AAAA,IACjD;AAAA,EACF;AAGA,SAAO,UAAU,YAAY,aAAa;AAC5C;","names":["i","j"]}
+{"version":3,"file":"mapChunksBetweenFiles.cjs","names":["chunkText","updatedChunk: ChunkLineResult","dp: number[][]","i","j","mappedLines: number[]"],"sources":["../../../src/utils/mapChunksBetweenFiles.ts"],"sourcesContent":["import { splitTextByLines } from '@intlayer/chokidar';\nimport { type ChunkLineResult, chunkText } from './calculateChunks';\n\nexport interface ChunkMapping {\n  baseChunk: ChunkLineResult;\n  updatedChunk: ChunkLineResult | null; // null if the chunk was deleted\n  hasChanges: boolean;\n}\n\n/**\n * Maps chunks from base file to corresponding chunks in updated file,\n * handling insertions, deletions, and modifications properly.\n */\nexport const mapChunksBetweenFiles = (\n  baseFileContent: string,\n  updatedFileContent: string,\n  maxCharsPerChunk: number = 800,\n  changedLines?: number[]\n): ChunkMapping[] => {\n  const baseChunks = chunkText(baseFileContent, maxCharsPerChunk, 0);\n  const baseLines = splitTextByLines(baseFileContent);\n  const updatedLines = splitTextByLines(updatedFileContent);\n\n  // Create a simple line mapping using LCS (Longest Common Subsequence) approach\n  const lineMapping = createLineMapping(baseLines, updatedLines);\n\n  return baseChunks.map((baseChunk): ChunkMapping => {\n    // Map the base chunk's line range to the updated file\n    const mappedRange = mapLineRange(\n      baseChunk.lineStart,\n      baseChunk.lineLength,\n      lineMapping\n    );\n\n    if (!mappedRange) {\n      // This chunk was completely deleted\n      return {\n        baseChunk,\n        updatedChunk: null,\n        hasChanges: true,\n      };\n    }\n\n    // Create the corresponding chunk in the updated file\n    const updatedChunk: ChunkLineResult = {\n      lineStart: mappedRange.start,\n      lineLength: mappedRange.length,\n      charStart: 0, // Will be calculated when needed\n      charLength: 0, // Will be calculated when needed\n      content: extractLinesFromRange(\n        updatedLines,\n        mappedRange.start,\n        mappedRange.length\n      ),\n    };\n\n    // Calculate character positions\n    updatedChunk.charStart = getCharStartForLine(\n      updatedFileContent,\n      updatedChunk.lineStart\n    );\n    updatedChunk.charLength = updatedChunk.content.length;\n\n    // Determine if this chunk has changes\n    const hasChanges = determineIfChunkHasChanges(\n      baseChunk,\n      updatedChunk,\n      changedLines\n    );\n\n    return {\n      baseChunk,\n      updatedChunk,\n      hasChanges,\n    };\n  });\n};\n\n/**\n * Creates a mapping between line numbers in base file and updated file\n * Returns a map where key = base line number, value = updated line number (or null if deleted)\n */\nconst createLineMapping = (\n  baseLines: string[],\n  updatedLines: string[]\n): Map<number, number | null> => {\n  const mapping = new Map<number, number | null>();\n\n  // Use a simple diff algorithm (similar to Myers algorithm but simplified)\n  const dp: number[][] = Array(baseLines.length + 1)\n    .fill(null)\n    .map(() => Array(updatedLines.length + 1).fill(0));\n\n  // Fill the DP table\n  for (let i = 1; i <= baseLines.length; i++) {\n    for (let j = 1; j <= updatedLines.length; j++) {\n      if (baseLines[i - 1] === updatedLines[j - 1]) {\n        dp[i][j] = dp[i - 1][j - 1] + 1;\n      } else {\n        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);\n      }\n    }\n  }\n\n  // Backtrack to create the mapping\n  let i = baseLines.length;\n  let j = updatedLines.length;\n\n  while (i > 0 || j > 0) {\n    if (i > 0 && j > 0 && baseLines[i - 1] === updatedLines[j - 1]) {\n      // Lines match\n      mapping.set(i - 1, j - 1);\n      i--;\n      j--;\n    } else if (i > 0 && (j === 0 || dp[i - 1][j] >= dp[i][j - 1])) {\n      // Line was deleted from base\n      mapping.set(i - 1, null);\n      i--;\n    } else {\n      // Line was added to updated (no mapping needed for base)\n      j--;\n    }\n  }\n\n  return mapping;\n};\n\n/**\n * Maps a line range from base file to updated file using the line mapping\n */\nconst mapLineRange = (\n  baseStart: number,\n  baseLength: number,\n  lineMapping: Map<number, number | null>\n): { start: number; length: number } | null => {\n  const mappedLines: number[] = [];\n\n  for (let i = baseStart; i < baseStart + baseLength; i++) {\n    const mappedLine = lineMapping.get(i);\n    if (mappedLine !== null && mappedLine !== undefined) {\n      mappedLines.push(mappedLine);\n    }\n  }\n\n  if (mappedLines.length === 0) {\n    return null; // All lines were deleted\n  }\n\n  // Find the continuous range in the mapped lines\n  mappedLines.sort((a, b) => a - b);\n  const start = mappedLines[0];\n  const end = mappedLines[mappedLines.length - 1];\n\n  return {\n    start,\n    length: end - start + 1,\n  };\n};\n\n/**\n * Extracts lines from a range in the lines array\n */\nconst extractLinesFromRange = (\n  lines: string[],\n  start: number,\n  length: number\n): string => {\n  const endIndex = Math.min(start + length, lines.length);\n  return lines.slice(start, endIndex).join('');\n};\n\n/**\n * Gets the character position where a line starts in the text\n */\nconst getCharStartForLine = (text: string, lineNumber: number): number => {\n  const lines = splitTextByLines(text);\n  let charStart = 0;\n\n  for (let i = 0; i < Math.min(lineNumber, lines.length); i++) {\n    charStart += lines[i].length;\n  }\n\n  return charStart;\n};\n\n/**\n * Determines if a chunk has changes based on git changed lines or content comparison\n */\nconst determineIfChunkHasChanges = (\n  baseChunk: ChunkLineResult,\n  updatedChunk: ChunkLineResult,\n  changedLines?: number[]\n): boolean => {\n  // If we have git changed lines, use them for precise detection\n  if (changedLines && changedLines.length > 0) {\n    return changedLines.some(\n      (line) =>\n        line >= updatedChunk.lineStart &&\n        line < updatedChunk.lineStart + updatedChunk.lineLength\n    );\n  }\n\n  // Fallback to content comparison\n  return baseChunk.content !== updatedChunk.content;\n};\n"],"mappings":"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"}

package/dist/cjs/utils/reorderParagraphs.cjs

@@ -1,125 +1,93 @@
-"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 reorderParagraphs_exports = {};
-__export(reorderParagraphs_exports, {
-  reorderParagraphs: () => reorderParagraphs
-});
-module.exports = __toCommonJS(reorderParagraphs_exports);
-var import_listSpecialChars = require('./listSpecialChars.cjs');
+const require_utils_listSpecialChars = require('./listSpecialChars.cjs');
+
+//#region src/utils/reorderParagraphs.ts
+/**
+* Split a text into paragraphs.
+*
+* We consider a paragraph boundary to be a block of at least two consecutive
+* new-lines that is immediately followed by a non-white-space character.  This
+* way, internal blank lines that are part of the same paragraph (e.g. a list
+* item that purposely contains a visual break) are preserved while true
+* paragraph breaks – the ones generated when calling `arr.join("\n\n")` in
+* the tests – are still detected.
+*/
 const splitByParagraph = (text) => {
-  const paragraphs = [];
-  const tokens = text.split(/(\n{2,})/);
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (i % 2 === 0) {
-      if (token) paragraphs.push(token);
-      continue;
-    }
-    const pairsOfNewlines = Math.floor(token.length / 2);
-    const blankParagraphs = Math.max(0, pairsOfNewlines - 2);
-    for (let j = 0; j < blankParagraphs; j++) {
-      paragraphs.push("\n\n");
-    }
-  }
-  return paragraphs;
+	const paragraphs = [];
+	const tokens = text.split(/(\n{2,})/);
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (i % 2 === 0) {
+			if (token) paragraphs.push(token);
+			continue;
+		}
+		const pairsOfNewlines = Math.floor(token.length / 2);
+		const blankParagraphs = Math.max(0, pairsOfNewlines - 2);
+		for (let j = 0; j < blankParagraphs; j++) paragraphs.push("\n\n");
+	}
+	return paragraphs;
 };
+/**
+* Determine whether two paragraphs match – either exactly, or by sharing the
+* same "special-character signature".
+*/
 const paragraphMatches = (paragraph, baseParagraph, paragraphSignature, baseSignature) => {
-  if (paragraph === baseParagraph) return true;
-  if (paragraphSignature.length !== baseSignature.length) return false;
-  for (let i = 0; i < paragraphSignature.length; i++) {
-    if (paragraphSignature[i].char !== baseSignature[i].char) {
-      return false;
-    }
-  }
-  return true;
+	if (paragraph === baseParagraph) return true;
+	if (paragraphSignature.length !== baseSignature.length) return false;
+	for (let i = 0; i < paragraphSignature.length; i++) if (paragraphSignature[i].char !== baseSignature[i].char) return false;
+	return true;
 };
+/**
+* Re-order `textToReorder` so that its paragraphs follow the ordering found in
+* `baseFileContent`, while preserving any extra paragraphs (those not present
+* in the base file) in a position that is intuitive for a human reader: right
+* after the closest preceding paragraph coming from the base file.
+*/
 const reorderParagraphs = (textToReorder, baseFileContent) => {
-  const baseFileParagraphs = splitByParagraph(baseFileContent);
-  const textToReorderParagraphs = splitByParagraph(textToReorder);
-  const baseSignatures = baseFileParagraphs.map((p) => (0, import_listSpecialChars.listSpecialChars)(p));
-  const textSignatures = textToReorderParagraphs.map(
-    (p) => (0, import_listSpecialChars.listSpecialChars)(p)
-  );
-  const firstMatchIndexForBase = Array(
-    baseFileParagraphs.length
-  ).fill(-1);
-  const paragraphMatchedBaseIdx = Array(
-    textToReorderParagraphs.length
-  ).fill(null);
-  for (let i = 0; i < textToReorderParagraphs.length; i++) {
-    const paragraph = textToReorderParagraphs[i];
-    const sig = textSignatures[i];
-    let foundIdx = baseFileParagraphs.findIndex(
-      (baseParagraph, idx) => firstMatchIndexForBase[idx] === -1 && paragraph === baseParagraph
-    );
-    if (foundIdx === -1) {
-      foundIdx = baseFileParagraphs.findIndex(
-        (baseParagraph, idx) => firstMatchIndexForBase[idx] === -1 && paragraphMatches(paragraph, baseParagraph, sig, baseSignatures[idx])
-      );
-    }
-    if (foundIdx !== -1) {
-      firstMatchIndexForBase[foundIdx] = i;
-      paragraphMatchedBaseIdx[i] = foundIdx;
-    }
-  }
-  const insertAfterBaseIdx = Array(
-    textToReorderParagraphs.length
-  ).fill(-1);
-  let maxBaseIdxEncountered = -1;
-  for (let i = 0; i < textToReorderParagraphs.length; i++) {
-    const matchedBase = paragraphMatchedBaseIdx[i];
-    if (matchedBase !== null) {
-      if (matchedBase > maxBaseIdxEncountered) {
-        maxBaseIdxEncountered = matchedBase;
-      }
-    } else {
-      insertAfterBaseIdx[i] = maxBaseIdxEncountered;
-    }
-  }
-  const result = [];
-  const extraParagraphsBuckets = {};
-  insertAfterBaseIdx.forEach((afterIdx, paragraphIdx) => {
-    if (afterIdx === -1) return;
-    extraParagraphsBuckets[afterIdx] = extraParagraphsBuckets[afterIdx] || [];
-    extraParagraphsBuckets[afterIdx].push(paragraphIdx);
-  });
-  for (let bIdx = 0; bIdx < baseFileParagraphs.length; bIdx++) {
-    const matchedParagraphIdx = firstMatchIndexForBase[bIdx];
-    if (matchedParagraphIdx !== -1) {
-      result.push(textToReorderParagraphs[matchedParagraphIdx]);
-    }
-    if (extraParagraphsBuckets[bIdx]) {
-      extraParagraphsBuckets[bIdx].forEach((pIdx) => {
-        result.push(textToReorderParagraphs[pIdx]);
-      });
-    }
-  }
-  const leadingExtras = [];
-  insertAfterBaseIdx.forEach((afterIdx, pIdx) => {
-    if (afterIdx === -1 && paragraphMatchedBaseIdx[pIdx] === null) {
-      leadingExtras.push(textToReorderParagraphs[pIdx]);
-    }
-  });
-  return [...leadingExtras, ...result].join("\n\n");
+	const baseFileParagraphs = splitByParagraph(baseFileContent);
+	const textToReorderParagraphs = splitByParagraph(textToReorder);
+	const baseSignatures = baseFileParagraphs.map((p) => require_utils_listSpecialChars.listSpecialChars(p));
+	const textSignatures = textToReorderParagraphs.map((p) => require_utils_listSpecialChars.listSpecialChars(p));
+	const firstMatchIndexForBase = Array(baseFileParagraphs.length).fill(-1);
+	const paragraphMatchedBaseIdx = Array(textToReorderParagraphs.length).fill(null);
+	for (let i = 0; i < textToReorderParagraphs.length; i++) {
+		const paragraph = textToReorderParagraphs[i];
+		const sig = textSignatures[i];
+		let foundIdx = baseFileParagraphs.findIndex((baseParagraph, idx) => firstMatchIndexForBase[idx] === -1 && paragraph === baseParagraph);
+		if (foundIdx === -1) foundIdx = baseFileParagraphs.findIndex((baseParagraph, idx) => firstMatchIndexForBase[idx] === -1 && paragraphMatches(paragraph, baseParagraph, sig, baseSignatures[idx]));
+		if (foundIdx !== -1) {
+			firstMatchIndexForBase[foundIdx] = i;
+			paragraphMatchedBaseIdx[i] = foundIdx;
+		}
+	}
+	const insertAfterBaseIdx = Array(textToReorderParagraphs.length).fill(-1);
+	let maxBaseIdxEncountered = -1;
+	for (let i = 0; i < textToReorderParagraphs.length; i++) {
+		const matchedBase = paragraphMatchedBaseIdx[i];
+		if (matchedBase !== null) {
+			if (matchedBase > maxBaseIdxEncountered) maxBaseIdxEncountered = matchedBase;
+		} else insertAfterBaseIdx[i] = maxBaseIdxEncountered;
+	}
+	const result = [];
+	const extraParagraphsBuckets = {};
+	insertAfterBaseIdx.forEach((afterIdx, paragraphIdx) => {
+		if (afterIdx === -1) return;
+		extraParagraphsBuckets[afterIdx] = extraParagraphsBuckets[afterIdx] || [];
+		extraParagraphsBuckets[afterIdx].push(paragraphIdx);
+	});
+	for (let bIdx = 0; bIdx < baseFileParagraphs.length; bIdx++) {
+		const matchedParagraphIdx = firstMatchIndexForBase[bIdx];
+		if (matchedParagraphIdx !== -1) result.push(textToReorderParagraphs[matchedParagraphIdx]);
+		if (extraParagraphsBuckets[bIdx]) extraParagraphsBuckets[bIdx].forEach((pIdx) => {
+			result.push(textToReorderParagraphs[pIdx]);
+		});
+	}
+	const leadingExtras = [];
+	insertAfterBaseIdx.forEach((afterIdx, pIdx) => {
+		if (afterIdx === -1 && paragraphMatchedBaseIdx[pIdx] === null) leadingExtras.push(textToReorderParagraphs[pIdx]);
+	});
+	return [...leadingExtras, ...result].join("\n\n");
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  reorderParagraphs
-});
+
+//#endregion
+exports.reorderParagraphs = reorderParagraphs;
 //# sourceMappingURL=reorderParagraphs.cjs.map

package/dist/cjs/utils/reorderParagraphs.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/reorderParagraphs.ts"],"sourcesContent":["import { listSpecialChars } from './listSpecialChars';\n\n/**\n * Split a text into paragraphs.\n *\n * We consider a paragraph boundary to be a block of at least two consecutive\n * new-lines that is immediately followed by a non-white-space character.  This\n * way, internal blank lines that are part of the same paragraph (e.g. a list\n * item that purposely contains a visual break) are preserved while true\n * paragraph breaks – the ones generated when calling `arr.join(\"\\n\\n\")` in\n * the tests – are still detected.\n */\nconst splitByParagraph = (text: string): string[] => {\n  const paragraphs: string[] = [];\n\n  // Capture the delimiter so that we can inspect how many new-lines it\n  // contains.  We know that the test strings only use LF, so we keep the\n  // regex simple here.\n  const tokens = text.split(/(\\n{2,})/);\n\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n\n    // Even-indexed tokens are the actual paragraph contents.\n    if (i % 2 === 0) {\n      if (token) paragraphs.push(token);\n      continue;\n    }\n\n    // Odd-indexed tokens are the delimiters (>= two consecutive new-lines).\n    // The first and last pairs represent the natural separators that are\n    // added when paragraphs are later joined with \"\\n\\n\".  Any additional\n    // pairs in between correspond to *explicit* blank paragraphs that were\n    // present in the original text and must therefore be preserved.\n    const pairsOfNewlines = Math.floor(token.length / 2);\n    const blankParagraphs = Math.max(0, pairsOfNewlines - 2);\n\n    for (let j = 0; j < blankParagraphs; j++) {\n      paragraphs.push('\\n\\n');\n    }\n  }\n\n  return paragraphs;\n};\n\n/**\n * Determine whether two paragraphs match – either exactly, or by sharing the\n * same \"special-character signature\".\n */\nconst paragraphMatches = (\n  paragraph: string,\n  baseParagraph: string,\n  paragraphSignature: ReturnType<typeof listSpecialChars>,\n  baseSignature: ReturnType<typeof listSpecialChars>\n): boolean => {\n  if (paragraph === baseParagraph) return true;\n  // fallback to special-character signature comparison\n  if (paragraphSignature.length !== baseSignature.length) return false;\n\n  for (let i = 0; i < paragraphSignature.length; i++) {\n    if (paragraphSignature[i].char !== baseSignature[i].char) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Re-order `textToReorder` so that its paragraphs follow the ordering found in\n * `baseFileContent`, while preserving any extra paragraphs (those not present\n * in the base file) in a position that is intuitive for a human reader: right\n * after the closest preceding paragraph coming from the base file.\n */\nexport const reorderParagraphs = (\n  textToReorder: string,\n  baseFileContent: string\n): string => {\n  // 1. Split both texts into paragraphs and pre-compute their signatures.\n  const baseFileParagraphs = splitByParagraph(baseFileContent);\n  const textToReorderParagraphs = splitByParagraph(textToReorder);\n\n  const baseSignatures = baseFileParagraphs.map((p) => listSpecialChars(p));\n  const textSignatures = textToReorderParagraphs.map((p) =>\n    listSpecialChars(p)\n  );\n\n  // 2. For every paragraph in the text to reorder, find the *first* base\n  //    paragraph it matches.  We only allow each base paragraph to be matched\n  //    once.  Any further identical paragraphs will be treated as \"extra\" and\n  //    will be positioned later on, next to their closest neighbour.\n  const firstMatchIndexForBase: number[] = Array(\n    baseFileParagraphs.length\n  ).fill(-1);\n  const paragraphMatchedBaseIdx: (number | null)[] = Array(\n    textToReorderParagraphs.length\n  ).fill(null);\n\n  for (let i = 0; i < textToReorderParagraphs.length; i++) {\n    const paragraph = textToReorderParagraphs[i];\n    const sig = textSignatures[i];\n\n    // exact match pass first for performance\n    let foundIdx = baseFileParagraphs.findIndex(\n      (baseParagraph, idx) =>\n        firstMatchIndexForBase[idx] === -1 && paragraph === baseParagraph\n    );\n\n    if (foundIdx === -1) {\n      // fallback to the signature comparison\n      foundIdx = baseFileParagraphs.findIndex(\n        (baseParagraph, idx) =>\n          firstMatchIndexForBase[idx] === -1 &&\n          paragraphMatches(paragraph, baseParagraph, sig, baseSignatures[idx])\n      );\n    }\n\n    if (foundIdx !== -1) {\n      firstMatchIndexForBase[foundIdx] = i;\n      paragraphMatchedBaseIdx[i] = foundIdx;\n    }\n  }\n\n  // 3. For the paragraphs that *didn't* get matched to a base paragraph, we\n  //    record the highest-numbered base paragraph that was matched *before* it\n  //    in the original text.  The extra paragraph will later be placed right\n  //    after that paragraph in the final ordering.\n  const insertAfterBaseIdx: number[] = Array(\n    textToReorderParagraphs.length\n  ).fill(-1);\n  let maxBaseIdxEncountered = -1;\n\n  for (let i = 0; i < textToReorderParagraphs.length; i++) {\n    const matchedBase = paragraphMatchedBaseIdx[i];\n\n    if (matchedBase !== null) {\n      if (matchedBase > maxBaseIdxEncountered) {\n        maxBaseIdxEncountered = matchedBase;\n      }\n    } else {\n      insertAfterBaseIdx[i] = maxBaseIdxEncountered;\n    }\n  }\n\n  // 4. Build the final, reordered list of paragraphs.\n  const result: string[] = [];\n\n  // Helper: quickly retrieve all indices of paragraphs that should be inserted\n  // after a given base index, while keeping their original order.\n  const extraParagraphsBuckets: Record<number, number[]> = {};\n  insertAfterBaseIdx.forEach((afterIdx, paragraphIdx) => {\n    if (afterIdx === -1) return; // will be handled later (if any)\n    extraParagraphsBuckets[afterIdx] = extraParagraphsBuckets[afterIdx] || [];\n    extraParagraphsBuckets[afterIdx].push(paragraphIdx);\n  });\n\n  for (let bIdx = 0; bIdx < baseFileParagraphs.length; bIdx++) {\n    const matchedParagraphIdx = firstMatchIndexForBase[bIdx];\n\n    if (matchedParagraphIdx !== -1) {\n      result.push(textToReorderParagraphs[matchedParagraphIdx]);\n    }\n\n    if (extraParagraphsBuckets[bIdx]) {\n      extraParagraphsBuckets[bIdx].forEach((pIdx) => {\n        result.push(textToReorderParagraphs[pIdx]);\n      });\n    }\n  }\n\n  // Finally, if there were extra paragraphs appearing *before* any matched\n  // base paragraph (insertAfterBaseIdx === -1), we prepend them to the output\n  // in their original order.\n  const leadingExtras: string[] = [];\n  insertAfterBaseIdx.forEach((afterIdx, pIdx) => {\n    if (afterIdx === -1 && paragraphMatchedBaseIdx[pIdx] === null) {\n      leadingExtras.push(textToReorderParagraphs[pIdx]);\n    }\n  });\n\n  return [...leadingExtras, ...result].join('\\n\\n');\n};\n"],"mappings":"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","names":[]}
+{"version":3,"file":"reorderParagraphs.cjs","names":["paragraphs: string[]","listSpecialChars","firstMatchIndexForBase: number[]","paragraphMatchedBaseIdx: (number | null)[]","insertAfterBaseIdx: number[]","result: string[]","extraParagraphsBuckets: Record<number, number[]>","leadingExtras: string[]"],"sources":["../../../src/utils/reorderParagraphs.ts"],"sourcesContent":["import { listSpecialChars } from './listSpecialChars';\n\n/**\n * Split a text into paragraphs.\n *\n * We consider a paragraph boundary to be a block of at least two consecutive\n * new-lines that is immediately followed by a non-white-space character.  This\n * way, internal blank lines that are part of the same paragraph (e.g. a list\n * item that purposely contains a visual break) are preserved while true\n * paragraph breaks – the ones generated when calling `arr.join(\"\\n\\n\")` in\n * the tests – are still detected.\n */\nconst splitByParagraph = (text: string): string[] => {\n  const paragraphs: string[] = [];\n\n  // Capture the delimiter so that we can inspect how many new-lines it\n  // contains.  We know that the test strings only use LF, so we keep the\n  // regex simple here.\n  const tokens = text.split(/(\\n{2,})/);\n\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n\n    // Even-indexed tokens are the actual paragraph contents.\n    if (i % 2 === 0) {\n      if (token) paragraphs.push(token);\n      continue;\n    }\n\n    // Odd-indexed tokens are the delimiters (>= two consecutive new-lines).\n    // The first and last pairs represent the natural separators that are\n    // added when paragraphs are later joined with \"\\n\\n\".  Any additional\n    // pairs in between correspond to *explicit* blank paragraphs that were\n    // present in the original text and must therefore be preserved.\n    const pairsOfNewlines = Math.floor(token.length / 2);\n    const blankParagraphs = Math.max(0, pairsOfNewlines - 2);\n\n    for (let j = 0; j < blankParagraphs; j++) {\n      paragraphs.push('\\n\\n');\n    }\n  }\n\n  return paragraphs;\n};\n\n/**\n * Determine whether two paragraphs match – either exactly, or by sharing the\n * same \"special-character signature\".\n */\nconst paragraphMatches = (\n  paragraph: string,\n  baseParagraph: string,\n  paragraphSignature: ReturnType<typeof listSpecialChars>,\n  baseSignature: ReturnType<typeof listSpecialChars>\n): boolean => {\n  if (paragraph === baseParagraph) return true;\n  // fallback to special-character signature comparison\n  if (paragraphSignature.length !== baseSignature.length) return false;\n\n  for (let i = 0; i < paragraphSignature.length; i++) {\n    if (paragraphSignature[i].char !== baseSignature[i].char) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Re-order `textToReorder` so that its paragraphs follow the ordering found in\n * `baseFileContent`, while preserving any extra paragraphs (those not present\n * in the base file) in a position that is intuitive for a human reader: right\n * after the closest preceding paragraph coming from the base file.\n */\nexport const reorderParagraphs = (\n  textToReorder: string,\n  baseFileContent: string\n): string => {\n  // 1. Split both texts into paragraphs and pre-compute their signatures.\n  const baseFileParagraphs = splitByParagraph(baseFileContent);\n  const textToReorderParagraphs = splitByParagraph(textToReorder);\n\n  const baseSignatures = baseFileParagraphs.map((p) => listSpecialChars(p));\n  const textSignatures = textToReorderParagraphs.map((p) =>\n    listSpecialChars(p)\n  );\n\n  // 2. For every paragraph in the text to reorder, find the *first* base\n  //    paragraph it matches.  We only allow each base paragraph to be matched\n  //    once.  Any further identical paragraphs will be treated as \"extra\" and\n  //    will be positioned later on, next to their closest neighbour.\n  const firstMatchIndexForBase: number[] = Array(\n    baseFileParagraphs.length\n  ).fill(-1);\n  const paragraphMatchedBaseIdx: (number | null)[] = Array(\n    textToReorderParagraphs.length\n  ).fill(null);\n\n  for (let i = 0; i < textToReorderParagraphs.length; i++) {\n    const paragraph = textToReorderParagraphs[i];\n    const sig = textSignatures[i];\n\n    // exact match pass first for performance\n    let foundIdx = baseFileParagraphs.findIndex(\n      (baseParagraph, idx) =>\n        firstMatchIndexForBase[idx] === -1 && paragraph === baseParagraph\n    );\n\n    if (foundIdx === -1) {\n      // fallback to the signature comparison\n      foundIdx = baseFileParagraphs.findIndex(\n        (baseParagraph, idx) =>\n          firstMatchIndexForBase[idx] === -1 &&\n          paragraphMatches(paragraph, baseParagraph, sig, baseSignatures[idx])\n      );\n    }\n\n    if (foundIdx !== -1) {\n      firstMatchIndexForBase[foundIdx] = i;\n      paragraphMatchedBaseIdx[i] = foundIdx;\n    }\n  }\n\n  // 3. For the paragraphs that *didn't* get matched to a base paragraph, we\n  //    record the highest-numbered base paragraph that was matched *before* it\n  //    in the original text.  The extra paragraph will later be placed right\n  //    after that paragraph in the final ordering.\n  const insertAfterBaseIdx: number[] = Array(\n    textToReorderParagraphs.length\n  ).fill(-1);\n  let maxBaseIdxEncountered = -1;\n\n  for (let i = 0; i < textToReorderParagraphs.length; i++) {\n    const matchedBase = paragraphMatchedBaseIdx[i];\n\n    if (matchedBase !== null) {\n      if (matchedBase > maxBaseIdxEncountered) {\n        maxBaseIdxEncountered = matchedBase;\n      }\n    } else {\n      insertAfterBaseIdx[i] = maxBaseIdxEncountered;\n    }\n  }\n\n  // 4. Build the final, reordered list of paragraphs.\n  const result: string[] = [];\n\n  // Helper: quickly retrieve all indices of paragraphs that should be inserted\n  // after a given base index, while keeping their original order.\n  const extraParagraphsBuckets: Record<number, number[]> = {};\n  insertAfterBaseIdx.forEach((afterIdx, paragraphIdx) => {\n    if (afterIdx === -1) return; // will be handled later (if any)\n    extraParagraphsBuckets[afterIdx] = extraParagraphsBuckets[afterIdx] || [];\n    extraParagraphsBuckets[afterIdx].push(paragraphIdx);\n  });\n\n  for (let bIdx = 0; bIdx < baseFileParagraphs.length; bIdx++) {\n    const matchedParagraphIdx = firstMatchIndexForBase[bIdx];\n\n    if (matchedParagraphIdx !== -1) {\n      result.push(textToReorderParagraphs[matchedParagraphIdx]);\n    }\n\n    if (extraParagraphsBuckets[bIdx]) {\n      extraParagraphsBuckets[bIdx].forEach((pIdx) => {\n        result.push(textToReorderParagraphs[pIdx]);\n      });\n    }\n  }\n\n  // Finally, if there were extra paragraphs appearing *before* any matched\n  // base paragraph (insertAfterBaseIdx === -1), we prepend them to the output\n  // in their original order.\n  const leadingExtras: string[] = [];\n  insertAfterBaseIdx.forEach((afterIdx, pIdx) => {\n    if (afterIdx === -1 && paragraphMatchedBaseIdx[pIdx] === null) {\n      leadingExtras.push(textToReorderParagraphs[pIdx]);\n    }\n  });\n\n  return [...leadingExtras, ...result].join('\\n\\n');\n};\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAM,oBAAoB,SAA2B;CACnD,MAAMA,aAAuB,EAAE;CAK/B,MAAM,SAAS,KAAK,MAAM,WAAW;AAErC,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,QAAQ,OAAO;AAGrB,MAAI,IAAI,MAAM,GAAG;AACf,OAAI,MAAO,YAAW,KAAK,MAAM;AACjC;;EAQF,MAAM,kBAAkB,KAAK,MAAM,MAAM,SAAS,EAAE;EACpD,MAAM,kBAAkB,KAAK,IAAI,GAAG,kBAAkB,EAAE;AAExD,OAAK,IAAI,IAAI,GAAG,IAAI,iBAAiB,IACnC,YAAW,KAAK,OAAO;;AAI3B,QAAO;;;;;;AAOT,MAAM,oBACJ,WACA,eACA,oBACA,kBACY;AACZ,KAAI,cAAc,cAAe,QAAO;AAExC,KAAI,mBAAmB,WAAW,cAAc,OAAQ,QAAO;AAE/D,MAAK,IAAI,IAAI,GAAG,IAAI,mBAAmB,QAAQ,IAC7C,KAAI,mBAAmB,GAAG,SAAS,cAAc,GAAG,KAClD,QAAO;AAGX,QAAO;;;;;;;;AAST,MAAa,qBACX,eACA,oBACW;CAEX,MAAM,qBAAqB,iBAAiB,gBAAgB;CAC5D,MAAM,0BAA0B,iBAAiB,cAAc;CAE/D,MAAM,iBAAiB,mBAAmB,KAAK,MAAMC,gDAAiB,EAAE,CAAC;CACzE,MAAM,iBAAiB,wBAAwB,KAAK,MAClDA,gDAAiB,EAAE,CACpB;CAMD,MAAMC,yBAAmC,MACvC,mBAAmB,OACpB,CAAC,KAAK,GAAG;CACV,MAAMC,0BAA6C,MACjD,wBAAwB,OACzB,CAAC,KAAK,KAAK;AAEZ,MAAK,IAAI,IAAI,GAAG,IAAI,wBAAwB,QAAQ,KAAK;EACvD,MAAM,YAAY,wBAAwB;EAC1C,MAAM,MAAM,eAAe;EAG3B,IAAI,WAAW,mBAAmB,WAC/B,eAAe,QACd,uBAAuB,SAAS,MAAM,cAAc,cACvD;AAED,MAAI,aAAa,GAEf,YAAW,mBAAmB,WAC3B,eAAe,QACd,uBAAuB,SAAS,MAChC,iBAAiB,WAAW,eAAe,KAAK,eAAe,KAAK,CACvE;AAGH,MAAI,aAAa,IAAI;AACnB,0BAAuB,YAAY;AACnC,2BAAwB,KAAK;;;CAQjC,MAAMC,qBAA+B,MACnC,wBAAwB,OACzB,CAAC,KAAK,GAAG;CACV,IAAI,wBAAwB;AAE5B,MAAK,IAAI,IAAI,GAAG,IAAI,wBAAwB,QAAQ,KAAK;EACvD,MAAM,cAAc,wBAAwB;AAE5C,MAAI,gBAAgB,MAClB;OAAI,cAAc,sBAChB,yBAAwB;QAG1B,oBAAmB,KAAK;;CAK5B,MAAMC,SAAmB,EAAE;CAI3B,MAAMC,yBAAmD,EAAE;AAC3D,oBAAmB,SAAS,UAAU,iBAAiB;AACrD,MAAI,aAAa,GAAI;AACrB,yBAAuB,YAAY,uBAAuB,aAAa,EAAE;AACzE,yBAAuB,UAAU,KAAK,aAAa;GACnD;AAEF,MAAK,IAAI,OAAO,GAAG,OAAO,mBAAmB,QAAQ,QAAQ;EAC3D,MAAM,sBAAsB,uBAAuB;AAEnD,MAAI,wBAAwB,GAC1B,QAAO,KAAK,wBAAwB,qBAAqB;AAG3D,MAAI,uBAAuB,MACzB,wBAAuB,MAAM,SAAS,SAAS;AAC7C,UAAO,KAAK,wBAAwB,MAAM;IAC1C;;CAON,MAAMC,gBAA0B,EAAE;AAClC,oBAAmB,SAAS,UAAU,SAAS;AAC7C,MAAI,aAAa,MAAM,wBAAwB,UAAU,KACvD,eAAc,KAAK,wBAAwB,MAAM;GAEnD;AAEF,QAAO,CAAC,GAAG,eAAe,GAAG,OAAO,CAAC,KAAK,OAAO"}

package/dist/cjs/watch.cjs

@@ -1,42 +1,24 @@
-"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 watch_exports = {};
-__export(watch_exports, {
-  watchContentDeclaration: () => watchContentDeclaration
-});
-module.exports = __toCommonJS(watch_exports);
-var import_chokidar = require("@intlayer/chokidar");
-var import_config = require("@intlayer/config");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let __intlayer_chokidar = require("@intlayer/chokidar");
+__intlayer_chokidar = require_rolldown_runtime.__toESM(__intlayer_chokidar);
+let __intlayer_config = require("@intlayer/config");
+__intlayer_config = require_rolldown_runtime.__toESM(__intlayer_config);
+
+//#region src/watch.ts
+/**
+* Get locales dictionaries .content.{json|ts|tsx|js|jsx|mjs|cjs} and build the JSON dictionaries in the .intlayer directory.
+* Watch mode available to get the change in the .content.{json|ts|tsx|js|jsx|mjs|cjs}
+*/
 const watchContentDeclaration = async (options) => {
-  const config = (0, import_config.getConfiguration)(options?.configOptions);
-  const appLogger = (0, import_config.getAppLogger)(config);
-  if (options?.with) {
-    (0, import_chokidar.runParallel)(options.with);
-  }
-  appLogger("Watching Intlayer content declarations");
-  (0, import_chokidar.watch)({
-    persistent: true,
-    skipPrepare: options?.skipPrepare ?? false
-  });
+	const appLogger = (0, __intlayer_config.getAppLogger)((0, __intlayer_config.getConfiguration)(options?.configOptions));
+	if (options?.with) (0, __intlayer_chokidar.runParallel)(options.with);
+	appLogger("Watching Intlayer content declarations");
+	(0, __intlayer_chokidar.watch)({
+		persistent: true,
+		skipPrepare: options?.skipPrepare ?? false
+	});
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  watchContentDeclaration
-});
+
+//#endregion
+exports.watchContentDeclaration = watchContentDeclaration;
 //# sourceMappingURL=watch.cjs.map