@treeviz/gedcom-parser 2.0.9 → 2.0.12

package/dist/classes/index.js

@@ -77,12 +77,33 @@ __export(translators_exports, {
   en: () => KinshipTranslatorEn,
   es: () => KinshipTranslatorEs,
   fr: () => KinshipTranslatorFr,
-  hu: () => KinshipTranslatorHU
+  hu: () => KinshipTranslatorHU,
+  ru: () => KinshipTranslatorRu
 });
 
 // src/constants/constants.ts
+var APP_BRANDING = "TreeViz - The Family Tree Visualiser & Editor";
 var ID_REG = /^@[_a-zA-Z0-9]+@/;
 var ID_GETTER_REG = /^(?<at>@)?(?<letter>[A-Z])?/i;
+var ORIG_HEAD_TAG = "_ORIGHEAD";
+
+// src/utils/gedcom-trailer.ts
+var TRAILER_LINE = /^0 TRLR\s*$/i;
+var GEDCOM_TRAILER_TAG = "TRLR";
+var isGedcomTrailerTag = (tag) => tag === GEDCOM_TRAILER_TAG;
+var isGedcomTrailerLine = (line) => TRAILER_LINE.test(line);
+var appendGedcomTrailer = (serialized) => {
+  const newline = serialized.includes("\r\n") ? "\r\n" : "\n";
+  const trimmed = serialized.replace(/(?:\r?\n)+$/, "");
+  if (!trimmed) {
+    return "0 TRLR";
+  }
+  const lastLine = trimmed.split(/\r?\n/).at(-1) ?? "";
+  if (isGedcomTrailerLine(lastLine)) {
+    return trimmed;
+  }
+  return `${trimmed}${newline}0 TRLR`;
+};
 var List = class _List {
   // length = 0;
   constructor(items) {
@@ -593,6 +614,9 @@ var Common = class _Common {
     delete this._value;
   }
   set(name, value) {
+    if (isGedcomTrailerTag(name)) {
+      return void 0;
+    }
     if (typeof value === "string") {
       const usedValue = createCommon(this._gedcom, void 0, this.main);
       usedValue.value = value;
@@ -603,6 +627,9 @@ var Common = class _Common {
     return get(this, name);
   }
   assign(name, value, unique = false) {
+    if (isGedcomTrailerTag(name)) {
+      return void 0;
+    }
     let curValue = this.get(name);
     if (curValue?.isListable) {
       if (curValue instanceof _Common) {
@@ -825,30 +852,47 @@ var Common = class _Common {
     });
     return gedcom;
   }
+  getHeadRecord() {
+    return get(this, "HEAD") || get(this.getGedcom(), "HEAD");
+  }
+  getOriginalHeadRecord() {
+    return get(this, ORIG_HEAD_TAG) || get(this.getGedcom(), ORIG_HEAD_TAG) || get(this.getHeadRecord(), ORIG_HEAD_TAG);
+  }
+  getSourceHeads() {
+    const heads = [this.getOriginalHeadRecord(), this.getHeadRecord()];
+    return heads.filter((head, index) => {
+      return Boolean(head && heads.indexOf(head) === index);
+    });
+  }
+  getFromSourceHeads(path) {
+    for (const head of this.getSourceHeads()) {
+      const value = get(head, path);
+      if (value !== void 0 && value !== null && value !== "") {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  sourStartsWith(prefix) {
+    return this.getSourceHeads().some((head) => {
+      const sour = get(head, "SOUR.value");
+      return !!sour?.toLowerCase()?.startsWith(prefix);
+    });
+  }
   isGenoPro() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("genopro");
+    return this.sourStartsWith("genopro");
   }
   isAhnenblatt() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("ahnenblatt");
+    return this.sourStartsWith("ahnenblatt");
   }
   isGeni() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("geni");
+    return this.sourStartsWith("geni");
   }
   isAncestry() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("ancestry");
+    return this.sourStartsWith("ancestry");
   }
   isMyHeritage() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("myheritage");
+    return this.sourStartsWith("myheritage");
   }
   /**
    * Get the source type as a string (for prefixing tree IDs and names)
@@ -865,22 +909,22 @@ var Common = class _Common {
     return void 0;
   }
   isFamilySearch() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sourName = get(head, "SOUR.NAME.value");
-    return sourName === "FamilySearch API";
+    return this.getSourceHeads().some((head) => {
+      const sourName = get(head, "SOUR.NAME.value");
+      return sourName === "FamilySearch API";
+    });
   }
   isGNO2GED() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return sour === "GNO2GED";
+    return this.getSourceHeads().some((head) => {
+      const sour = get(head, "SOUR.value");
+      return sour === "GNO2GED";
+    });
   }
   getAncestryTreeId() {
-    const path = "HEAD.SOUR._TREE.RIN.value";
-    return get(this, path) || get(this.getGedcom(), path);
+    return this.getFromSourceHeads("SOUR._TREE.RIN.value") || (get(this, "HEAD.SOUR._TREE.RIN.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.RIN.value"));
   }
   getMyHeritageTreeId() {
-    const path = "HEAD._EXPORTED_FROM_SITE_ID.value";
-    return get(this, path) || get(this.getGedcom(), path);
+    return this.getFromSourceHeads("_EXPORTED_FROM_SITE_ID.value") || (get(this, "HEAD._EXPORTED_FROM_SITE_ID.value") || get(this.getGedcom(), "HEAD._EXPORTED_FROM_SITE_ID.value"));
   }
   getTreeId() {
     if (this?.isAncestry()) {
@@ -914,8 +958,7 @@ var Common = class _Common {
     return this.getUniversalTreeId();
   }
   getAncestryTreeName() {
-    const path = "HEAD.SOUR._TREE.value";
-    return get(this, path) || get(this.getGedcom(), path);
+    return this.getFromSourceHeads("SOUR._TREE.value") || (get(this, "HEAD.SOUR._TREE.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.value"));
   }
   getMyHeritageTreeName() {
     const path = "HEAD.FILE.value";
@@ -925,14 +968,14 @@ var Common = class _Common {
     )?.groups?.tree;
   }
   getFamilySearchTreeId() {
-    const rin = get(this, "HEAD.SOUR._TREE.RIN.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.RIN.value");
+    const rin = this.getFromSourceHeads("SOUR._TREE.RIN.value") || get(this, "HEAD.SOUR._TREE.RIN.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.RIN.value");
     if (rin) {
       return rin;
     }
     return "familysearch";
   }
   getFamilySearchTreeName() {
-    const treeName = get(this, "HEAD.SOUR._TREE.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.value");
+    const treeName = this.getFromSourceHeads("SOUR._TREE.value") || get(this, "HEAD.SOUR._TREE.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.value");
     if (treeName) {
       return treeName;
     }
@@ -1024,11 +1067,11 @@ var Common = class _Common {
       const cleanName = fileName.replace(/\.ged$/i, "").replace(/_/g, " ");
       return `${prefix}${cleanName}`;
     }
-    const sourName = get(this, "HEAD.SOUR.NAME.value") || get(this.getGedcom(), "HEAD.SOUR.NAME.value");
+    const sourName = this.getFromSourceHeads("SOUR.NAME.value") || get(this, "HEAD.SOUR.NAME.value") || get(this.getGedcom(), "HEAD.SOUR.NAME.value");
     if (sourName) {
       return `${prefix}${sourName}`;
     }
-    const sourValue = get(this, "HEAD.SOUR.value") || get(this.getGedcom(), "HEAD.SOUR.value");
+    const sourValue = this.getFromSourceHeads("SOUR.value") || get(this, "HEAD.SOUR.value") || get(this.getGedcom(), "HEAD.SOUR.value");
     if (sourValue) {
       return `${prefix}${sourValue}`;
     }
@@ -1094,7 +1137,7 @@ var isOnlyMainProp = (key) => {
 };
 var isValidKey = (common, key) => {
   const prop = get(common, key);
-  return key !== "_gedcom" && key !== "_main" && key !== "_parent" && key !== "_uniqueId" && key !== "_refs" && key !== "_type" && (key === "id" || key === "_id" || key === "value" || key === "_value" || prop instanceof Common || prop instanceof List);
+  return key !== "_gedcom" && key !== "_main" && key !== "_parent" && key !== "_uniqueId" && key !== "_refs" && key !== "_type" && !(typeof key === "string" && isGedcomTrailerTag(key)) && (key === "id" || key === "_id" || key === "value" || key === "_value" || prop instanceof Common || prop instanceof List);
 };
 var getValidKeys = (common) => {
   return Object.keys(common).filter((key) => {
@@ -2574,6 +2617,249 @@ var KinshipTranslatorEs = class extends KinshipTranslatorBasic {
   }
 };
 
+// src/kinship-translator/patterns.ru.ts
+var InLawsRu = {
+  "\u0441\u0443\u043F\u0440\u0443\u0433(?:\u0430)? (\u0440\u0435\u0431\u0451\u043D\u043A\u0430|\u0434\u043E\u0447\u0435\u0440\u0438|\u0441\u044B\u043D\u0430)": "\u0437\u044F\u0442\u044C/\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "\u0436\u0435\u043D\u0430 (\u0440\u0435\u0431\u0451\u043D\u043A\u0430|\u0434\u043E\u0447\u0435\u0440\u0438|\u0441\u044B\u043D\u0430)": "\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "\u043C\u0443\u0436 (\u0440\u0435\u0431\u0451\u043D\u043A\u0430|\u0434\u043E\u0447\u0435\u0440\u0438|\u0441\u044B\u043D\u0430)": "\u0437\u044F\u0442\u044C",
+  "\u043C\u0430\u0442\u044C (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0442\u0451\u0449\u0430",
+  "\u043E\u0442\u0435\u0446 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0442\u0435\u0441\u0442\u044C",
+  "\u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044C (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0442\u0435\u0441\u0442\u044C/\u0442\u0451\u0449\u0430",
+  "\u0436\u0435\u043D\u0430 (\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?(\u0431\u0440\u0430\u0442\u0430|\u0441\u0435\u0441\u0442\u0440\u044B|\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430)": "\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "\u043C\u0443\u0436 (\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?(\u0431\u0440\u0430\u0442\u0430|\u0441\u0435\u0441\u0442\u0440\u044B|\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430)": "\u0437\u044F\u0442\u044C",
+  "\u0441\u0443\u043F\u0440\u0443\u0433(?:\u0430)? (\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?(\u0431\u0440\u0430\u0442\u0430|\u0441\u0435\u0441\u0442\u0440\u044B|\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430)": "\u0437\u044F\u0442\u044C/\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "(\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?\u0441\u0435\u0441\u0442\u0440\u0430 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0437\u043E\u043B\u043E\u0432\u043A\u0430",
+  "(\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?\u0431\u0440\u0430\u0442 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0448\u0443\u0440\u0438\u043D",
+  "(\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?\u0441\u0438\u0431\u043B\u0438\u043D\u0433 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0448\u0443\u0440\u0438\u043D/\u0437\u043E\u043B\u043E\u0432\u043A\u0430"
+};
+
+// src/kinship-translator/kinship-translator.ru.ts
+var GENITIVE = {
+  \u0441\u044B\u043D: "\u0441\u044B\u043D\u0430",
+  \u0434\u043E\u0447\u044C: "\u0434\u043E\u0447\u0435\u0440\u0438",
+  \u0440\u0435\u0431\u0451\u043D\u043E\u043A: "\u0440\u0435\u0431\u0451\u043D\u043A\u0430",
+  \u0431\u0440\u0430\u0442: "\u0431\u0440\u0430\u0442\u0430",
+  \u0441\u0435\u0441\u0442\u0440\u0430: "\u0441\u0435\u0441\u0442\u0440\u044B",
+  \u0441\u0438\u0431\u043B\u0438\u043D\u0433: "\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430",
+  \u043E\u0442\u0435\u0446: "\u043E\u0442\u0446\u0430",
+  \u043C\u0430\u0442\u044C: "\u043C\u0430\u0442\u0435\u0440\u0438",
+  \u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044C: "\u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044F",
+  \u043C\u0443\u0436: "\u043C\u0443\u0436\u0430",
+  \u0436\u0435\u043D\u0430: "\u0436\u0435\u043D\u044B",
+  \u0441\u0443\u043F\u0440\u0443\u0433: "\u0441\u0443\u043F\u0440\u0443\u0433\u0430",
+  \u0441\u0443\u043F\u0440\u0443\u0433\u0430: "\u0441\u0443\u043F\u0440\u0443\u0433\u0438"
+};
+var toGenitive = (word) => GENITIVE[word] ?? word;
+var cousinWord = (degree, sex) => {
+  const stem = degree <= 1 ? "\u0434\u0432\u043E\u044E\u0440\u043E\u0434\u043D" : degree === 2 ? "\u0442\u0440\u043E\u044E\u0440\u043E\u0434\u043D" : degree === 3 ? "\u0447\u0435\u0442\u0432\u0435\u0440\u043E\u044E\u0440\u043E\u0434\u043D" : `${degree + 1}-\u044E\u0440\u043E\u0434\u043D`;
+  if (sex === "m") {
+    return `${stem}\u044B\u0439 \u0431\u0440\u0430\u0442`;
+  }
+  if (sex === "f") {
+    return `${stem}\u0430\u044F \u0441\u0435\u0441\u0442\u0440\u0430`;
+  }
+  return `${stem}\u044B\u0439 \u0431\u0440\u0430\u0442/\u0441\u0435\u0441\u0442\u0440\u0430`;
+};
+var praRepeat = (count) => count > 0 ? "\u043F\u0440\u0430".repeat(count) : "";
+var sexOf = (person) => {
+  if (person?.isMale?.()) {
+    return "m";
+  }
+  if (person?.isFemale?.()) {
+    return "f";
+  }
+  return "n";
+};
+var KinshipTranslatorRu = class extends KinshipTranslatorBasic {
+  indirect() {
+    let degree = Math.abs(this.pathN?.degree ?? 0);
+    if (degree > 0) {
+      degree = degree - 1;
+    }
+    return cousinWord(degree, sexOf(this.personN));
+  }
+  removal() {
+    const level = this.pathN?.level ?? 0;
+    let degree = Math.abs(this.pathN?.degree ?? 0);
+    if (degree > 0) {
+      degree = degree - 1;
+    }
+    if (!degree) {
+      return level < 0 ? this.nibling() : this.auncle();
+    }
+    const removed = Math.abs(level);
+    return `${cousinWord(degree, sexOf(this.personN))} (${removed}\xD7 \u0447\u0435\u0440\u0435\u0437 \u043F\u043E\u043A\u043E\u043B\u0435\u043D\u0438\u0435)`;
+  }
+  auncle() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const pra = praRepeat(Math.max(0, level - 2));
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return `${pra}\u0434\u044F\u0434\u044F`;
+    }
+    if (sex === "f") {
+      return `${pra}\u0442\u0451\u0442\u044F`;
+    }
+    return `${pra}\u0434\u044F\u0434\u044F/\u0442\u0451\u0442\u044F`;
+  }
+  nibling() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const pra = praRepeat(Math.max(0, level - 2));
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return `${pra}\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u043A`;
+    }
+    if (sex === "f") {
+      return `${pra}\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u0446\u0430`;
+    }
+    return `${pra}\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u043A/\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u0446\u0430`;
+  }
+  parent() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const sex = sexOf(this.personN);
+    if (level <= 1) {
+      if (sex === "m") {
+        return "\u043E\u0442\u0435\u0446";
+      }
+      if (sex === "f") {
+        return "\u043C\u0430\u0442\u044C";
+      }
+      return "\u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044C";
+    }
+    if (level === 2) {
+      if (sex === "m") {
+        return "\u0434\u0435\u0434";
+      }
+      if (sex === "f") {
+        return "\u0431\u0430\u0431\u0443\u0448\u043A\u0430";
+      }
+      return "\u0434\u0435\u0434/\u0431\u0430\u0431\u0443\u0448\u043A\u0430";
+    }
+    const pra = praRepeat(level - 2);
+    if (sex === "m") {
+      return `${pra}\u0434\u0435\u0434`;
+    }
+    if (sex === "f") {
+      return `${pra}\u0431\u0430\u0431\u0443\u0448\u043A\u0430`;
+    }
+    return `${pra}\u0434\u0435\u0434/\u0431\u0430\u0431\u0443\u0448\u043A\u0430`;
+  }
+  child() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const sex = sexOf(this.personN);
+    if (level <= 1) {
+      if (sex === "m") {
+        return "\u0441\u044B\u043D";
+      }
+      if (sex === "f") {
+        return "\u0434\u043E\u0447\u044C";
+      }
+      return "\u0440\u0435\u0431\u0451\u043D\u043E\u043A";
+    }
+    if (level === 2) {
+      if (sex === "m") {
+        return "\u0432\u043D\u0443\u043A";
+      }
+      if (sex === "f") {
+        return "\u0432\u043D\u0443\u0447\u043A\u0430";
+      }
+      return "\u0432\u043D\u0443\u043A/\u0432\u043D\u0443\u0447\u043A\u0430";
+    }
+    const pra = praRepeat(level - 2);
+    if (sex === "m") {
+      return `${pra}\u0432\u043D\u0443\u043A`;
+    }
+    if (sex === "f") {
+      return `${pra}\u0432\u043D\u0443\u0447\u043A\u0430`;
+    }
+    return `${pra}\u0432\u043D\u0443\u043A/\u0432\u043D\u0443\u0447\u043A\u0430`;
+  }
+  sibling() {
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return "\u0431\u0440\u0430\u0442";
+    }
+    if (sex === "f") {
+      return "\u0441\u0435\u0441\u0442\u0440\u0430";
+    }
+    return "\u0441\u0438\u0431\u043B\u0438\u043D\u0433";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    if (/сестра|дочь|мать|тётя|бабушка|жена|племянница|внучка/.test(
+      relation
+    )) {
+      return `\u0441\u0432\u043E\u0434\u043D\u0430\u044F ${relation}`;
+    }
+    return `\u0441\u0432\u043E\u0434\u043D\u044B\u0439 ${relation}`;
+  }
+  spouse() {
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return "\u043C\u0443\u0436";
+    }
+    if (sex === "f") {
+      return "\u0436\u0435\u043D\u0430";
+    }
+    return "\u0441\u0443\u043F\u0440\u0443\u0433";
+  }
+  ofSpouse(relation) {
+    if (!relation) {
+      return "";
+    }
+    const spouse = this.path?.[1].indi;
+    const sex = sexOf(spouse);
+    const spouseType = sex === "m" ? "\u043C\u0443\u0436" : sex === "f" ? "\u0436\u0435\u043D\u0430" : "\u0441\u0443\u043F\u0440\u0443\u0433";
+    return `${relation} ${toGenitive(spouseType)}`;
+  }
+  spouseOf(relation) {
+    if (!relation) {
+      return "";
+    }
+    const spouse = this.path?.[this.path.length - 1].indi;
+    const sex = sexOf(spouse);
+    const spouseType = sex === "m" ? "\u043C\u0443\u0436" : sex === "f" ? "\u0436\u0435\u043D\u0430" : "\u0441\u0443\u043F\u0440\u0443\u0433";
+    return `${spouseType} ${toGenitive(relation)}`;
+  }
+  of(relation) {
+    const formattedName = nameFormatter(this.path?.[0]?.indi, {
+      nameOrder: "first-last"
+    });
+    let name = formattedName.inOrder.filter(Boolean).join(" ");
+    if (this.displayName === "none") {
+      name = "";
+    } else if (this.displayName === "givenname") {
+      name = formattedName.givenname;
+    } else if (this.displayName === "surname") {
+      name = `${formattedName.surname}`;
+    }
+    if (!name || !relation) {
+      return relation ?? "";
+    }
+    return `${name}: ${relation}`;
+  }
+  inLaw(relation) {
+    let inLawRelation = relation;
+    Object.keys(InLawsRu).find((pattern) => {
+      const regex = new RegExp(`^${pattern}$`);
+      if (relation?.match(regex)) {
+        inLawRelation = InLawsRu[pattern];
+        return true;
+      }
+      return false;
+    });
+    return inLawRelation ?? "";
+  }
+  relationType(relation) {
+    if (!relation || !this.pathN?.relation) {
+      return relation ?? "";
+    }
+    return `${this.pathN.relation} ${relation}`;
+  }
+};
+
 // src/kinship-translator/kinship-translator.ts
 var KinshipTranslator = class {
   constructor(person1, person2, lang = "en", entirePath, displayName = "givenname") {
@@ -3566,6 +3852,250 @@ var cacheDiscoveredPath = (gedcom, path) => {
   }
 };
 
+// src/utils/fact-edit.ts
+var SINGLETON_TAGS = /* @__PURE__ */ new Set(["BIRT", "DEAT", "SSN", "SEX", "DSCR"]);
+var firstRecord = (node) => {
+  if (!node) {
+    return void 0;
+  }
+  if (node instanceof List) {
+    return node.index(0);
+  }
+  return node.index(0) ?? node;
+};
+var setDateOn = (gedcom, owner, parent, date) => {
+  const trimmed = date.trim();
+  if (!trimmed) {
+    return;
+  }
+  let dateNode = parent.get("DATE");
+  if (!dateNode || dateNode instanceof List) {
+    dateNode = createCommonDate(gedcom, void 0, owner, parent);
+    dateNode.type = "DATE";
+    parent.set("DATE", dateNode);
+  }
+  dateNode.value = trimmed;
+};
+var fillFact = (gedcom, owner, event, input) => {
+  if (input.value?.trim()) {
+    event.value = input.value.trim();
+  }
+  if (input.type?.trim()) {
+    event.set("TYPE", input.type.trim());
+  }
+  if (input.date) {
+    setDateOn(gedcom, owner, event, input.date);
+  }
+  if (input.place?.trim()) {
+    event.set("PLAC", input.place.trim());
+  }
+  if (input.note?.trim()) {
+    event.set("NOTE", input.note.trim());
+  }
+};
+var addIndividualFact = (indi, input) => {
+  const gedcom = indi.getGedcom();
+  if (!gedcom) {
+    return void 0;
+  }
+  const tag = input.tag;
+  let event = SINGLETON_TAGS.has(tag) ? firstRecord(indi.get(tag)) : void 0;
+  if (!event) {
+    event = createCommon(gedcom, void 0, indi);
+    event.type = tag;
+    if (SINGLETON_TAGS.has(tag)) {
+      indi.set(tag, event);
+    } else {
+      indi.assign(tag, event);
+    }
+  }
+  fillFact(gedcom, indi, event, input);
+  return event;
+};
+var addFamilyFact = (fam, input) => {
+  const gedcom = fam.getGedcom();
+  if (!gedcom) {
+    return void 0;
+  }
+  const event = createCommon(gedcom, void 0, fam);
+  event.type = input.tag;
+  fam.assign(input.tag, event);
+  fillFact(gedcom, fam, event, input);
+  return event;
+};
+
+// src/utils/family-edit.ts
+var PEDIGREE_VALUES = [
+  "birth" /* BIRTH */,
+  "adopted" /* ADOPTED */,
+  "foster" /* FOSTER */,
+  "step" /* STEP */,
+  "sealing" /* SEALING */
+];
+var toGedcomPedigree = (value) => {
+  const normalized = String(value || "birth" /* BIRTH */).toLowerCase();
+  if (normalized === "biological" /* BIOLOGICAL */ || normalized === "birth" /* BIRTH */) {
+    return "birth" /* BIRTH */;
+  }
+  const match = PEDIGREE_VALUES.find((item) => item === normalized);
+  return match ?? "birth" /* BIRTH */;
+};
+var pointerIds = (tag) => {
+  if (!tag) {
+    return [];
+  }
+  if (tag instanceof List) {
+    return tag.values().map((item) => item?.toValue?.()).filter((value2) => !!value2);
+  }
+  const value = tag.toValue?.();
+  return value ? [String(value)] : [];
+};
+var firstPointerId = (tag) => pointerIds(tag)[0];
+var makePointer = (gedcom, parent, value, refType) => {
+  const pointer = createCommon(gedcom, void 0, parent);
+  pointer.value = value;
+  pointer.refType = refType;
+  return pointer;
+};
+var nextRecordId = (ids, prefix) => {
+  let max = 0;
+  ids.forEach((id) => {
+    const match = String(id).match(/(\d+)/);
+    const n = match ? Number.parseInt(match[1], 10) : 0;
+    if (n > max) {
+      max = n;
+    }
+  });
+  return `@${prefix}${max + 1}@`;
+};
+var familyHasParent = (fam, indiId) => pointerIds(fam.get("HUSB")).includes(indiId) || pointerIds(fam.get("WIFE")).includes(indiId);
+var familyHasChild = (fam, indiId) => pointerIds(fam.get("CHIL")).includes(indiId);
+var spouseTagFor = (indi, fam) => {
+  const husbId = firstPointerId(fam.get("HUSB"));
+  const wifeId = firstPointerId(fam.get("WIFE"));
+  if (husbId === indi.id) {
+    return "HUSB";
+  }
+  if (wifeId === indi.id) {
+    return "WIFE";
+  }
+  if (indi.isFemale()) {
+    return wifeId && wifeId !== indi.id ? "HUSB" : "WIFE";
+  }
+  if (indi.isMale()) {
+    return husbId && husbId !== indi.id ? "WIFE" : "HUSB";
+  }
+  return husbId ? "WIFE" : "HUSB";
+};
+var canAttachAsSpouse = (fam, indi) => {
+  if (!indi.id) {
+    return false;
+  }
+  if (familyHasParent(fam, indi.id)) {
+    return true;
+  }
+  const tag = spouseTagFor(indi, fam);
+  const occupied = firstPointerId(fam.get(tag));
+  return !occupied || occupied === indi.id;
+};
+var pointerByValue = (tag, id) => {
+  if (!tag) {
+    return void 0;
+  }
+  const fromValues = tag.toValueList?.().item(id);
+  if (fromValues) {
+    return fromValues;
+  }
+  return tag.toList()?.values().find((item) => item?.toValue?.() === id);
+};
+var setChildPedigree = (fam, child, pedigree, parent) => {
+  if (!fam.id || !child.id) {
+    return;
+  }
+  const pedi = toGedcomPedigree(pedigree);
+  const famc = pointerByValue(child.get("FAMC"), fam.id);
+  if (famc) {
+    famc.set("PEDI", pedi);
+  }
+  const chil = pointerByValue(fam.get("CHIL"), child.id);
+  if (!chil) {
+    return;
+  }
+  const setFather = !parent || parent.isMale() || parent.isUnknownSex();
+  const setMother = !parent || parent.isFemale() || parent.isUnknownSex();
+  if (setFather) {
+    chil.set("_FREL", pedi);
+  }
+  if (setMother) {
+    chil.set("_MREL", pedi);
+  }
+};
+var attachSpouseToFamily = (fam, indi) => {
+  const gedcom = fam.getGedcom() ?? indi.getGedcom();
+  if (!indi.id || !fam.id || !gedcom) {
+    return false;
+  }
+  if (!canAttachAsSpouse(fam, indi)) {
+    return false;
+  }
+  const tag = spouseTagFor(indi, fam);
+  if (firstPointerId(fam.get(tag)) !== indi.id) {
+    fam.set(tag, makePointer(gedcom, fam, indi.id, "INDI"));
+  }
+  indi.assign("FAMS", makePointer(gedcom, indi, fam.id, "FAM"), true);
+  return true;
+};
+var attachChildToFamily = (fam, child, pedigree, parent) => {
+  const gedcom = fam.getGedcom() ?? child.getGedcom();
+  if (!child.id || !fam.id || !gedcom) {
+    return false;
+  }
+  if (!familyHasChild(fam, child.id)) {
+    fam.assign("CHIL", makePointer(gedcom, fam, child.id, "INDI"), true);
+  }
+  const existingFamc = pointerByValue(child.get("FAMC"), fam.id);
+  if (!existingFamc) {
+    child.assign("FAMC", makePointer(gedcom, child, fam.id, "FAM"), true);
+  }
+  setChildPedigree(fam, child, pedigree, parent);
+  return true;
+};
+var findReusableParentChildFamily = (parent, child) => {
+  if (!parent.id || !child.id) {
+    return void 0;
+  }
+  let reusableFamc;
+  let already = false;
+  child.getFamilies("FAMC")?.forEach((fam) => {
+    if (!fam) {
+      return;
+    }
+    if (familyHasParent(fam, parent.id) && familyHasChild(fam, child.id)) {
+      already = true;
+      return;
+    }
+    if (!reusableFamc && canAttachAsSpouse(fam, parent)) {
+      reusableFamc = fam;
+    }
+  });
+  if (already) {
+    return "already";
+  }
+  if (reusableFamc) {
+    return reusableFamc;
+  }
+  const parentFams = [];
+  parent.getFamilies("FAMS")?.forEach((fam) => {
+    if (fam) {
+      parentFams.push(fam);
+    }
+  });
+  if (parentFams.length === 1) {
+    return parentFams[0];
+  }
+  return void 0;
+};
+
 // src/utils/get-places.ts
 var getPlaces = (common, type = ["ALL" /* All */], maxLevel = 1, level = 0, mainKey) => {
   const types = Array.isArray(type) ? type : [type];
@@ -4196,6 +4726,31 @@ var Fam = class extends Common {
   getParents() {
     return this.getHusband().copy().merge(this.getWife());
   }
+  hasParent(indi) {
+    const indiId = typeof indi === "string" ? indi : indi?.id;
+    return !!indiId && familyHasParent(this, indiId);
+  }
+  hasChild(indi) {
+    const indiId = typeof indi === "string" ? indi : indi?.id;
+    return !!indiId && familyHasChild(this, indiId);
+  }
+  canAddSpouse(indi) {
+    return canAttachAsSpouse(this, indi);
+  }
+  addSpouse(indi) {
+    return attachSpouseToFamily(this, indi);
+  }
+  addChild(child, pedigree, parent) {
+    return attachChildToFamily(
+      this,
+      child,
+      pedigree,
+      parent
+    );
+  }
+  addFact(input) {
+    return addFamilyFact(this, input);
+  }
   toList() {
     return new Families().concat(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -4268,19 +4823,51 @@ var ALLOWED_FACTS = [
   "OCCU",
   "OCCUPATIONS",
   "RESI",
+  "BIRT",
+  "DEAT",
   "BAPT",
+  "BAPM",
   "CHRI",
   "CHR",
+  "CHRA",
   "BURI",
-  "EDUC",
+  "CREM",
+  "ADOP",
+  "BARM",
+  "BASM",
+  "BLES",
+  "CONF",
+  "FCOM",
+  "ORDN",
+  "NATU",
+  "EMIG",
+  "IMMI",
+  "CENS",
+  "PROB",
+  "WILL",
   "GRAD",
+  "RETI",
+  "EDUC",
   "DIV",
-  "IMMI",
   "RELI",
+  "CAST",
+  "DSCR",
+  "NATI",
+  "PROP",
+  "SSN",
+  "TITL",
+  "ADDR",
+  "BAPL",
+  "CONL",
+  "ENDL",
+  "SLGC",
   "_MILT",
   "_MILTID",
   "FACT",
-  "_ORIG"
+  "_ORIG",
+  "_WLNK",
+  "WWW",
+  "URL"
 ];
 var DISALLOWED_CUSTOM_FACTS = ["DNA Test", "Newspaper"];
 var CustomFactRenderers = {
@@ -4824,7 +5411,7 @@ var Indi = class extends Common {
     return result;
   }
   ancestryLink() {
-    const www = this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
+    const www = this.getFromSourceHeads("SOUR.CORP.WWW.value") || this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
     const tree = this.getAncestryTreeId();
     if (this.id) {
       return `https://${www}/family-tree/person/tree/${tree}/person/${this.id.replace(
@@ -4836,7 +5423,7 @@ var Indi = class extends Common {
   async ancestryMedia(namespace) {
     const list = {};
     const objeList = this.get("OBJE")?.toList().copy();
-    const www = this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
+    const www = this.getFromSourceHeads("SOUR.CORP.WWW.value") || this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
     const tree = this.getAncestryTreeId();
     if (objeList) {
       await Promise.all(
@@ -4896,7 +5483,7 @@ var Indi = class extends Common {
     return list;
   }
   myheritageLink(poolId = 0) {
-    const www = this._gedcom?.HEAD?.SOUR?.CORP?.value?.toLowerCase().replace(/^www\./gi, "");
+    const www = (this.getFromSourceHeads("SOUR.CORP.value") || this._gedcom?.HEAD?.SOUR?.CORP?.value)?.toLowerCase().replace(/^www\./gi, "");
     const site = this.getMyHeritageTreeId();
     const file = this._gedcom?.HEAD?.get("FILE")?.toValue()?.match(/Exported by MyHeritage.com from .+ in (?<site>.+) on .+$/)?.groups?.site;
     const normalizedFile = file?.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-");
@@ -5417,6 +6004,57 @@ var Indi = class extends Common {
   isUnknownSex() {
     return !this.isMale() && !this.isFemale();
   }
+  addSpouse(other) {
+    if (!this.id || !other?.id || this.id === other.id || !this._gedcom) {
+      return void 0;
+    }
+    const existing = getFamilyWith(this, other.id);
+    if (existing) {
+      return existing;
+    }
+    const fam = this._gedcom.createFamily();
+    if (!fam.addSpouse(this) || !fam.addSpouse(other)) {
+      return void 0;
+    }
+    return fam;
+  }
+  addChild(child, pedigree) {
+    if (!this.id || !child?.id || this.id === child.id || !this._gedcom) {
+      return void 0;
+    }
+    const existing = findReusableParentChildFamily(
+      this,
+      child
+    );
+    if (existing === "already") {
+      const fam2 = child.getFamilies("FAMC")?.find(
+        (item) => !!item && item.hasParent(this.id) && item.hasChild(child.id)
+      );
+      if (fam2) {
+        setChildPedigree(
+          fam2,
+          child,
+          pedigree,
+          this
+        );
+      }
+      return fam2;
+    }
+    const fam = existing ?? this._gedcom.createFamily();
+    if (!fam.addSpouse(this)) {
+      return void 0;
+    }
+    if (!fam.addChild(child, pedigree, this)) {
+      return void 0;
+    }
+    return fam;
+  }
+  addParent(parent, pedigree) {
+    return parent.addChild(this, pedigree);
+  }
+  addFact(input) {
+    return addIndividualFact(this, input);
+  }
   getParentType(id) {
     let indi;
     if (typeof id === "string" || typeof id === "number") {
@@ -5617,7 +6255,9 @@ var Indi = class extends Common {
           }
         }
         if (kinship !== "child" || !breakAfterSpouse) {
-          indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(indi.getFathers().copy().merge(indi.getMothers())).forEach((relative) => {
+          indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(
+            indi.getFathers().copy().merge(indi.getMothers())
+          ).forEach((relative) => {
             if (!visited.has(relative)) {
               const currentRelation = indi.getParentType(relative);
               const isNonBiological = !!currentRelation && currentRelation !== "biological" /* BIOLOGICAL */;
@@ -6518,7 +7158,7 @@ var createIndi = (gedcom, id, main, parent) => {
 
 // package.json
 var package_default = {
-  version: "2.0.9"};
+  version: "2.0.12"};
 
 // src/utils/get-product-details.ts
 var getVersion = () => package_default.version;
@@ -6718,6 +7358,44 @@ var GedCom = class extends Common {
   fams() {
     return this.getList("@@FAM");
   }
+  nextIndiKey() {
+    const ids = [];
+    this.indis()?.forEach((_indi, id) => {
+      ids.push(String(id));
+    });
+    return nextRecordId(ids, "I");
+  }
+  nextFamKey() {
+    const ids = [];
+    this.fams()?.forEach((_fam, id) => {
+      ids.push(String(id));
+    });
+    return nextRecordId(ids, "F");
+  }
+  createIndividual() {
+    const existing = this.indis();
+    const indis = existing ?? new Individuals();
+    if (!existing) {
+      this.set("@@INDI", indis);
+    }
+    const id = this.nextIndiKey();
+    const indi = createIndi(this, id);
+    indi.type = "INDI";
+    indis.item(id, indi);
+    return indi;
+  }
+  createFamily() {
+    const existing = this.fams();
+    const fams = existing ?? new Families();
+    if (!existing) {
+      this.set("@@FAM", fams);
+    }
+    const id = this.nextFamKey();
+    const fam = createFam(this, id);
+    fam.type = "FAM";
+    fams.item(id, fam);
+    return fam;
+  }
   objes() {
     return this.getList("@@OBJE");
   }
@@ -6805,15 +7483,24 @@ var GedCom = class extends Common {
   getDownloadHeader() {
     const newHead = createCommon();
     Object.assign(newHead, this.get("HEAD") ?? {});
+    const existingSour = this.get("HEAD")?.get("SOUR");
+    const existingTreeName = existingSour?.get("_TREE")?.toValue();
+    const existingTreeUniqueId = existingSour?.get("_TID")?.toValue();
     const newSour = createCommon();
-    newSour.set("CORP", createCommon());
-    newSour.set("CORP.WWW", createCommon());
-    newSour.set("NAME", createCommon());
-    newSour.set("VERS", createCommon());
-    newSour.CORP.value = "TreeViz - The Family Tree Visualiser";
-    newSour.CORP.WWW.value = "treeviz.com";
-    newSour.NAME.value = "TreeViz - The Family Tree Visualiser";
-    newSour.VERS.value = getVersion();
+    newSour.value = APP_BRANDING;
+    newSour.set("NAME", APP_BRANDING);
+    newSour.set("VERS", getVersion());
+    if (typeof existingTreeName === "string" && existingTreeName.trim()) {
+      newSour.set("_TREE", existingTreeName.trim());
+    }
+    if (typeof existingTreeUniqueId === "string" && existingTreeUniqueId.trim()) {
+      newSour.set("_TID", existingTreeUniqueId.trim());
+    }
+    const corp = createCommon();
+    corp.value = APP_BRANDING;
+    corp.set("WWW", "treeviz.com");
+    corp.set("EMAIL", "info@treeviz.com");
+    newSour.set("CORP", corp);
     newHead.set("SOUR", newSour);
     return newHead;
   }
@@ -6842,15 +7529,17 @@ var GedCom = class extends Common {
   }
   toGedcom(tag, level, options) {
     if (options?.super) {
-      return super.toGedcom(tag, level, options);
+      return appendGedcomTrailer(
+        super.toGedcom(tag, level, options)
+      );
     }
     const newGedcom = createGedCom();
+    Object.assign(newGedcom, this);
     if (!options?.original) {
       Object.assign(newGedcom, {
         HEAD: this.getDownloadHeader()
       });
     }
-    Object.assign(newGedcom, this);
     if (options?.indis?.length) {
       const newContent = this.getIndiRelatedLists(options.indis);
       Object.assign(newGedcom, newContent);