@intlayer/cli 5.5.9 → 5.5.11

package/dist/cjs/utils/checkFileModifiedRange.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/checkFileModifiedRange.test.ts"],"sourcesContent":["import {\n  afterEach,\n  beforeEach,\n  describe,\n  expect,\n  it,\n  vi,\n  type Mock,\n} from 'vitest';\n\n// We are testing the public helper. The helper itself internally relies on\n// `checkLastUpdateTime`, which hits the file-system. To keep the test\n// deterministic (and independent from the real FS) we mock this dependency so\n// that we can control the last modification date that the helper receives.\n\n// NOTE: `vi.mock` must be called *before* the module under test is imported.\nvi.mock('./checkLastUpdateTime', () => {\n  return {\n    checkLastUpdateTime: vi.fn(() => new Date()), // pretend the file was just modified\n  };\n});\n\nimport { checkFileModifiedRange } from './checkFileModifiedRange';\nimport { checkLastUpdateTime } from './checkLastUpdateTime';\n\ndescribe('checkFileModifiedRange', () => {\n  beforeEach(() => {\n    // Use fake timers so Date.now() is deterministic.\n    vi.useFakeTimers();\n    // Pin the system time to an arbitrary date for reproducibility\n    vi.setSystemTime(new Date('2025-01-01'));\n  });\n\n  afterEach(() => {\n    vi.useRealTimers();\n    vi.clearAllMocks();\n  });\n\n  const testList = [\n    {\n      // |---a---|\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: false, // No constraints\n    },\n    {\n      // |-min-a-max-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: true, // During the range\n    },\n    {\n      // |-min-max-a-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: false, // After the range\n    },\n    {\n      // |-a-min-max-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2023-01-01'), // a\n      isSkipped: false, // Before the range\n    },\n    {\n      // |-a-min-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      fileModifiedTime: new Date('2023-01-01'), // a\n      isSkipped: false, // Before the skipIfModifiedBefore\n    },\n    {\n      // |-min-a-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: true, // After the skipIfModifiedBefore\n    },\n    {\n      // |-a-max-|\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: true, // Before the skipIfModifiedAfter\n    },\n    {\n      // |-max-a-|\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: true, // After the skipIfModifiedAfter\n    },\n    {\n      // |-min-max-a-|\n      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1000, // min // 3 year ago\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: false, // Before the range\n    },\n    {\n      // |-a-max-|\n      skipIfModifiedAfter: 0, // max // now\n      fileModifiedTime: new Date('2024-01-01'), // a\n      isSkipped: false, // Before the skipIfModifiedAfter\n    },\n    {\n      // |-min-a-|\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: true, // Before the skipIfModifiedAfter\n    },\n    {\n      // |-min-a-max-|\n      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1000, // min // 3 year ago\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2023-01-01'), // a\n      isSkipped: true, // After the range\n    },\n    {\n      // |-a-min-max-|\n      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1000, // min // 3 year ago\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2020-01-01'), // a\n      isSkipped: false, // Before the range\n    },\n    {\n      // |-min-max-a-|\n      skipIfModifiedBefore: '2024-01-01T00:00:00Z', // min\n      skipIfModifiedAfter: '2026-01-01T00:00:00Z', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: false, // After the range\n    },\n  ];\n\n  testList.forEach((test) => {\n    it(`should correctly handle string date inputs (absolute time) outside of the range`, () => {\n      const filePath = 'test/file.txt';\n\n      // Simulate the file's last modification time for this test case\n      (checkLastUpdateTime as unknown as Mock).mockReturnValue(\n        // If a specific mocked modification time is provided, use it. Otherwise, fall back to \"now\".\n        test.fileModifiedTime ?? new Date()\n      );\n\n      const { isSkipped } = checkFileModifiedRange(filePath, {\n        skipIfModifiedBefore: test.skipIfModifiedBefore,\n        skipIfModifiedAfter: test.skipIfModifiedAfter,\n      });\n\n      expect(isSkipped).toBe(test.isSkipped);\n    });\n  });\n});\n"],"mappings":"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","names":[]}

package/dist/cjs/utils/checkLastUpdateTime.cjs

@@ -0,0 +1,33 @@
+"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 checkLastUpdateTime_exports = {};
+__export(checkLastUpdateTime_exports, {
+  checkLastUpdateTime: () => checkLastUpdateTime
+});
+module.exports = __toCommonJS(checkLastUpdateTime_exports);
+var import_fs = require("fs");
+const checkLastUpdateTime = (filePath) => {
+  const stats = (0, import_fs.statSync)(filePath);
+  return new Date(stats.mtime);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkLastUpdateTime
+});
+//# sourceMappingURL=checkLastUpdateTime.cjs.map

package/dist/cjs/utils/checkLastUpdateTime.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/checkLastUpdateTime.ts"],"sourcesContent":["import { statSync } from 'fs';\n\n/**\n * Returns the last modification date of a file.\n *\n * @param filePath - Absolute or relative path to the file to inspect.\n * @returns Date instance representing the file's last modified time (mtime).\n * @throws Will propagate any error thrown by fs.statSync (e.g., file not found).\n */\nexport const checkLastUpdateTime = (filePath: string): Date => {\n  const stats = statSync(filePath);\n  return new Date(stats.mtime);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAyB;AASlB,MAAM,sBAAsB,CAAC,aAA2B;AAC7D,QAAM,YAAQ,oBAAS,QAAQ;AAC/B,SAAO,IAAI,KAAK,MAAM,KAAK;AAC7B;","names":[]}

package/dist/cjs/utils/chunkInference.cjs

@@ -0,0 +1,58 @@
+"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 chunkInference_exports = {};
+__export(chunkInference_exports, {
+  chunkInference: () => chunkInference
+});
+module.exports = __toCommonJS(chunkInference_exports);
+var import_api = require("@intlayer/api");
+var import_config = require("@intlayer/config");
+const chunkInference = async (messages, aiOptions, oAuth2AccessToken) => {
+  let lastResult;
+  await (0, import_config.retryManager)(async () => {
+    const response = await (0, import_api.getAiAPI)().customQuery(
+      {
+        aiOptions,
+        messages
+      },
+      {
+        ...oAuth2AccessToken && {
+          headers: {
+            Authorization: `Bearer ${oAuth2AccessToken}`
+          }
+        }
+      }
+    );
+    if (!response.data) {
+      throw new Error("No response from AI API");
+    }
+    const { fileContent, tokenUsed } = response.data;
+    const newContent = fileContent.replaceAll("///chunksStart///", "").replaceAll("///chunkStart///", "").replaceAll("///chunksEnd///", "").replaceAll("///chunkEnd///", "");
+    lastResult = {
+      fileContent: newContent,
+      tokenUsed
+    };
+  })();
+  return lastResult;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunkInference
+});
+//# sourceMappingURL=chunkInference.cjs.map

package/dist/cjs/utils/chunkInference.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/chunkInference.ts"],"sourcesContent":["import { type AIOptions, type Messages, getAiAPI } from '@intlayer/api';\nimport { retryManager } from '@intlayer/config';\n\ntype ChunkInferenceResult = {\n  fileContent: string;\n  tokenUsed: number;\n};\n\n/**\n * Translates a single chunk via the OpenAI API.\n * Includes retry logic if the call fails.\n */\nexport const chunkInference = async (\n  messages: Messages,\n  aiOptions?: AIOptions,\n  oAuth2AccessToken?: string\n): Promise<ChunkInferenceResult> => {\n  let lastResult: ChunkInferenceResult;\n\n  await retryManager(async () => {\n    const response = await getAiAPI().customQuery(\n      {\n        aiOptions,\n        messages,\n      },\n      {\n        ...(oAuth2AccessToken && {\n          headers: {\n            Authorization: `Bearer ${oAuth2AccessToken}`,\n          },\n        }),\n      }\n    );\n\n    if (!response.data) {\n      throw new Error('No response from AI API');\n    }\n\n    const { fileContent, tokenUsed } = response.data;\n\n    const newContent = fileContent\n      .replaceAll('///chunksStart///', '')\n      .replaceAll('///chunkStart///', '')\n      .replaceAll('///chunksEnd///', '')\n      .replaceAll('///chunkEnd///', '');\n\n    lastResult = {\n      fileContent: newContent,\n      tokenUsed,\n    };\n  })();\n\n  return lastResult!;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAwD;AACxD,oBAA6B;AAWtB,MAAM,iBAAiB,OAC5B,UACA,WACA,sBACkC;AAClC,MAAI;AAEJ,YAAM,4BAAa,YAAY;AAC7B,UAAM,WAAW,UAAM,qBAAS,EAAE;AAAA,MAChC;AAAA,QACE;AAAA,QACA;AAAA,MACF;AAAA,MACA;AAAA,QACE,GAAI,qBAAqB;AAAA,UACvB,SAAS;AAAA,YACP,eAAe,UAAU,iBAAiB;AAAA,UAC5C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,CAAC,SAAS,MAAM;AAClB,YAAM,IAAI,MAAM,yBAAyB;AAAA,IAC3C;AAEA,UAAM,EAAE,aAAa,UAAU,IAAI,SAAS;AAE5C,UAAM,aAAa,YAChB,WAAW,qBAAqB,EAAE,EAClC,WAAW,oBAAoB,EAAE,EACjC,WAAW,mBAAmB,EAAE,EAChC,WAAW,kBAAkB,EAAE;AAElC,iBAAa;AAAA,MACX,aAAa;AAAA,MACb;AAAA,IACF;AAAA,EACF,CAAC,EAAE;AAEH,SAAO;AACT;","names":[]}

package/dist/cjs/utils/fixChunkStartEndChars.cjs

@@ -0,0 +1,47 @@
+"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 fixChunkStartEndChars_exports = {};
+__export(fixChunkStartEndChars_exports, {
+  fixChunkStartEndChars: () => fixChunkStartEndChars
+});
+module.exports = __toCommonJS(fixChunkStartEndChars_exports);
+const CHAR_TO_CHECK_FORMATTING = ["```", "\n\n", "\n", "---", "{{", "}}"];
+const escapeForRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\n/g, "\\n");
+const FORMATTING_REGEX_SOURCE = `(?:${CHAR_TO_CHECK_FORMATTING.map(escapeForRegExp).join("|")})+`;
+const LEADING_FORMATTING_REGEX = new RegExp(`^${FORMATTING_REGEX_SOURCE}`);
+const TRAILING_FORMATTING_REGEX = new RegExp(`${FORMATTING_REGEX_SOURCE}$`);
+const fixChunkStartEndChars = (reviewedChunkResult, baseChunkContext) => {
+  let result = reviewedChunkResult;
+  const baseLeading = baseChunkContext.match(LEADING_FORMATTING_REGEX)?.[0] ?? "";
+  const baseTrailing = baseChunkContext.match(TRAILING_FORMATTING_REGEX)?.[0] ?? "";
+  const resultLeading = result.match(LEADING_FORMATTING_REGEX)?.[0] ?? "";
+  const resultTrailing = result.match(TRAILING_FORMATTING_REGEX)?.[0] ?? "";
+  if (baseLeading !== resultLeading) {
+    result = baseLeading + result.slice(resultLeading.length);
+  }
+  if (baseTrailing !== resultTrailing) {
+    result = result.slice(0, result.length - resultTrailing.length) + baseTrailing;
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fixChunkStartEndChars
+});
+//# sourceMappingURL=fixChunkStartEndChars.cjs.map

package/dist/cjs/utils/fixChunkStartEndChars.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fixChunkStartEndChars.ts"],"sourcesContent":["const CHAR_TO_CHECK_FORMATTING = ['```', '\\n\\n', '\\n', '---', '{{', '}}'];\n\n// Escape a string for use in RegExp\nconst escapeForRegExp = (str: string) =>\n  str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\n/g, '\\\\n');\n\n// Build once the regex that matches any combination of the formatting chars appearing\n// sequentially at the beginning or at the end of a string.\nconst FORMATTING_REGEX_SOURCE = `(?:${CHAR_TO_CHECK_FORMATTING.map(escapeForRegExp).join('|')})+`;\nconst LEADING_FORMATTING_REGEX = new RegExp(`^${FORMATTING_REGEX_SOURCE}`);\nconst TRAILING_FORMATTING_REGEX = new RegExp(`${FORMATTING_REGEX_SOURCE}$`);\n\nexport const fixChunkStartEndChars = (\n  reviewedChunkResult: string,\n  baseChunkContext: string\n) => {\n  let result = reviewedChunkResult;\n\n  const baseLeading =\n    baseChunkContext.match(LEADING_FORMATTING_REGEX)?.[0] ?? '';\n  const baseTrailing =\n    baseChunkContext.match(TRAILING_FORMATTING_REGEX)?.[0] ?? '';\n\n  const resultLeading = result.match(LEADING_FORMATTING_REGEX)?.[0] ?? '';\n  const resultTrailing = result.match(TRAILING_FORMATTING_REGEX)?.[0] ?? '';\n\n  // Fix leading formatting\n  if (baseLeading !== resultLeading) {\n    // Remove current leading formatting found in result and prepend the correct one\n    result = baseLeading + result.slice(resultLeading.length);\n  }\n\n  // Fix trailing formatting\n  if (baseTrailing !== resultTrailing) {\n    // Remove current trailing formatting found in result and append the correct one\n    result =\n      result.slice(0, result.length - resultTrailing.length) + baseTrailing;\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAAM,2BAA2B,CAAC,OAAO,QAAQ,MAAM,OAAO,MAAM,IAAI;AAGxE,MAAM,kBAAkB,CAAC,QACvB,IAAI,QAAQ,uBAAuB,MAAM,EAAE,QAAQ,OAAO,KAAK;AAIjE,MAAM,0BAA0B,MAAM,yBAAyB,IAAI,eAAe,EAAE,KAAK,GAAG,CAAC;AAC7F,MAAM,2BAA2B,IAAI,OAAO,IAAI,uBAAuB,EAAE;AACzE,MAAM,4BAA4B,IAAI,OAAO,GAAG,uBAAuB,GAAG;AAEnE,MAAM,wBAAwB,CACnC,qBACA,qBACG;AACH,MAAI,SAAS;AAEb,QAAM,cACJ,iBAAiB,MAAM,wBAAwB,IAAI,CAAC,KAAK;AAC3D,QAAM,eACJ,iBAAiB,MAAM,yBAAyB,IAAI,CAAC,KAAK;AAE5D,QAAM,gBAAgB,OAAO,MAAM,wBAAwB,IAAI,CAAC,KAAK;AACrE,QAAM,iBAAiB,OAAO,MAAM,yBAAyB,IAAI,CAAC,KAAK;AAGvE,MAAI,gBAAgB,eAAe;AAEjC,aAAS,cAAc,OAAO,MAAM,cAAc,MAAM;AAAA,EAC1D;AAGA,MAAI,iBAAiB,gBAAgB;AAEnC,aACE,OAAO,MAAM,GAAG,OAAO,SAAS,eAAe,MAAM,IAAI;AAAA,EAC7D;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/utils/fixChunkStartEndChars.test.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_fixChunkStartEndChars = require('./fixChunkStartEndChars.cjs');
+const visible = (str) => str.replace(/\n/g, "\\n");
+(0, import_vitest.describe)("fixChunkStartEndChars", () => {
+  (0, import_vitest.it)("should add the missing starting character when the base chunk starts with it", () => {
+    const base = "\nHello world";
+    const reviewed = "Hello world";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(visible(fixed)).toEqual(visible(base));
+  });
+  (0, import_vitest.it)("should add the missing ending character when the base chunk ends with it", () => {
+    const base = 'console.log("hi")```';
+    const reviewed = 'console.log("hi")';
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should remove the extra starting character when the base chunk does not start with it", () => {
+    const base = "Hello world";
+    const reviewed = "\nHello world";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(visible(fixed)).toEqual(visible(base));
+  });
+  (0, import_vitest.it)("should remove the extra ending character when the base chunk does not end with it", () => {
+    const base = "Hello world";
+    const reviewed = "Hello world---";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should return the reviewed chunk untouched when already matching the base structure", () => {
+    const base = "Plain text without special markers";
+    const reviewed = "Plain text without special markers";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should not remove ```` when the base chunk starts with it", () => {
+    const base = "```test";
+    const reviewed = "```test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should add ```` when the base chunk ends with it", () => {
+    const base = "```test";
+    const reviewed = "test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should remove ```` when the base chunk starts with it", () => {
+    const base = "test";
+    const reviewed = "```test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should not remove ```` when the base chunk finishes with it", () => {
+    const base = "test```";
+    const reviewed = "test```";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should add ```` when the base chunk finishes with it", () => {
+    const base = "test```";
+    const reviewed = "test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should remove ```` when the base chunk finishes with it", () => {
+    const base = "test";
+    const reviewed = "test```";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should add the missing char is a char list that matching char list", () => {
+    const baseChunk = "```\n\n### 2. **Check if the command is registered**\n";
+    const aiGeneratedResult = "\n\n### 2. **V\xE9rifiez si la commande est enregistr\xE9e**\n";
+    const fixedResultError = "```### 2. **V\xE9rifiez si la commande est enregistr\xE9e**\n";
+    const fixedResultSuccess = "```\n\n### 2. **V\xE9rifiez si la commande est enregistr\xE9e**\n";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(aiGeneratedResult, baseChunk);
+    (0, import_vitest.expect)(fixed).toMatch(/^```\n\n### 2\./);
+  });
+});
+//# sourceMappingURL=fixChunkStartEndChars.test.cjs.map

package/dist/cjs/utils/fixChunkStartEndChars.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fixChunkStartEndChars.test.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest';\nimport { fixChunkStartEndChars } from './fixChunkStartEndChars';\n\n// Helper to visualise new line at the beginning/end of a string when debugging\nconst visible = (str: string) => str.replace(/\\n/g, '\\\\n');\n\ndescribe('fixChunkStartEndChars', () => {\n  it('should add the missing starting character when the base chunk starts with it', () => {\n    const base = '\\nHello world';\n    const reviewed = 'Hello world';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(visible(fixed)).toEqual(visible(base));\n  });\n\n  it('should add the missing ending character when the base chunk ends with it', () => {\n    const base = 'console.log(\"hi\")```';\n    const reviewed = 'console.log(\"hi\")';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should remove the extra starting character when the base chunk does not start with it', () => {\n    const base = 'Hello world';\n    const reviewed = '\\nHello world';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(visible(fixed)).toEqual(visible(base));\n  });\n\n  it('should remove the extra ending character when the base chunk does not end with it', () => {\n    const base = 'Hello world';\n    const reviewed = 'Hello world---';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should return the reviewed chunk untouched when already matching the base structure', () => {\n    const base = 'Plain text without special markers';\n    const reviewed = 'Plain text without special markers';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should not remove ```` when the base chunk starts with it', () => {\n    const base = '```test';\n    const reviewed = '```test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should add ```` when the base chunk ends with it', () => {\n    const base = '```test';\n    const reviewed = 'test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should remove ```` when the base chunk starts with it', () => {\n    const base = 'test';\n    const reviewed = '```test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should not remove ```` when the base chunk finishes with it', () => {\n    const base = 'test```';\n    const reviewed = 'test```';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should add ```` when the base chunk finishes with it', () => {\n    const base = 'test```';\n    const reviewed = 'test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should remove ```` when the base chunk finishes with it', () => {\n    const base = 'test';\n    const reviewed = 'test```';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should add the missing char is a char list that matching char list', () => {\n    // Here the base chunk as entry for the AI\n    const baseChunk =\n      '```\\n' + '\\n' + '### 2. **Check if the command is registered**\\n';\n\n    // But the translation AI returned a content that is wrong, because the firsts chars are missing\n    const aiGeneratedResult =\n      '\\n' + '\\n' + '### 2. **Vérifiez si la commande est enregistrée**\\n';\n\n    // The current result is this one, but it's wrong because the \\n are missing\n    const fixedResultError =\n      '```### 2. **Vérifiez si la commande est enregistrée**\\n';\n\n    // The correct result should be this one, with the \\n at the beginning\n    const fixedResultSuccess =\n      '```\\n' + '\\n' + '### 2. **Vérifiez si la commande est enregistrée**\\n';\n\n    const fixed = fixChunkStartEndChars(aiGeneratedResult, baseChunk);\n\n    // Check if it start by '```\\n' + '\\n' + '### 2.'\n    expect(fixed).toMatch(/^```\\n\\n### 2\\./);\n  });\n});\n"],"mappings":";AAAA,oBAAqC;AACrC,mCAAsC;AAGtC,MAAM,UAAU,CAAC,QAAgB,IAAI,QAAQ,OAAO,KAAK;AAAA,IAEzD,wBAAS,yBAAyB,MAAM;AACtC,wBAAG,gFAAgF,MAAM;AACvF,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,QAAQ,KAAK,CAAC,EAAE,QAAQ,QAAQ,IAAI,CAAC;AAAA,EAC9C,CAAC;AAED,wBAAG,4EAA4E,MAAM;AACnF,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,yFAAyF,MAAM;AAChG,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,QAAQ,KAAK,CAAC,EAAE,QAAQ,QAAQ,IAAI,CAAC;AAAA,EAC9C,CAAC;AAED,wBAAG,qFAAqF,MAAM;AAC5F,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,uFAAuF,MAAM;AAC9F,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,6DAA6D,MAAM;AACpE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,oDAAoD,MAAM;AAC3D,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,yDAAyD,MAAM;AAChE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,+DAA+D,MAAM;AACtE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,wDAAwD,MAAM;AAC/D,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,2DAA2D,MAAM;AAClE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,sEAAsE,MAAM;AAE7E,UAAM,YACJ;AAGF,UAAM,oBACJ;AAGF,UAAM,mBACJ;AAGF,UAAM,qBACJ;AAEF,UAAM,YAAQ,oDAAsB,mBAAmB,SAAS;AAGhE,8BAAO,KAAK,EAAE,QAAQ,iBAAiB;AAAA,EACzC,CAAC;AACH,CAAC;","names":[]}

package/dist/cjs/utils/formatTimeDiff.cjs

@@ -0,0 +1,46 @@
+"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 formatTimeDiff_exports = {};
+__export(formatTimeDiff_exports, {
+  formatTimeDiff: () => formatTimeDiff
+});
+module.exports = __toCommonJS(formatTimeDiff_exports);
+const formatTimeDiff = (realtiveTime) => {
+  const diff = realtiveTime.getTime();
+  const MS_IN_SECOND = 1e3;
+  const MS_IN_MINUTE = 60 * MS_IN_SECOND;
+  const MS_IN_HOUR = 60 * MS_IN_MINUTE;
+  const MS_IN_DAY = 24 * MS_IN_HOUR;
+  const days = Math.floor(diff / MS_IN_DAY);
+  const hours = Math.floor(diff % MS_IN_DAY / MS_IN_HOUR);
+  const minutes = Math.floor(diff % MS_IN_HOUR / MS_IN_MINUTE);
+  const seconds = Math.floor(diff % MS_IN_MINUTE / MS_IN_SECOND);
+  if (days > 0) {
+    return `${days}d ${hours}h ${minutes}m ${seconds}s`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  }
+  return `${minutes}m ${seconds}s`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatTimeDiff
+});
+//# sourceMappingURL=formatTimeDiff.cjs.map

package/dist/cjs/utils/formatTimeDiff.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/formatTimeDiff.ts"],"sourcesContent":["export const formatTimeDiff = (realtiveTime: Date): string => {\n  const diff = realtiveTime.getTime();\n\n  const MS_IN_SECOND = 1000;\n  const MS_IN_MINUTE = 60 * MS_IN_SECOND;\n  const MS_IN_HOUR = 60 * MS_IN_MINUTE;\n  const MS_IN_DAY = 24 * MS_IN_HOUR;\n\n  const days = Math.floor(diff / MS_IN_DAY);\n  const hours = Math.floor((diff % MS_IN_DAY) / MS_IN_HOUR);\n  const minutes = Math.floor((diff % MS_IN_HOUR) / MS_IN_MINUTE);\n  const seconds = Math.floor((diff % MS_IN_MINUTE) / MS_IN_SECOND);\n\n  if (days > 0) {\n    return `${days}d ${hours}h ${minutes}m ${seconds}s`;\n  }\n  if (hours > 0) {\n    return `${hours}h ${minutes}m ${seconds}s`;\n  }\n\n  return `${minutes}m ${seconds}s`;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,iBAAiB,CAAC,iBAA+B;AAC5D,QAAM,OAAO,aAAa,QAAQ;AAElC,QAAM,eAAe;AACrB,QAAM,eAAe,KAAK;AAC1B,QAAM,aAAa,KAAK;AACxB,QAAM,YAAY,KAAK;AAEvB,QAAM,OAAO,KAAK,MAAM,OAAO,SAAS;AACxC,QAAM,QAAQ,KAAK,MAAO,OAAO,YAAa,UAAU;AACxD,QAAM,UAAU,KAAK,MAAO,OAAO,aAAc,YAAY;AAC7D,QAAM,UAAU,KAAK,MAAO,OAAO,eAAgB,YAAY;AAE/D,MAAI,OAAO,GAAG;AACZ,WAAO,GAAG,IAAI,KAAK,KAAK,KAAK,OAAO,KAAK,OAAO;AAAA,EAClD;AACA,MAAI,QAAQ,GAAG;AACb,WAAO,GAAG,KAAK,KAAK,OAAO,KAAK,OAAO;AAAA,EACzC;AAEA,SAAO,GAAG,OAAO,KAAK,OAAO;AAC/B;","names":[]}

package/dist/cjs/utils/formatTimeDiff.test.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_formatTimeDiff = require('./formatTimeDiff.cjs');
+(0, import_vitest.describe)("formatTimeDiff", () => {
+  const fixedNow = /* @__PURE__ */ new Date("2025-01-01T00:00:00Z");
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+    import_vitest.vi.setSystemTime(fixedNow);
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.useRealTimers();
+  });
+  (0, import_vitest.it)("formats differences containing days", () => {
+    const past = new Date(
+      2 * 24 * 60 * 60 * 1e3 + // 2 days
+      3 * 60 * 60 * 1e3 + // 3 hours
+      4 * 60 * 1e3 + // 4 minutes
+      5 * 1e3
+      // 5 seconds
+    );
+    (0, import_vitest.expect)((0, import_formatTimeDiff.formatTimeDiff)(past)).toBe("2d 3h 4m 5s");
+  });
+  (0, import_vitest.it)("formats differences containing hours but no days", () => {
+    const past = new Date(3 * 60 * 60 * 1e3 + 15 * 60 * 1e3 + 20 * 1e3);
+    (0, import_vitest.expect)((0, import_formatTimeDiff.formatTimeDiff)(past)).toBe("3h 15m 20s");
+  });
+  (0, import_vitest.it)("formats differences containing only minutes and seconds", () => {
+    const past = new Date(7 * 60 * 1e3 + 45 * 1e3);
+    (0, import_vitest.expect)((0, import_formatTimeDiff.formatTimeDiff)(past)).toBe("7m 45s");
+  });
+});
+//# sourceMappingURL=formatTimeDiff.test.cjs.map

package/dist/cjs/utils/formatTimeDiff.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/formatTimeDiff.test.ts"],"sourcesContent":["import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';\nimport { formatTimeDiff } from './formatTimeDiff';\n\ndescribe('formatTimeDiff', () => {\n  const fixedNow = new Date('2025-01-01T00:00:00Z');\n\n  beforeEach(() => {\n    // Use fake timers so \"now\" is deterministic across tests\n    vi.useFakeTimers();\n    vi.setSystemTime(fixedNow);\n  });\n\n  afterEach(() => {\n    vi.useRealTimers();\n  });\n\n  it('formats differences containing days', () => {\n    // 2 days, 3 hours, 4 minutes, 5 seconds ago\n    const past = new Date(\n      2 * 24 * 60 * 60 * 1000 + // 2 days\n        3 * 60 * 60 * 1000 + // 3 hours\n        4 * 60 * 1000 + // 4 minutes\n        5 * 1000 // 5 seconds\n    );\n\n    expect(formatTimeDiff(past)).toBe('2d 3h 4m 5s');\n  });\n\n  it('formats differences containing hours but no days', () => {\n    // 3 hours, 15 minutes, 20 seconds ago\n    const past = new Date(3 * 60 * 60 * 1000 + 15 * 60 * 1000 + 20 * 1000);\n\n    expect(formatTimeDiff(past)).toBe('3h 15m 20s');\n  });\n\n  it('formats differences containing only minutes and seconds', () => {\n    // 7 minutes, 45 seconds ago\n    const past = new Date(7 * 60 * 1000 + 45 * 1000);\n\n    expect(formatTimeDiff(past)).toBe('7m 45s');\n  });\n});\n"],"mappings":";AAAA,oBAAgE;AAChE,4BAA+B;AAAA,IAE/B,wBAAS,kBAAkB,MAAM;AAC/B,QAAM,WAAW,oBAAI,KAAK,sBAAsB;AAEhD,gCAAW,MAAM;AAEf,qBAAG,cAAc;AACjB,qBAAG,cAAc,QAAQ;AAAA,EAC3B,CAAC;AAED,+BAAU,MAAM;AACd,qBAAG,cAAc;AAAA,EACnB,CAAC;AAED,wBAAG,uCAAuC,MAAM;AAE9C,UAAM,OAAO,IAAI;AAAA,MACf,IAAI,KAAK,KAAK,KAAK;AAAA,MACjB,IAAI,KAAK,KAAK;AAAA,MACd,IAAI,KAAK;AAAA,MACT,IAAI;AAAA;AAAA,IACR;AAEA,kCAAO,sCAAe,IAAI,CAAC,EAAE,KAAK,aAAa;AAAA,EACjD,CAAC;AAED,wBAAG,oDAAoD,MAAM;AAE3D,UAAM,OAAO,IAAI,KAAK,IAAI,KAAK,KAAK,MAAO,KAAK,KAAK,MAAO,KAAK,GAAI;AAErE,kCAAO,sCAAe,IAAI,CAAC,EAAE,KAAK,YAAY;AAAA,EAChD,CAAC;AAED,wBAAG,2DAA2D,MAAM;AAElE,UAAM,OAAO,IAAI,KAAK,IAAI,KAAK,MAAO,KAAK,GAAI;AAE/C,kCAAO,sCAAe,IAAI,CAAC,EAAE,KAAK,QAAQ;AAAA,EAC5C,CAAC;AACH,CAAC;","names":[]}

package/dist/cjs/utils/getChunk.cjs

@@ -0,0 +1,77 @@
+"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 getChunk_exports = {};
+__export(getChunk_exports, {
+  getChunk: () => getChunk
+});
+module.exports = __toCommonJS(getChunk_exports);
+var import_splitTextByLine = require('./splitTextByLine.cjs');
+const getChunk = (text, options = {}) => {
+  const { lineStart, lineLength, charStart, charLength } = options;
+  if (lineStart === void 0 && lineLength === void 0 && charStart === void 0 && charLength === void 0) {
+    return text;
+  }
+  const lines = (0, import_splitTextByLine.splitTextByLines)(text);
+  const getCharIndexOfLineStart = (lineNumber) => {
+    if (lineNumber <= 0) return 0;
+    let idx = 0;
+    for (let i = 0; i < Math.min(lineNumber, lines.length); i++) {
+      idx += lines[i].length;
+    }
+    return idx;
+  };
+  const getCharIndexOfLineEnd = (lineNumber) => {
+    if (lineNumber >= lines.length) {
+      return text.length;
+    }
+    const line = lines[lineNumber];
+    const lineEnd = getCharIndexOfLineStart(lineNumber) + line.length;
+    return lineEnd;
+  };
+  let effectiveStart = 0;
+  let effectiveEnd = text.length;
+  if (lineStart !== void 0) {
+    effectiveStart = Math.max(
+      effectiveStart,
+      getCharIndexOfLineStart(lineStart)
+    );
+  }
+  if (charStart !== void 0) {
+    effectiveStart = Math.max(effectiveStart, charStart);
+  }
+  if (lineLength !== void 0) {
+    const endLine = (lineStart ?? 0) + lineLength - 1;
+    effectiveEnd = Math.min(effectiveEnd, getCharIndexOfLineEnd(endLine));
+  }
+  if (charLength !== void 0) {
+    effectiveEnd = Math.min(
+      effectiveEnd,
+      (charStart ?? effectiveStart) + charLength
+    );
+  }
+  if (effectiveStart >= effectiveEnd) {
+    return "";
+  }
+  return text.slice(effectiveStart, effectiveEnd);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChunk
+});
+//# sourceMappingURL=getChunk.cjs.map

package/dist/cjs/utils/getChunk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/getChunk.ts"],"sourcesContent":["import { splitTextByLines } from './splitTextByLine';\n\ntype TrunkOptions = {\n  lineStart?: number;\n  lineLength?: number;\n  charStart?: number;\n  charLength?: number;\n};\n\nexport const getChunk = (text: string, options: TrunkOptions = {}): string => {\n  const { lineStart, lineLength, charStart, charLength } = options;\n\n  // Fast-path: if no filters were provided, return the whole text\n  if (\n    lineStart === undefined &&\n    lineLength === undefined &&\n    charStart === undefined &&\n    charLength === undefined\n  ) {\n    return text;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Utility helpers to convert between line numbers and absolute char indices\n  // ---------------------------------------------------------------------------\n  const lines = splitTextByLines(text);\n\n  const getCharIndexOfLineStart = (lineNumber: number): number => {\n    if (lineNumber <= 0) return 0;\n    // Sum the length of every previous line\n    let idx = 0;\n    for (let i = 0; i < Math.min(lineNumber, lines.length); i++) {\n      idx += lines[i].length;\n    }\n    return idx;\n  };\n\n  const getCharIndexOfLineEnd = (lineNumber: number): number => {\n    // If the requested line number exceeds the number of lines, clamp to the last character\n    if (lineNumber >= lines.length) {\n      return text.length;\n    }\n    const line = lines[lineNumber];\n    const lineEnd = getCharIndexOfLineStart(lineNumber) + line.length;\n\n    return lineEnd;\n  };\n\n  // ---------------------------------------------------------------------------\n  // Compute the effective (inclusive) charStart/charEnd for the requested slice\n  // ---------------------------------------------------------------------------\n  let effectiveStart = 0; // inclusive\n  let effectiveEnd = text.length; // exclusive\n\n  // Apply line boundaries if provided\n  if (lineStart !== undefined) {\n    effectiveStart = Math.max(\n      effectiveStart,\n      getCharIndexOfLineStart(lineStart)\n    );\n  }\n\n  // Apply character boundaries if provided\n  if (charStart !== undefined) {\n    effectiveStart = Math.max(effectiveStart, charStart);\n  }\n\n  // Apply line length boundary from lineStart (or 0)\n  if (lineLength !== undefined) {\n    const endLine = (lineStart ?? 0) + lineLength - 1;\n    effectiveEnd = Math.min(effectiveEnd, getCharIndexOfLineEnd(endLine));\n  }\n\n  // Apply character length boundary from effectiveStart\n  if (charLength !== undefined) {\n    effectiveEnd = Math.min(\n      effectiveEnd,\n      (charStart ?? effectiveStart) + charLength\n    );\n  }\n\n  // If bounds do not overlap, return empty string\n  if (effectiveStart >= effectiveEnd) {\n    return '';\n  }\n\n  return text.slice(effectiveStart, effectiveEnd);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAAiC;AAS1B,MAAM,WAAW,CAAC,MAAc,UAAwB,CAAC,MAAc;AAC5E,QAAM,EAAE,WAAW,YAAY,WAAW,WAAW,IAAI;AAGzD,MACE,cAAc,UACd,eAAe,UACf,cAAc,UACd,eAAe,QACf;AACA,WAAO;AAAA,EACT;AAKA,QAAM,YAAQ,yCAAiB,IAAI;AAEnC,QAAM,0BAA0B,CAAC,eAA+B;AAC9D,QAAI,cAAc,EAAG,QAAO;AAE5B,QAAI,MAAM;AACV,aAAS,IAAI,GAAG,IAAI,KAAK,IAAI,YAAY,MAAM,MAAM,GAAG,KAAK;AAC3D,aAAO,MAAM,CAAC,EAAE;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,wBAAwB,CAAC,eAA+B;AAE5D,QAAI,cAAc,MAAM,QAAQ;AAC9B,aAAO,KAAK;AAAA,IACd;AACA,UAAM,OAAO,MAAM,UAAU;AAC7B,UAAM,UAAU,wBAAwB,UAAU,IAAI,KAAK;AAE3D,WAAO;AAAA,EACT;AAKA,MAAI,iBAAiB;AACrB,MAAI,eAAe,KAAK;AAGxB,MAAI,cAAc,QAAW;AAC3B,qBAAiB,KAAK;AAAA,MACpB;AAAA,MACA,wBAAwB,SAAS;AAAA,IACnC;AAAA,EACF;AAGA,MAAI,cAAc,QAAW;AAC3B,qBAAiB,KAAK,IAAI,gBAAgB,SAAS;AAAA,EACrD;AAGA,MAAI,eAAe,QAAW;AAC5B,UAAM,WAAW,aAAa,KAAK,aAAa;AAChD,mBAAe,KAAK,IAAI,cAAc,sBAAsB,OAAO,CAAC;AAAA,EACtE;AAGA,MAAI,eAAe,QAAW;AAC5B,mBAAe,KAAK;AAAA,MAClB;AAAA,OACC,aAAa,kBAAkB;AAAA,IAClC;AAAA,EACF;AAGA,MAAI,kBAAkB,cAAc;AAClC,WAAO;AAAA,EACT;AAEA,SAAO,KAAK,MAAM,gBAAgB,YAAY;AAChD;","names":[]}

package/dist/cjs/utils/getChunk.test.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_getChunk = require('./getChunk.cjs');
+const sampleText = [
+  "Line 0: The quick brown fox jumps over the lazy dog.",
+  "Line 1: Pack my box with five dozen liquor jugs.",
+  "Line 2: How razorback-jumping frogs can level six piqued gymnasts!",
+  "Line 3: Cozy lummox gives smart squid who asks for job pen.",
+  "Line 4: A mad boxer shot a quick, gloved jab to the jaw of his dizzy opponent."
+].join("\n");
+(0, import_vitest.describe)("getChunk", () => {
+  (0, import_vitest.it)("returns the whole text when no filters are provided", () => {
+    const result = (0, import_getChunk.getChunk)(sampleText);
+    (0, import_vitest.expect)(result).toBe(sampleText);
+  });
+  (0, import_vitest.it)("applies lineStart and lineLength filters", () => {
+    const result = (0, import_getChunk.getChunk)(sampleText, { lineStart: 1, lineLength: 2 });
+    const expected = [
+      "Line 1: Pack my box with five dozen liquor jugs.\n",
+      "Line 2: How razorback-jumping frogs can level six piqued gymnasts!\n"
+    ].join("");
+    (0, import_vitest.expect)(result).toBe(expected);
+  });
+  (0, import_vitest.it)("applies charStart and charLength filters", () => {
+    const charStart = sampleText.indexOf("quick");
+    const charLength = "quick brown fox".length;
+    const result = (0, import_getChunk.getChunk)(sampleText, { charStart, charLength });
+    (0, import_vitest.expect)(result).toBe("quick brown fox");
+  });
+  (0, import_vitest.it)("combines line and char filters by intersecting their ranges", () => {
+    const partial = (0, import_getChunk.getChunk)(sampleText, {
+      lineStart: 0,
+      lineLength: 3,
+      // lines 0, 1, 2
+      // Grab only the first 10 characters of the selected block
+      charStart: 0,
+      charLength: 10
+    });
+    (0, import_vitest.expect)(partial).toBe("Line 0: Th");
+  });
+  (0, import_vitest.it)("returns an empty string when effectiveStart > effectiveEnd", () => {
+    const result = (0, import_getChunk.getChunk)(sampleText, { charStart: 10, charLength: 0 });
+    (0, import_vitest.expect)(result).toBe("");
+  });
+});
+//# sourceMappingURL=getChunk.test.cjs.map

package/dist/cjs/utils/getChunk.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/getChunk.test.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest';\n\nimport { getChunk } from './getChunk';\n\n// Sample multiline string used across test cases\nconst sampleText = [\n  'Line 0: The quick brown fox jumps over the lazy dog.',\n  'Line 1: Pack my box with five dozen liquor jugs.',\n  'Line 2: How razorback-jumping frogs can level six piqued gymnasts!',\n  'Line 3: Cozy lummox gives smart squid who asks for job pen.',\n  'Line 4: A mad boxer shot a quick, gloved jab to the jaw of his dizzy opponent.',\n].join('\\n');\n\ndescribe('getChunk', () => {\n  it('returns the whole text when no filters are provided', () => {\n    const result = getChunk(sampleText);\n    expect(result).toBe(sampleText);\n  });\n\n  it('applies lineStart and lineLength filters', () => {\n    const result = getChunk(sampleText, { lineStart: 1, lineLength: 2 });\n\n    // Expected substring is lines 1 and 2 plus the newline in-between\n    const expected = [\n      'Line 1: Pack my box with five dozen liquor jugs.\\n',\n      'Line 2: How razorback-jumping frogs can level six piqued gymnasts!\\n',\n    ].join('');\n\n    expect(result).toBe(expected);\n  });\n\n  it('applies charStart and charLength filters', () => {\n    // Grab substring \"quick brown fox\" from first line\n    const charStart = sampleText.indexOf('quick');\n    const charLength = 'quick brown fox'.length;\n\n    const result = getChunk(sampleText, { charStart, charLength });\n\n    expect(result).toBe('quick brown fox');\n  });\n\n  it('combines line and char filters by intersecting their ranges', () => {\n    // Restrict to lines 0-2, then further to characters within those lines\n    const partial = getChunk(sampleText, {\n      lineStart: 0,\n      lineLength: 3, // lines 0, 1, 2\n      // Grab only the first 10 characters of the selected block\n      charStart: 0,\n      charLength: 10,\n    });\n\n    expect(partial).toBe('Line 0: Th');\n  });\n\n  it('returns an empty string when effectiveStart > effectiveEnd', () => {\n    const result = getChunk(sampleText, { charStart: 10, charLength: 0 });\n    expect(result).toBe('');\n  });\n});\n"],"mappings":";AAAA,oBAAqC;AAErC,sBAAyB;AAGzB,MAAM,aAAa;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAAA,IAEX,wBAAS,YAAY,MAAM;AACzB,wBAAG,uDAAuD,MAAM;AAC9D,UAAM,aAAS,0BAAS,UAAU;AAClC,8BAAO,MAAM,EAAE,KAAK,UAAU;AAAA,EAChC,CAAC;AAED,wBAAG,4CAA4C,MAAM;AACnD,UAAM,aAAS,0BAAS,YAAY,EAAE,WAAW,GAAG,YAAY,EAAE,CAAC;AAGnE,UAAM,WAAW;AAAA,MACf;AAAA,MACA;AAAA,IACF,EAAE,KAAK,EAAE;AAET,8BAAO,MAAM,EAAE,KAAK,QAAQ;AAAA,EAC9B,CAAC;AAED,wBAAG,4CAA4C,MAAM;AAEnD,UAAM,YAAY,WAAW,QAAQ,OAAO;AAC5C,UAAM,aAAa,kBAAkB;AAErC,UAAM,aAAS,0BAAS,YAAY,EAAE,WAAW,WAAW,CAAC;AAE7D,8BAAO,MAAM,EAAE,KAAK,iBAAiB;AAAA,EACvC,CAAC;AAED,wBAAG,+DAA+D,MAAM;AAEtE,UAAM,cAAU,0BAAS,YAAY;AAAA,MACnC,WAAW;AAAA,MACX,YAAY;AAAA;AAAA;AAAA,MAEZ,WAAW;AAAA,MACX,YAAY;AAAA,IACd,CAAC;AAED,8BAAO,OAAO,EAAE,KAAK,YAAY;AAAA,EACnC,CAAC;AAED,wBAAG,8DAA8D,MAAM;AACrE,UAAM,aAAS,0BAAS,YAAY,EAAE,WAAW,IAAI,YAAY,EAAE,CAAC;AACpE,8BAAO,MAAM,EAAE,KAAK,EAAE;AAAA,EACxB,CAAC;AACH,CAAC;","names":[]}

package/dist/cjs/utils/getIsFileUpdatedRecently.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getIsFileUpdatedRecently_exports = {};
+__export(getIsFileUpdatedRecently_exports, {
+  getIsFileUpdatedRecently: () => getIsFileUpdatedRecently
+});
+module.exports = __toCommonJS(getIsFileUpdatedRecently_exports);
+var import_fs = require("fs");
+const SKIP_RANGE_OF_LAST_UPDATE_TIME = 0;
+const getIsFileUpdatedRecently = (localeFilePath) => {
+  const stats = (0, import_fs.statSync)(localeFilePath);
+  const lastModified = new Date(stats.mtime);
+  const threshold = new Date(Date.now() - SKIP_RANGE_OF_LAST_UPDATE_TIME);
+  return lastModified > threshold;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getIsFileUpdatedRecently
+});
+//# sourceMappingURL=getIsFileUpdatedRecently.cjs.map

package/dist/cjs/utils/getIsFileUpdatedRecently.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/getIsFileUpdatedRecently.ts"],"sourcesContent":["import { statSync } from 'fs';\n\nconst SKIP_RANGE_OF_LAST_UPDATE_TIME: number = 0; //2 * 60 * 60 * 1000; // 2 hours\n\n/**\n * Check if file was updated recently, to skip re-translation\n */\nexport const getIsFileUpdatedRecently = (localeFilePath: string): boolean => {\n  const stats = statSync(localeFilePath);\n  const lastModified = new Date(stats.mtime);\n  const threshold = new Date(Date.now() - SKIP_RANGE_OF_LAST_UPDATE_TIME);\n\n  return lastModified > threshold;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAyB;AAEzB,MAAM,iCAAyC;AAKxC,MAAM,2BAA2B,CAAC,mBAAoC;AAC3E,QAAM,YAAQ,oBAAS,cAAc;AACrC,QAAM,eAAe,IAAI,KAAK,MAAM,KAAK;AACzC,QAAM,YAAY,IAAI,KAAK,KAAK,IAAI,IAAI,8BAA8B;AAEtE,SAAO,eAAe;AACxB;","names":[]}