@treeviz/gedcom-parser 2.0.10 → 2.0.12

package/dist/utils/index.js

@@ -292,11 +292,31 @@ var cacheDiscoveredPath = (gedcom, path) => {
 };
 
 // src/constants/constants.ts
+var APP_BRANDING = "TreeViz - The Family Tree Visualiser & Editor";
 var REF_LINE_REG = /^0 (?:(@[_a-zA-Z0-9]*@) )?(?<type>_[_A-Z][_a-zA-Z]{2,}|_?[A-Z][a-zA-Z]{2,}) ?(?<value>.*)/gm;
 var LINE_REG = /(?<indent>^[0-9]) (?:(@[_a-zA-Z0-9]*@) )?(?<type>_[_A-Z][_a-zA-Z]{2,}|_?[A-Z][a-zA-Z]{2,}) ?(?<value>.*)/;
 var ID_REG = /^@[_a-zA-Z0-9]+@/;
 var ID_GETTER_REG = /^(?<at>@)?(?<letter>[A-Z])?/i;
+var ORIG_HEAD_TAG = "_ORIGHEAD";
 var MAX_FILE_SIZE_TO_SYNC = 1024 * 1024 * 20;
+
+// 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) {
@@ -807,6 +827,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;
@@ -817,6 +840,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) {
@@ -1039,30 +1065,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)
@@ -1079,22 +1122,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()) {
@@ -1128,8 +1171,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";
@@ -1139,14 +1181,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;
     }
@@ -1238,11 +1280,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}`;
     }
@@ -1308,7 +1350,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) => {
@@ -1802,6 +1844,334 @@ var dateFormatter = (indi, showMarriages = false, showDays = false, showPlaces =
   };
 };
 
+// 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 updateFactRecord = (owner, event, input) => {
+  const gedcom = owner.getGedcom();
+  if (!gedcom) {
+    return event;
+  }
+  const asOwner = owner;
+  if (input.value !== void 0) {
+    const trimmed = input.value.trim();
+    if (trimmed) {
+      event.value = trimmed;
+    } else {
+      event.removeValue();
+    }
+  }
+  if (input.type !== void 0) {
+    const trimmed = input.type.trim();
+    if (trimmed) {
+      event.set("TYPE", trimmed);
+    } else {
+      event.remove("TYPE");
+    }
+  }
+  if (input.date !== void 0) {
+    const trimmed = input.date.trim();
+    if (trimmed) {
+      setDateOn(gedcom, asOwner, event, trimmed);
+    } else {
+      event.remove("DATE");
+    }
+  }
+  if (input.place !== void 0) {
+    const trimmed = input.place.trim();
+    if (trimmed) {
+      event.set("PLAC", trimmed);
+    } else {
+      event.remove("PLAC");
+    }
+  }
+  if (input.note !== void 0) {
+    const trimmed = input.note.trim();
+    if (trimmed) {
+      event.set("NOTE", trimmed);
+    } else {
+      event.remove("NOTE");
+    }
+  }
+  return event;
+};
+var setFamilyMarriage = (fam, input) => {
+  const existing = firstRecord(fam.get("MARR"));
+  if (existing) {
+    return updateFactRecord(fam, existing, {
+      date: input.date,
+      place: input.place
+    });
+  }
+  return addFamilyFact(fam, {
+    tag: "MARR",
+    date: input.date,
+    place: input.place
+  });
+};
+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;
+};
+var setCauseOfDeath = (indi, text) => {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const death = firstRecord(indi.get("DEAT")) || addIndividualFact(indi, { tag: "DEAT", value: "Y" });
+  if (!death) {
+    return void 0;
+  }
+  death.set("CAUS", trimmed);
+  return death;
+};
+var setDeceased = (indi, deceased) => {
+  if (!deceased) {
+    indi.remove("DEAT");
+    return;
+  }
+  if (firstRecord(indi.get("DEAT"))) {
+    return;
+  }
+  addIndividualFact(indi, { tag: "DEAT", value: "Y" });
+};
+
+// 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 PlaceType = /* @__PURE__ */ ((PlaceType2) => {
   PlaceType2["All"] = "ALL";
@@ -2445,6 +2815,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
@@ -2550,19 +2945,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 = {
@@ -3106,7 +3533,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(
@@ -3118,7 +3545,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(
@@ -3178,7 +3605,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, "-");
@@ -3699,6 +4126,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") {
@@ -3899,7 +4377,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 */;
@@ -6998,7 +7478,7 @@ var isCommonDate = (value) => {
 // package.json
 var package_default = {
   name: "@treeviz/gedcom-parser",
-  version: "2.0.10"};
+  version: "2.0.12"};
 
 // src/utils/get-product-details.ts
 var isDevelopment = () => {
@@ -7202,6 +7682,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");
   }
@@ -7289,15 +7807,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;
   }
@@ -7326,15 +7853,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);
@@ -7864,9 +8393,7 @@ var GedcomTree = {
     }, {}) : {};
     const links = new Individuals();
     const tags = [];
-    let lines = `${content.replace(/\n0 TRLR(\r?\n)*$/, "")}
-0 TRLR
-`.split(/\r?\n/).reduce((acc, line) => {
+    let lines = content.split(/\r?\n/).reduce((acc, line) => {
       const lineMatch = line.match(LINE_REG);
       if (lineMatch) {
         const lineIndent = Number(lineMatch?.groups?.indent ?? 0);
@@ -7879,6 +8406,13 @@ var GedcomTree = {
           linesAcc._hasFile = false;
           return acc;
         }
+        if (lineIndent === 0 && lineType === "TRLR") {
+          if (linesAcc._inHead && filename && !linesAcc._hasFile) {
+            acc.push(`1 FILE ${filename}`);
+          }
+          linesAcc._inHead = false;
+          return acc;
+        }
         if (lineIndent === 0 && linesAcc._inHead) {
           if (filename && !linesAcc._hasFile) {
             acc.push(`1 FILE ${filename}`);
@@ -7933,8 +8467,9 @@ var GedcomTree = {
       ).replace(/0\s(@[^@]+@)(\sSOUR[^\n]*\n)([123456789]\s.+\n)*/, "").replace(/0 HEAD(.*)\n/, "0 HEAD$1\n1 _IS_PURGED true\n");
       lines = linesJoined.split("\n");
     }
+    lines = lines.filter((line) => !isGedcomTrailerLine(line));
     lines.forEach((line, index) => {
-      if (line.length === 0) {
+      if (line.length === 0 || isGedcomTrailerLine(line)) {
         return;
       }
       const match = reg.exec(line);
@@ -8071,5 +8606,20 @@ if (isDev) {
   globalThis.GedcomTree = GedcomTree;
 }
 var parser_default = GedcomTree;
+var createEmptyGedcom = (options) => {
+  const { gedcom } = GedcomTree.parse(
+    `0 HEAD
+1 GEDC
+2 VERS 5.5.1
+2 FORM LINEAGE-LINKED
+1 CHAR UTF-8
+0 TRLR`,
+    { filename: options?.filename }
+  );
+  if (!gedcom) {
+    throw new Error("Failed to create empty GEDCOM");
+  }
+  return gedcom;
+};
 
-export { ACCEPTED_DATE_FORMATS, ACCEPTED_DATE_FORMATS_REGEX, parser_default as GedcomTree, PlaceType, cacheDiscoveredPath, commonDateFormatter, create, dateFormatter, extractSeparationYears, extractSplitPoints, findMatchingRangeForSplitRange, fromTuple, generateSplitRanges, getAllProp, getFamilyWith, getFileExtension, getName, getPlaceParts, getPlaces, getRawSize, getVersion, hungarianOrdinalize, implemented, inRange, initializeCache, isDevelopment, isImageFormat, isIntersectedRange, isRangeContained, marriageDateFormatter, nameFormatter, notImplemented, noteDateFormatter, ordinalize, parseRangeBounds, pathCache, placeTranslator, profilePictureCache, relativesCache, resetRelativesCache, setNestedGroup, splitOverlappingRanges, splitRange };
+export { ACCEPTED_DATE_FORMATS, ACCEPTED_DATE_FORMATS_REGEX, GEDCOM_TRAILER_TAG, parser_default as GedcomTree, PEDIGREE_VALUES, PlaceType, addFamilyFact, addIndividualFact, appendGedcomTrailer, attachChildToFamily, attachSpouseToFamily, cacheDiscoveredPath, canAttachAsSpouse, commonDateFormatter, create, createEmptyGedcom, dateFormatter, extractSeparationYears, extractSplitPoints, familyHasChild, familyHasParent, findMatchingRangeForSplitRange, findReusableParentChildFamily, firstPointerId, fromTuple, generateSplitRanges, getAllProp, getFamilyWith, getFileExtension, getName, getPlaceParts, getPlaces, getRawSize, getVersion, hungarianOrdinalize, implemented, inRange, initializeCache, isDevelopment, isGedcomTrailerLine, isGedcomTrailerTag, isImageFormat, isIntersectedRange, isRangeContained, makePointer, marriageDateFormatter, nameFormatter, nextRecordId, notImplemented, noteDateFormatter, ordinalize, parseRangeBounds, pathCache, placeTranslator, pointerIds, profilePictureCache, relativesCache, resetRelativesCache, setCauseOfDeath, setChildPedigree, setDeceased, setFamilyMarriage, setNestedGroup, splitOverlappingRanges, splitRange, spouseTagFor, toGedcomPedigree, updateFactRecord };