@gitwand/core 1.6.0

package/dist/resolvers/json.js

@@ -0,0 +1,363 @@
+/**
+ * GitWand — Résolveur JSON/JSONC sémantique
+ *
+ * Résout les conflits dans les fichiers JSON et JSONC en parsant
+ * les trois versions (base, ours, theirs) et en effectuant une
+ * fusion au niveau des clés plutôt que des lignes.
+ *
+ * Stratégie :
+ *  1. Tenter de parser les trois versions comme JSON (strip de commentaires JSONC)
+ *  2. Calculer les deltas clé-par-clé (récursif sur les objets)
+ *  3. Si tous les conflits de clés sont trivialement résolvables → merge
+ *  4. Sinon → retourner null (fallback textuel dans resolver.ts)
+ *
+ * Cas gérés :
+ *  - Clé ajoutée des deux côtés avec valeurs différentes → conflit non résolvable
+ *  - Clé ajoutée d'un seul côté → accepter l'ajout
+ *  - Clé supprimée d'un seul côté, pas modifiée de l'autre → supprimer
+ *  - Clé modifiée des deux côtés de la même façon → prendre la valeur
+ *  - Clé modifiée des deux côtés différemment → conflit non résolvable
+ *  - Merge récursif pour les objets imbriqués
+ */
+// ─── Strip JSONC comments ─────────────────────────────────
+/**
+ * Supprime les commentaires // et /* *\/ d'un fichier JSONC.
+ * Assez robuste pour les cas courants (config files).
+ */
+export function stripJsoncComments(text) {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    let stringChar = "";
+    while (i < text.length) {
+        const ch = text[i];
+        const next = text[i + 1];
+        // Gestion des chaînes de caractères
+        if (inString) {
+            if (ch === "\\" && i + 1 < text.length) {
+                result += ch + next;
+                i += 2;
+                continue;
+            }
+            if (ch === stringChar) {
+                inString = false;
+            }
+            result += ch;
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            stringChar = ch;
+            result += ch;
+            i++;
+            continue;
+        }
+        // Commentaire ligne // ...
+        if (ch === "/" && next === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            continue;
+        }
+        // Commentaire bloc /* ... */
+        if (ch === "/" && next === "*") {
+            i += 2;
+            while (i < text.length - 1 && !(text[i] === "*" && text[i + 1] === "/")) {
+                i++;
+            }
+            i += 2; // sauter */
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}
+/**
+ * Vérifie si une valeur est un objet JSON (et pas null, ni tableau).
+ */
+function isObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Vérifie si deux valeurs JSON sont profondément égales.
+ */
+function jsonEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => jsonEqual(v, b[i]));
+    }
+    if (isObject(a) && isObject(b)) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((k) => k in b && jsonEqual(a[k], b[k]));
+    }
+    return false;
+}
+/**
+ * Fusionne récursivement deux objets JSON avec une base commune.
+ *
+ * Retourne `{ merged, resolvedKeys, unresolvedKeys }`.
+ * Si `merged === null`, au moins un conflit est non résolvable.
+ */
+function mergeObjects(base, ours, theirs) {
+    const result = {};
+    let resolvedKeys = 0;
+    let unresolvedKeys = 0;
+    // Ensemble de toutes les clés présentes dans au moins une version
+    const allKeys = new Set([
+        ...Object.keys(base),
+        ...Object.keys(ours),
+        ...Object.keys(theirs),
+    ]);
+    for (const key of allKeys) {
+        const inBase = key in base;
+        const inOurs = key in ours;
+        const inTheirs = key in theirs;
+        const baseVal = base[key];
+        const oursVal = ours[key];
+        const theirsVal = theirs[key];
+        // Clé présente dans les deux branches, absente de la base → ajout des deux côtés
+        if (!inBase && inOurs && inTheirs) {
+            if (jsonEqual(oursVal, theirsVal)) {
+                // Même valeur ajoutée des deux côtés → same_change
+                result[key] = oursVal;
+                resolvedKeys++;
+            }
+            else if (isObject(oursVal) && isObject(theirsVal)) {
+                // Objets ajoutés différemment → fusion récursive depuis base vide
+                const sub = mergeObjects({}, oursVal, theirsVal);
+                if (sub.merged !== null) {
+                    result[key] = sub.merged;
+                    resolvedKeys += sub.resolvedKeys + 1;
+                    unresolvedKeys += sub.unresolvedKeys;
+                }
+                else {
+                    unresolvedKeys++;
+                    return { merged: null, resolvedKeys, unresolvedKeys };
+                }
+            }
+            else {
+                // Valeurs scalaires différentes → conflit non résolvable
+                unresolvedKeys++;
+                return { merged: null, resolvedKeys, unresolvedKeys };
+            }
+            continue;
+        }
+        // Clé dans base + ours, absent de theirs → theirs a supprimé
+        if (inBase && inOurs && !inTheirs) {
+            if (jsonEqual(baseVal, oursVal)) {
+                // Ours n'a pas changé, theirs a supprimé → supprimer
+                resolvedKeys++;
+                // Ne pas ajouter à result (suppression)
+            }
+            else {
+                // Ours a modifié, theirs a supprimé → conflit
+                unresolvedKeys++;
+                return { merged: null, resolvedKeys, unresolvedKeys };
+            }
+            continue;
+        }
+        // Clé dans base + theirs, absent de ours → ours a supprimé
+        if (inBase && !inOurs && inTheirs) {
+            if (jsonEqual(baseVal, theirsVal)) {
+                // Theirs n'a pas changé, ours a supprimé → supprimer
+                resolvedKeys++;
+                // Ne pas ajouter à result
+            }
+            else {
+                // Theirs a modifié, ours a supprimé → conflit
+                unresolvedKeys++;
+                return { merged: null, resolvedKeys, unresolvedKeys };
+            }
+            continue;
+        }
+        // Clé dans base seulement → supprimée des deux côtés
+        if (inBase && !inOurs && !inTheirs) {
+            resolvedKeys++;
+            // Ne pas ajouter à result
+            continue;
+        }
+        // Clé dans ours seulement (ajout ours)
+        if (!inBase && inOurs && !inTheirs) {
+            result[key] = oursVal;
+            resolvedKeys++;
+            continue;
+        }
+        // Clé dans theirs seulement (ajout theirs)
+        if (!inBase && !inOurs && inTheirs) {
+            result[key] = theirsVal;
+            resolvedKeys++;
+            continue;
+        }
+        // Clé présente partout → modifier éventuelle
+        if (inBase && inOurs && inTheirs) {
+            const oursChanged = !jsonEqual(baseVal, oursVal);
+            const theirsChanged = !jsonEqual(baseVal, theirsVal);
+            if (!oursChanged && !theirsChanged) {
+                // Aucun côté n'a changé → garder base
+                result[key] = baseVal;
+                resolvedKeys++;
+            }
+            else if (oursChanged && !theirsChanged) {
+                // Seul ours a changé → accepter ours
+                result[key] = oursVal;
+                resolvedKeys++;
+            }
+            else if (!oursChanged && theirsChanged) {
+                // Seul theirs a changé → accepter theirs
+                result[key] = theirsVal;
+                resolvedKeys++;
+            }
+            else if (jsonEqual(oursVal, theirsVal)) {
+                // Les deux ont fait la même modif → same_change
+                result[key] = oursVal;
+                resolvedKeys++;
+            }
+            else if (isObject(oursVal) && isObject(theirsVal) && isObject(baseVal)) {
+                // Les deux ont modifié des objets → fusion récursive
+                const sub = mergeObjects(baseVal, oursVal, theirsVal);
+                if (sub.merged !== null) {
+                    result[key] = sub.merged;
+                    resolvedKeys += sub.resolvedKeys + 1;
+                    unresolvedKeys += sub.unresolvedKeys;
+                }
+                else {
+                    unresolvedKeys++;
+                    return { merged: null, resolvedKeys, unresolvedKeys };
+                }
+            }
+            else {
+                // Scalaires modifiés différemment → conflit non résolvable
+                unresolvedKeys++;
+                return { merged: null, resolvedKeys, unresolvedKeys };
+            }
+        }
+    }
+    return { merged: result, resolvedKeys, unresolvedKeys };
+}
+// ─── Indentation detection ────────────────────────────────
+/**
+ * Détecte le style d'indentation d'un fichier JSON (espaces ou tab).
+ * Retourne le string d'indentation utilisé (ex: "  ", "    ", "\t").
+ */
+function detectIndentation(jsonText) {
+    const lines = jsonText.split("\n");
+    for (const line of lines) {
+        const match = line.match(/^(\t+|\s+)/);
+        if (match) {
+            const indent = match[1];
+            if (indent.includes("\t"))
+                return "\t";
+            return indent.length;
+        }
+    }
+    return 2; // défaut
+}
+// ─── Public API ───────────────────────────────────────────
+/**
+ * Tente de résoudre un conflit JSON en fusionnant sémantiquement
+ * les trois versions.
+ *
+ * @param baseLines  - Lignes de la version base
+ * @param oursLines  - Lignes de la version ours
+ * @param theirsLines - Lignes de la version theirs
+ * @returns `JsonMergeResult` avec `merged !== null` si résolu, `null` sinon
+ */
+export function tryResolveJsonConflict(baseLines, oursLines, theirsLines) {
+    const baseText = baseLines.join("\n");
+    const oursText = oursLines.join("\n");
+    const theirsText = theirsLines.join("\n");
+    // Tenter de parser les trois versions
+    let baseJson;
+    let oursJson;
+    let theirsJson;
+    try {
+        baseJson = JSON.parse(stripJsoncComments(baseText) || "{}");
+    }
+    catch {
+        // Base peut être vide (conflict sans diff3)
+        baseJson = {};
+    }
+    try {
+        oursJson = JSON.parse(stripJsoncComments(oursText));
+    }
+    catch (e) {
+        return {
+            merged: null,
+            reason: `Impossible de parser ours comme JSON : ${e instanceof Error ? e.message : String(e)}`,
+            resolvedKeys: 0,
+            unresolvedKeys: 1,
+        };
+    }
+    try {
+        theirsJson = JSON.parse(stripJsoncComments(theirsText));
+    }
+    catch (e) {
+        return {
+            merged: null,
+            reason: `Impossible de parser theirs comme JSON : ${e instanceof Error ? e.message : String(e)}`,
+            resolvedKeys: 0,
+            unresolvedKeys: 1,
+        };
+    }
+    // Cas : les deux versions ne sont pas des objets (tableau, scalaire…)
+    if (!isObject(oursJson) || !isObject(theirsJson)) {
+        // Pour les tableaux ou scalaires, on peut tenter un merge basique
+        if (Array.isArray(oursJson) && Array.isArray(theirsJson)) {
+            // Pour l'instant, pas de merge sémantique des tableaux — fallback textuel
+            return {
+                merged: null,
+                reason: "Fusion sémantique de tableaux JSON non supportée (fallback textuel).",
+                resolvedKeys: 0,
+                unresolvedKeys: 1,
+            };
+        }
+        if (jsonEqual(oursJson, theirsJson)) {
+            // Même valeur scalaire des deux côtés
+            const indent = detectIndentation(oursText);
+            return {
+                merged: JSON.stringify(oursJson, null, indent),
+                reason: "Même valeur JSON des deux côtés — résolution triviale.",
+                resolvedKeys: 1,
+                unresolvedKeys: 0,
+            };
+        }
+        return {
+            merged: null,
+            reason: "Valeurs JSON scalaires différentes — fallback textuel.",
+            resolvedKeys: 0,
+            unresolvedKeys: 1,
+        };
+    }
+    const baseObj = isObject(baseJson) ? baseJson : {};
+    // Fusion sémantique
+    const { merged, resolvedKeys, unresolvedKeys } = mergeObjects(baseObj, oursJson, theirsJson);
+    if (merged === null) {
+        return {
+            merged: null,
+            reason: `Fusion JSON impossible : ${unresolvedKeys} clé(s) en conflit non résolvable.`,
+            resolvedKeys,
+            unresolvedKeys,
+        };
+    }
+    // Reformater le JSON en préservant le style d'indentation de ours
+    const indent = detectIndentation(oursText);
+    const mergedText = JSON.stringify(merged, null, indent);
+    return {
+        merged: mergedText,
+        reason: `Fusion JSON sémantique réussie : ${resolvedKeys} clé(s) fusionnée(s), ${unresolvedKeys} conflit(s).`,
+        resolvedKeys,
+        unresolvedKeys,
+    };
+}
+//# sourceMappingURL=json.js.map

package/dist/resolvers/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/resolvers/json.ts"],"names":[],"mappings":"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"}

package/dist/resolvers/lockfile-npm.d.ts

@@ -0,0 +1,38 @@
+/**
+ * GitWand — Résolveur sémantique pour package-lock.json (npm)
+ *
+ * Au lieu de traiter package-lock.json comme un fichier opaque (→ theirs),
+ * ce résolveur comprend la structure : chaque entrée dans "packages" ou
+ * "dependencies" est un nœud indépendant.
+ *
+ * Stratégie :
+ *  1. Parser les trois versions (base, ours, theirs) en maps de dépendances
+ *  2. Merge 3-way par clé (path de package) :
+ *     - Ajouté d'un seul côté → prendre l'ajout
+ *     - Supprimé d'un seul côté (pas modifié de l'autre) → supprimer
+ *     - Modifié d'un seul côté → prendre la modification
+ *     - Modifié des deux côtés avec même résultat → ok
+ *     - Modifié des deux côtés avec résultat différent → conflit (prefer-theirs par défaut)
+ *  3. Reconstruire le JSON avec l'indentation d'origine
+ *
+ * Limitations :
+ *  - Ne valide pas la cohérence sémantique (ranges vs resolved)
+ *  - Après merge, un `npm install` reste recommandé
+ */
+export interface LockfileMergeResult {
+    /** Contenu JSON fusionné ou null si échec */
+    merged: string | null;
+    /** Raison de la résolution */
+    reason: string;
+    /** Nombre de paquets fusionnés */
+    resolvedPackages: number;
+    /** Nombre de conflits de versions */
+    versionConflicts: number;
+    /** Paquets en conflit (versions incompatibles) */
+    conflictedPackages: string[];
+}
+/**
+ * Fusionne trois versions d'un package-lock.json par entrée de paquet.
+ */
+export declare function tryResolveLockfileNpmConflict(baseLines: string[], oursLines: string[], theirsLines: string[]): LockfileMergeResult;
+//# sourceMappingURL=lockfile-npm.d.ts.map

package/dist/resolvers/lockfile-npm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockfile-npm.d.ts","sourceRoot":"","sources":["../../src/resolvers/lockfile-npm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,MAAM,WAAW,mBAAmB;IAClC,6CAA6C;IAC7C,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,qCAAqC;IACrC,gBAAgB,EAAE,MAAM,CAAC;IACzB,kDAAkD;IAClD,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAoDD;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,EAAE,EACnB,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,EAAE,MAAM,EAAE,GACpB,mBAAmB,CAsJrB"}

package/dist/resolvers/lockfile-npm.js

@@ -0,0 +1,267 @@
+/**
+ * GitWand — Résolveur sémantique pour package-lock.json (npm)
+ *
+ * Au lieu de traiter package-lock.json comme un fichier opaque (→ theirs),
+ * ce résolveur comprend la structure : chaque entrée dans "packages" ou
+ * "dependencies" est un nœud indépendant.
+ *
+ * Stratégie :
+ *  1. Parser les trois versions (base, ours, theirs) en maps de dépendances
+ *  2. Merge 3-way par clé (path de package) :
+ *     - Ajouté d'un seul côté → prendre l'ajout
+ *     - Supprimé d'un seul côté (pas modifié de l'autre) → supprimer
+ *     - Modifié d'un seul côté → prendre la modification
+ *     - Modifié des deux côtés avec même résultat → ok
+ *     - Modifié des deux côtés avec résultat différent → conflit (prefer-theirs par défaut)
+ *  3. Reconstruire le JSON avec l'indentation d'origine
+ *
+ * Limitations :
+ *  - Ne valide pas la cohérence sémantique (ranges vs resolved)
+ *  - Après merge, un `npm install` reste recommandé
+ */
+// ─── Parser simplifié ────────────────────────────────────
+/**
+ * Extrait les entrées du lockfile v2/v3 (clé "packages") ou v1 ("dependencies").
+ * Retourne une Map<path, jsonStr> pour chaque entrée.
+ */
+function parseLockfileEntries(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    // Détecter l'indentation
+    const indentMatch = json.match(/\n(\s+)"/);
+    const indent = indentMatch ? indentMatch[1] : "  ";
+    const packages = new Map();
+    let format = "v1";
+    if (parsed.packages && typeof parsed.packages === "object") {
+        format = parsed.lockfileVersion === 3 ? "v3" : "v2";
+        for (const [key, value] of Object.entries(parsed.packages)) {
+            packages.set(key, JSON.stringify(value));
+        }
+    }
+    else if (parsed.dependencies && typeof parsed.dependencies === "object") {
+        for (const [key, value] of Object.entries(parsed.dependencies)) {
+            packages.set(key, JSON.stringify(value));
+        }
+    }
+    // Header = tout sauf packages/dependencies
+    const header = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (key !== "packages" && key !== "dependencies") {
+            header[key] = value;
+        }
+    }
+    return { header, packages, format, indent };
+}
+// ─── 3-way merge ─────────────────────────────────────────
+/**
+ * Fusionne trois versions d'un package-lock.json par entrée de paquet.
+ */
+export function tryResolveLockfileNpmConflict(baseLines, oursLines, theirsLines) {
+    const baseText = baseLines.join("\n");
+    const oursText = oursLines.join("\n");
+    const theirsText = theirsLines.join("\n");
+    const baseParsed = parseLockfileEntries(baseText);
+    const oursParsed = parseLockfileEntries(oursText);
+    const theirsParsed = parseLockfileEntries(theirsText);
+    if (!baseParsed || !oursParsed || !theirsParsed) {
+        return {
+            merged: null,
+            reason: "Impossible de parser une des versions du package-lock.json.",
+            resolvedPackages: 0,
+            versionConflicts: 0,
+            conflictedPackages: [],
+        };
+    }
+    const basePkgs = baseParsed.packages;
+    const oursPkgs = oursParsed.packages;
+    const theirsPkgs = theirsParsed.packages;
+    // Toutes les clés
+    const allKeys = new Set([...basePkgs.keys(), ...oursPkgs.keys(), ...theirsPkgs.keys()]);
+    const mergedPkgs = new Map();
+    let resolvedPackages = 0;
+    let versionConflicts = 0;
+    const conflictedPackages = [];
+    for (const key of allKeys) {
+        const base = basePkgs.get(key);
+        const ours = oursPkgs.get(key);
+        const theirs = theirsPkgs.get(key);
+        // Pas dans base → ajout(s)
+        if (base === undefined) {
+            if (ours !== undefined && theirs !== undefined) {
+                if (ours === theirs) {
+                    // Même ajout
+                    mergedPkgs.set(key, ours);
+                    resolvedPackages++;
+                }
+                else {
+                    // Ajout différent des deux côtés → merge de version (prefer theirs)
+                    mergedPkgs.set(key, theirs);
+                    resolvedPackages++;
+                }
+            }
+            else if (ours !== undefined) {
+                mergedPkgs.set(key, ours);
+                resolvedPackages++;
+            }
+            else if (theirs !== undefined) {
+                mergedPkgs.set(key, theirs);
+                resolvedPackages++;
+            }
+            continue;
+        }
+        // Dans base mais supprimé d'un côté
+        if (ours === undefined && theirs === undefined) {
+            // Supprimé des deux côtés → supprimer
+            resolvedPackages++;
+            continue;
+        }
+        if (ours === undefined) {
+            // Ours supprimé
+            if (theirs === base) {
+                // Theirs pas modifié → supprimer (ours gagne)
+                resolvedPackages++;
+            }
+            else {
+                // Theirs modifié, ours supprimé → garder theirs (il a été mis à jour)
+                mergedPkgs.set(key, theirs);
+                resolvedPackages++;
+            }
+            continue;
+        }
+        if (theirs === undefined) {
+            // Theirs supprimé
+            if (ours === base) {
+                // Ours pas modifié → supprimer (theirs gagne)
+                resolvedPackages++;
+            }
+            else {
+                // Ours modifié, theirs supprimé → garder ours
+                mergedPkgs.set(key, ours);
+                resolvedPackages++;
+            }
+            continue;
+        }
+        // Présent partout — comparer
+        const oursChanged = ours !== base;
+        const theirsChanged = theirs !== base;
+        if (!oursChanged && !theirsChanged) {
+            mergedPkgs.set(key, base);
+            resolvedPackages++;
+        }
+        else if (!oursChanged) {
+            mergedPkgs.set(key, theirs);
+            resolvedPackages++;
+        }
+        else if (!theirsChanged) {
+            mergedPkgs.set(key, ours);
+            resolvedPackages++;
+        }
+        else if (ours === theirs) {
+            mergedPkgs.set(key, ours);
+            resolvedPackages++;
+        }
+        else {
+            // Vrai conflit de version → merge au niveau des propriétés
+            const merged = mergePackageEntry(base, ours, theirs);
+            if (merged !== null) {
+                mergedPkgs.set(key, merged);
+                resolvedPackages++;
+            }
+            else {
+                // Fallback : prefer theirs
+                mergedPkgs.set(key, theirs);
+                versionConflicts++;
+                conflictedPackages.push(key);
+            }
+        }
+    }
+    // Reconstruire le JSON
+    const indent = oursParsed.indent;
+    const header = { ...oursParsed.header };
+    const pkgKey = oursParsed.format === "v1" ? "dependencies" : "packages";
+    // Trier les clés comme npm le fait (alphabétique)
+    const sortedEntries = {};
+    const sortedKeys = [...mergedPkgs.keys()].sort();
+    for (const key of sortedKeys) {
+        try {
+            sortedEntries[key] = JSON.parse(mergedPkgs.get(key));
+        }
+        catch {
+            sortedEntries[key] = mergedPkgs.get(key);
+        }
+    }
+    const result = { ...header, [pkgKey]: sortedEntries };
+    const merged = JSON.stringify(result, null, indent.length) + "\n";
+    const reason = versionConflicts > 0
+        ? `Fusion sémantique lockfile : ${resolvedPackages} paquet(s) fusionné(s), ${versionConflicts} conflit(s) de version résolu(s) (prefer-theirs).`
+        : `Fusion sémantique lockfile réussie : ${resolvedPackages} paquet(s) fusionné(s) sans conflit.`;
+    return {
+        merged,
+        reason,
+        resolvedPackages,
+        versionConflicts,
+        conflictedPackages,
+    };
+}
+// ─── Merge de propriétés d'un paquet ─────────────────────
+/**
+ * Fusionne deux versions différentes d'une entrée de paquet au niveau propriété.
+ * Permet de résoudre les cas où ours met à jour `version` et theirs met à jour `integrity`.
+ */
+function mergePackageEntry(baseJson, oursJson, theirsJson) {
+    let base;
+    let ours;
+    let theirs;
+    try {
+        base = JSON.parse(baseJson);
+        ours = JSON.parse(oursJson);
+        theirs = JSON.parse(theirsJson);
+    }
+    catch {
+        return null;
+    }
+    if (typeof base !== "object" || typeof ours !== "object" || typeof theirs !== "object") {
+        return null;
+    }
+    const allProps = new Set([
+        ...Object.keys(base),
+        ...Object.keys(ours),
+        ...Object.keys(theirs),
+    ]);
+    const merged = {};
+    for (const prop of allProps) {
+        const baseVal = JSON.stringify(base[prop]);
+        const oursVal = JSON.stringify(ours[prop]);
+        const theirsVal = JSON.stringify(theirs[prop]);
+        const oursChanged = oursVal !== baseVal;
+        const theirsChanged = theirsVal !== baseVal;
+        if (!oursChanged && !theirsChanged) {
+            if (base[prop] !== undefined)
+                merged[prop] = base[prop];
+        }
+        else if (!oursChanged) {
+            if (theirs[prop] !== undefined)
+                merged[prop] = theirs[prop];
+        }
+        else if (!theirsChanged) {
+            if (ours[prop] !== undefined)
+                merged[prop] = ours[prop];
+        }
+        else if (oursVal === theirsVal) {
+            if (ours[prop] !== undefined)
+                merged[prop] = ours[prop];
+        }
+        else {
+            // Vrai conflit sur cette propriété → prefer theirs
+            if (theirs[prop] !== undefined)
+                merged[prop] = theirs[prop];
+        }
+    }
+    return JSON.stringify(merged);
+}
+//# sourceMappingURL=lockfile-npm.js.map