@treeviz/familysearch-sdk 1.0.10

package/dist/utils/index.cjs

@@ -0,0 +1,663 @@
+'use strict';
+
+// src/utils/gedcom-converter.ts
+function transformFamilySearchUrl(url) {
+  if (!url.includes("/platform/tree/persons/")) {
+    return url;
+  }
+  const personId = url.match(/persons\/([^/?]+)/)?.[1];
+  if (!personId) {
+    return url;
+  }
+  let baseUrl = "https://www.familysearch.org";
+  if (url.includes("integration.familysearch.org") || url.includes("api-integ.familysearch.org")) {
+    baseUrl = "https://integration.familysearch.org";
+  } else if (url.includes("beta.familysearch.org") || url.includes("apibeta.familysearch.org")) {
+    baseUrl = "https://beta.familysearch.org";
+  }
+  return `${baseUrl}/tree/person/${personId}`;
+}
+function transformSourceUrl(url) {
+  if (!url) return url;
+  if (!url.includes("/platform/") && url.includes("ark:")) {
+    return url;
+  }
+  const arkMatch = url.match(/ark:\/[^/?]+\/[^/?]+/);
+  if (!arkMatch) {
+    return url;
+  }
+  const arkId = arkMatch[0];
+  let baseUrl = "https://www.familysearch.org";
+  if (url.includes("integration.familysearch.org") || url.includes("api-integ.familysearch.org")) {
+    baseUrl = "https://integration.familysearch.org";
+  } else if (url.includes("beta.familysearch.org") || url.includes("apibeta.familysearch.org")) {
+    baseUrl = "https://beta.familysearch.org";
+  }
+  return `${baseUrl}/${arkId}`;
+}
+function extractName(person) {
+  if (!person) return null;
+  if (person.names?.[0]?.nameForms?.[0]) {
+    const nameForm = person.names[0].nameForms[0];
+    const parts = nameForm.parts || [];
+    const given = parts.find((p) => p.type?.includes("Given"))?.value || "";
+    const surname = parts.find((p) => p.type?.includes("Surname"))?.value || "";
+    if (given || surname) {
+      return `${given} /${surname}/`.trim();
+    }
+    if (nameForm.fullText) {
+      return nameForm.fullText;
+    }
+  }
+  if (person.display?.name) {
+    return person.display.name;
+  }
+  return null;
+}
+function extractGender(person) {
+  if (!person) return null;
+  if (person.gender?.type?.includes("Male")) {
+    return "M";
+  } else if (person.gender?.type?.includes("Female")) {
+    return "F";
+  } else if (person.display?.gender === "Male") {
+    return "M";
+  } else if (person.display?.gender === "Female") {
+    return "F";
+  }
+  return null;
+}
+function extractFact(person, factType) {
+  if (!person) return null;
+  const result = {};
+  const factTypeUrl = `http://gedcomx.org/${factType === "BIRTH" ? "Birth" : "Death"}`;
+  const fact = person.facts?.find((f) => f.type === factTypeUrl);
+  if (fact) {
+    if (fact.date?.formal || fact.date?.original) {
+      result.date = (fact.date?.formal || fact.date?.original)?.replace(
+        /^(-|\+)/,
+        ""
+      );
+    }
+    if (fact.place?.original) {
+      result.place = fact.place.original;
+    }
+  }
+  if (factType === "BIRTH") {
+    result.date = result.date || person.display?.birthDate;
+    result.place = result.place || person.display?.birthPlace;
+  } else if (factType === "DEATH") {
+    result.date = result.date || person.display?.deathDate;
+    result.place = result.place || person.display?.deathPlace;
+  }
+  return result.date || result.place ? result : null;
+}
+function formatDateForGedcom(date) {
+  const months = [
+    "JAN",
+    "FEB",
+    "MAR",
+    "APR",
+    "MAY",
+    "JUN",
+    "JUL",
+    "AUG",
+    "SEP",
+    "OCT",
+    "NOV",
+    "DEC"
+  ];
+  const day = date.getDate();
+  const month = months[date.getMonth()];
+  const year = date.getFullYear();
+  return `${day} ${month} ${year}`;
+}
+function convertFactToGedcom(fact) {
+  const lines = [];
+  if (!fact.type) return lines;
+  const typeMap = {
+    "http://gedcomx.org/Burial": "BURI",
+    "http://gedcomx.org/Christening": "CHR",
+    "http://gedcomx.org/Baptism": "BAPM",
+    "http://gedcomx.org/Marriage": "MARR",
+    "http://gedcomx.org/Divorce": "DIV",
+    "http://gedcomx.org/Residence": "RESI",
+    "http://gedcomx.org/Occupation": "OCCU",
+    "http://gedcomx.org/Immigration": "IMMI",
+    "http://gedcomx.org/Emigration": "EMIG",
+    "http://gedcomx.org/Naturalization": "NATU",
+    "http://gedcomx.org/Census": "CENS"
+  };
+  const gedcomTag = typeMap[fact.type] || "EVEN";
+  if (gedcomTag === "OCCU" && fact.value) {
+    lines.push(`1 OCCU ${fact.value}`);
+  } else {
+    lines.push(`1 ${gedcomTag}`);
+  }
+  if (fact.links?.conclusion?.href) {
+    const webUrl = transformFamilySearchUrl(fact.links.conclusion.href);
+    lines.push(`2 _FS_LINK ${webUrl}`);
+  }
+  if (fact.date?.formal || fact.date?.original) {
+    lines.push(
+      `2 DATE ${(fact.date?.formal || fact.date?.original)?.replace(/^(-|\+)/, "")}`
+    );
+  }
+  if (fact.place?.original) {
+    lines.push(`2 PLAC ${fact.place.original}`);
+  }
+  if (fact.value && gedcomTag !== "OCCU") {
+    lines.push(`2 NOTE ${fact.value}`);
+  }
+  return lines;
+}
+function convertToGedcom(pedigreeData, options = {}) {
+  const {
+    treeName = "FamilySearch Import",
+    includeLinks = true,
+    includeNotes = true,
+    environment = "production"
+  } = options;
+  if (!pedigreeData || !pedigreeData.persons) {
+    throw new Error("Invalid FamilySearch data: no persons found");
+  }
+  const lines = [];
+  lines.push("0 HEAD");
+  lines.push("1 SOUR FamilySearch");
+  lines.push("2 VERS 1.0");
+  lines.push("2 NAME FamilySearch API");
+  lines.push("1 DEST ANY");
+  lines.push("1 DATE " + formatDateForGedcom(/* @__PURE__ */ new Date()));
+  lines.push("1 SUBM @SUBM1@");
+  lines.push("1 FILE " + treeName);
+  lines.push("1 GEDC");
+  lines.push("2 VERS 5.5");
+  lines.push("2 FORM LINEAGE-LINKED");
+  lines.push("1 CHAR UTF-8");
+  lines.push("0 @SUBM1@ SUBM");
+  const sourceMap = /* @__PURE__ */ new Map();
+  let sourceCounter = 1;
+  pedigreeData.persons.forEach((person) => {
+    const sourceDescriptions = person.fullDetails?.sourceDescriptions;
+    if (sourceDescriptions && Array.isArray(sourceDescriptions)) {
+      sourceDescriptions.forEach((source) => {
+        if (source.id && !sourceMap.has(source.id)) {
+          sourceMap.set(source.id, source);
+        }
+      });
+    }
+  });
+  sourceMap.forEach((source) => {
+    const sourceId = `@S${sourceCounter++}@`;
+    lines.push(`0 ${sourceId} SOUR`);
+    const title = source.titles?.[0]?.value || "FamilySearch Source";
+    lines.push(`1 TITL ${title}`);
+    if (source.citations?.[0]?.value) {
+      lines.push(`1 TEXT ${source.citations[0].value}`);
+    }
+    if (source.about) {
+      const webUrl = transformSourceUrl(source.about);
+      lines.push(`1 WWW ${webUrl}`);
+    }
+    if (source.resourceType) {
+      lines.push(`1 NOTE Resource Type: ${source.resourceType}`);
+    }
+  });
+  const personIdMap = /* @__PURE__ */ new Map();
+  pedigreeData.persons.forEach((person, index) => {
+    const gedcomId = `@I${index + 1}@`;
+    personIdMap.set(person.id, gedcomId);
+  });
+  const families = /* @__PURE__ */ new Map();
+  const childToParents = /* @__PURE__ */ new Map();
+  const allRelationships = [
+    ...pedigreeData.relationships || []
+  ];
+  pedigreeData.persons.forEach((person) => {
+    const personRelationships = person.fullDetails?.relationships;
+    if (personRelationships && Array.isArray(personRelationships)) {
+      personRelationships.forEach((rel) => {
+        const exists = allRelationships.some((r) => r.id === rel.id);
+        if (!exists) {
+          allRelationships.push(rel);
+        }
+      });
+    }
+    const childAndParentsRels = person.fullDetails?.childAndParentsRelationships;
+    if (childAndParentsRels && Array.isArray(childAndParentsRels)) {
+      childAndParentsRels.forEach((capRel) => {
+        if (capRel.parent1 && capRel.child) {
+          const rel = {
+            id: `${capRel.id}-p1`,
+            type: "http://gedcomx.org/ParentChild",
+            person1: { resourceId: capRel.parent1.resourceId },
+            person2: { resourceId: capRel.child.resourceId },
+            parent2: capRel.parent2 ? { resourceId: capRel.parent2.resourceId } : void 0
+          };
+          const exists = allRelationships.some(
+            (r) => r.id === rel.id
+          );
+          if (!exists) {
+            allRelationships.push(rel);
+          }
+        }
+        if (capRel.parent2 && capRel.child) {
+          const rel = {
+            id: `${capRel.id}-p2`,
+            type: "http://gedcomx.org/ParentChild",
+            person1: { resourceId: capRel.parent2.resourceId },
+            person2: { resourceId: capRel.child.resourceId },
+            parent2: capRel.parent1 ? { resourceId: capRel.parent1.resourceId } : void 0
+          };
+          const exists = allRelationships.some(
+            (r) => r.id === rel.id
+          );
+          if (!exists) {
+            allRelationships.push(rel);
+          }
+        }
+      });
+    }
+  });
+  const validPersonIds = new Set(pedigreeData.persons.map((p) => p.id));
+  allRelationships.forEach((rel) => {
+    if (rel.type?.includes("ParentChild")) {
+      const parentId = rel.person1?.resourceId;
+      const childId = rel.person2?.resourceId;
+      const parent2Id = rel.parent2?.resourceId;
+      if (!parentId || !childId) {
+        return;
+      }
+      if (!validPersonIds.has(childId)) {
+        return;
+      }
+      const validParents = [];
+      if (validPersonIds.has(parentId)) {
+        validParents.push(parentId);
+      }
+      if (parent2Id && validPersonIds.has(parent2Id)) {
+        validParents.push(parent2Id);
+      }
+      if (validParents.length > 0) {
+        if (!childToParents.has(childId)) {
+          childToParents.set(childId, []);
+        }
+        const parents = childToParents.get(childId);
+        validParents.forEach((parentId2) => {
+          if (!parents.includes(parentId2)) {
+            parents.push(parentId2);
+          }
+        });
+      }
+    } else if (rel.type?.includes("Couple")) {
+      const person1 = rel.person1?.resourceId;
+      const person2 = rel.person2?.resourceId;
+      if (!person1 || !person2) {
+        return;
+      }
+      if (validPersonIds.has(person1) && validPersonIds.has(person2)) {
+        const famKey = [person1, person2].sort().join("-");
+        if (!families.has(famKey)) {
+          families.set(famKey, {
+            spouses: /* @__PURE__ */ new Set([person1, person2]),
+            children: []
+          });
+        }
+      }
+    }
+  });
+  childToParents.forEach((parents, childId) => {
+    if (parents.length >= 2) {
+      const famKey = parents.slice(0, 2).sort().join("-");
+      if (!families.has(famKey)) {
+        families.set(famKey, {
+          spouses: new Set(parents.slice(0, 2)),
+          children: []
+        });
+      }
+      families.get(famKey).children.push(childId);
+    } else if (parents.length === 1) {
+      const famKey = `single-${parents[0]}`;
+      if (!families.has(famKey)) {
+        families.set(famKey, {
+          spouses: /* @__PURE__ */ new Set([parents[0]]),
+          children: []
+        });
+      }
+      families.get(famKey).children.push(childId);
+    }
+  });
+  const connectablePersons = /* @__PURE__ */ new Set();
+  if (options.ancestryPersonIds && options.ancestryPersonIds.size > 0) {
+    options.ancestryPersonIds.forEach((personId) => {
+      connectablePersons.add(personId);
+    });
+    families.forEach((family) => {
+      const spouses = Array.from(family.spouses);
+      if (spouses.some((spouseId) => connectablePersons.has(spouseId))) {
+        spouses.forEach((spouseId) => connectablePersons.add(spouseId));
+      }
+    });
+    let addedNewPersons = true;
+    while (addedNewPersons) {
+      addedNewPersons = false;
+      const beforeSize = connectablePersons.size;
+      childToParents.forEach((parents, childId) => {
+        if (parents.some((parentId) => connectablePersons.has(parentId))) {
+          if (!connectablePersons.has(childId)) {
+            connectablePersons.add(childId);
+            addedNewPersons = true;
+          }
+        }
+      });
+      families.forEach((family) => {
+        const spouses = Array.from(family.spouses);
+        const hasConnectableSpouse = spouses.some(
+          (spouseId) => connectablePersons.has(spouseId)
+        );
+        const hasConnectableChild = family.children.some(
+          (childId) => connectablePersons.has(childId)
+        );
+        if (hasConnectableSpouse || hasConnectableChild) {
+          spouses.forEach((spouseId) => {
+            if (!connectablePersons.has(spouseId)) {
+              connectablePersons.add(spouseId);
+              addedNewPersons = true;
+            }
+          });
+        }
+      });
+      const afterSize = connectablePersons.size;
+      if (afterSize > beforeSize) {
+        addedNewPersons = afterSize !== beforeSize;
+      }
+    }
+  } else {
+    childToParents.forEach((parents, childId) => {
+      connectablePersons.add(childId);
+      parents.forEach((parentId) => connectablePersons.add(parentId));
+    });
+  }
+  const allowOrphanFamilies = options.allowOrphanFamilies === true;
+  const orphanFamKeys = /* @__PURE__ */ new Set();
+  const personToFamKeys = /* @__PURE__ */ new Map();
+  families.forEach((family, key) => {
+    const spouseArray = Array.from(family.spouses);
+    const anyMemberConnectable = spouseArray.some((spouseId) => connectablePersons.has(spouseId)) || family.children.some((childId) => connectablePersons.has(childId));
+    const isOrphanFamily = !anyMemberConnectable;
+    if (isOrphanFamily) {
+      orphanFamKeys.add(key);
+    }
+    spouseArray.forEach((spouseId) => {
+      if (!personToFamKeys.has(spouseId))
+        personToFamKeys.set(spouseId, /* @__PURE__ */ new Set());
+      personToFamKeys.get(spouseId).add(key);
+    });
+    family.children.forEach((childId) => {
+      if (!personToFamKeys.has(childId))
+        personToFamKeys.set(childId, /* @__PURE__ */ new Set());
+      personToFamKeys.get(childId).add(key);
+    });
+  });
+  pedigreeData.persons.forEach((person) => {
+    const gedcomId = personIdMap.get(person.id);
+    if (!gedcomId) {
+      console.warn(
+        `[GEDCOM] Person ${person.id} not found in personIdMap`
+      );
+      return;
+    }
+    if (!allowOrphanFamilies) {
+      const famKeys = personToFamKeys.get(person.id);
+      if (famKeys && famKeys.size > 0 && Array.from(famKeys).every((key) => orphanFamKeys.has(key))) {
+        return;
+      }
+    }
+    lines.push(`0 ${gedcomId} INDI`);
+    if (person.id) {
+      lines.push(`1 _FS_ID ${person.id}`);
+    }
+    if (includeLinks) {
+      const personLink = person.links?.person?.href || person.identifiers?.["http://gedcomx.org/Persistent"]?.[0];
+      if (personLink) {
+        const webUrl = transformFamilySearchUrl(personLink);
+        lines.push(`1 _FS_LINK ${webUrl}`);
+      } else if (person.id) {
+        let baseUrl = "https://www.familysearch.org";
+        if (environment === "beta") {
+          baseUrl = "https://beta.familysearch.org";
+        } else if (environment === "integration") {
+          baseUrl = "https://integration.familysearch.org";
+        }
+        const webUrl = `${baseUrl}/tree/person/${person.id}`;
+        lines.push(`1 _FS_LINK ${webUrl}`);
+      }
+    }
+    const personData = person.fullDetails?.persons?.[0] || person;
+    const name = extractName(personData);
+    if (name) {
+      lines.push(`1 NAME ${name}`);
+    }
+    const gender = extractGender(personData);
+    if (gender) {
+      lines.push(`1 SEX ${gender}`);
+    }
+    const birth = extractFact(personData, "BIRTH");
+    if (birth) {
+      lines.push("1 BIRT");
+      if (birth.date) {
+        lines.push(`2 DATE ${birth.date}`);
+      }
+      if (birth.place) {
+        lines.push(`2 PLAC ${birth.place}`);
+      }
+    }
+    const death = extractFact(personData, "DEATH");
+    if (death) {
+      lines.push("1 DEAT");
+      if (death.date) {
+        lines.push(`2 DATE ${death.date}`);
+      }
+      if (death.place) {
+        lines.push(`2 PLAC ${death.place}`);
+      }
+    }
+    personData.facts?.forEach((fact) => {
+      if (fact.type && fact.type !== "http://gedcomx.org/Birth" && fact.type !== "http://gedcomx.org/Death") {
+        const factLines = convertFactToGedcom(fact);
+        factLines.forEach((line) => lines.push(line));
+      }
+    });
+    if (includeNotes && person.notes?.persons?.[0]?.notes) {
+      person.notes.persons[0].notes.forEach((note) => {
+        if (note.text) {
+          const noteText = note.text.replace(/\n/g, " ");
+          lines.push(`1 NOTE ${noteText}`);
+        }
+      });
+    }
+    const personSources = personData?.sources;
+    if (personSources && Array.isArray(personSources)) {
+      personSources.forEach((sourceRef) => {
+        const sourceId = sourceRef.descriptionId;
+        if (!sourceId) return;
+        const sourceIds = Array.from(sourceMap.keys());
+        const sourceIndex = sourceIds.indexOf(sourceId);
+        if (sourceIndex === -1) return;
+        const gedcomSourceId = `@S${sourceIndex + 1}@`;
+        lines.push(`1 SOUR ${gedcomSourceId}`);
+        if (sourceRef.qualifiers && Array.isArray(sourceRef.qualifiers)) {
+          sourceRef.qualifiers.forEach((qualifier) => {
+            if (qualifier.name && qualifier.value) {
+              lines.push(
+                `2 NOTE ${qualifier.name}: ${qualifier.value}`
+              );
+            }
+          });
+        }
+      });
+    }
+  });
+  let famIndex = 1;
+  const familyIdMap = /* @__PURE__ */ new Map();
+  families.forEach((family, key) => {
+    const spouseArray = Array.from(family.spouses);
+    const parentsInMap = spouseArray.filter((id) => personIdMap.has(id));
+    const hasNoParents = parentsInMap.length === 0;
+    const hasSingleParentNoChildren = parentsInMap.length === 1 && family.children.length === 0;
+    if (hasNoParents) {
+      if (family.children.length > 0) {
+        console.warn(
+          `[FS SDK GEDCOM] Skipping FAM for orphaned child(ren): ${family.children.length} child(ren) with 0 parents`
+        );
+      }
+      return;
+    }
+    if (hasSingleParentNoChildren) {
+      return;
+    }
+    const anyMemberConnectable = spouseArray.some((spouseId) => connectablePersons.has(spouseId)) || family.children.some((childId) => connectablePersons.has(childId));
+    const isOrphanFamily = !anyMemberConnectable;
+    if (isOrphanFamily && !allowOrphanFamilies) {
+      return;
+    }
+    const famId = `@F${famIndex++}@`;
+    familyIdMap.set(key, famId);
+    lines.push(`0 ${famId} FAM`);
+    if (isOrphanFamily && allowOrphanFamilies) {
+      lines.push(`1 _IS_ORPHAN_FAMILY Y`);
+    }
+    if (spouseArray.length === 2) {
+      const [person1, person2] = spouseArray;
+      const person1Data = pedigreeData.persons?.find(
+        (p) => p.id === person1
+      );
+      const person2Data = pedigreeData.persons?.find(
+        (p) => p.id === person2
+      );
+      const gender1 = extractGender(
+        person1Data?.fullDetails?.persons?.[0] || person1Data
+      );
+      const gender2 = extractGender(
+        person2Data?.fullDetails?.persons?.[0] || person2Data
+      );
+      const p1 = personIdMap.get(person1);
+      const p2 = personIdMap.get(person2);
+      if (gender1 === "M" || gender2 === "F") {
+        if (p1) lines.push(`1 HUSB ${p1}`);
+        if (p2) lines.push(`1 WIFE ${p2}`);
+      } else {
+        if (p2) lines.push(`1 HUSB ${p2}`);
+        if (p1) lines.push(`1 WIFE ${p1}`);
+      }
+      addMarriageFacts(lines, allRelationships, person1, person2);
+    } else if (spouseArray.length === 1) {
+      const parentData = pedigreeData.persons?.find(
+        (p) => p.id === spouseArray[0]
+      );
+      const gender = extractGender(
+        parentData?.fullDetails?.persons?.[0] || parentData
+      );
+      if (gender === "M") {
+        lines.push(`1 HUSB ${personIdMap.get(spouseArray[0])}`);
+      } else {
+        lines.push(`1 WIFE ${personIdMap.get(spouseArray[0])}`);
+      }
+    }
+    family.children.forEach((childId) => {
+      const childGedcomId = personIdMap.get(childId);
+      if (childGedcomId) {
+        lines.push(`1 CHIL ${childGedcomId}`);
+      }
+    });
+  });
+  childToParents.forEach((parents, childId) => {
+    const childGedcomId = personIdMap.get(childId);
+    if (!childGedcomId) return;
+    let famId;
+    if (parents.length >= 2) {
+      const famKey = parents.slice(0, 2).sort().join("-");
+      famId = familyIdMap.get(famKey);
+    } else if (parents.length === 1) {
+      const famKey = `single-${parents[0]}`;
+      famId = familyIdMap.get(famKey);
+    }
+    if (famId) {
+      const indiRecordIndex = lines.findIndex(
+        (line) => line === `0 ${childGedcomId} INDI`
+      );
+      if (indiRecordIndex !== -1) {
+        lines.splice(indiRecordIndex + 1, 0, `1 FAMC ${famId}`);
+      }
+    }
+  });
+  families.forEach((family, key) => {
+    const famId = familyIdMap.get(key);
+    if (!famId) return;
+    family.spouses.forEach((spouseId) => {
+      const spouseGedcomId = personIdMap.get(spouseId);
+      if (!spouseGedcomId) return;
+      const indiRecordIndex = lines.findIndex(
+        (line) => line === `0 ${spouseGedcomId} INDI`
+      );
+      if (indiRecordIndex !== -1) {
+        let insertIndex = indiRecordIndex + 1;
+        while (insertIndex < lines.length && lines[insertIndex].startsWith("1 FAMC")) {
+          insertIndex++;
+        }
+        lines.splice(insertIndex, 0, `1 FAMS ${famId}`);
+      }
+    });
+  });
+  const personsInFamilies = /* @__PURE__ */ new Set();
+  families.forEach((family) => {
+    family.spouses.forEach((id) => personsInFamilies.add(id));
+    family.children.forEach((id) => personsInFamilies.add(id));
+  });
+  lines.push("0 TRLR");
+  return lines.join("\n");
+}
+function addMarriageFacts(lines, relationships, person1, person2) {
+  const relKey = [person1, person2].sort().join("-");
+  const rel = relationships.find((r) => {
+    const a = r.person1?.resourceId || r.person1?.resource?.resourceId;
+    const b = r.person2?.resourceId || r.person2?.resource?.resourceId;
+    if (!a || !b) return false;
+    return [a, b].sort().join("-") === relKey;
+  });
+  if (!rel) return;
+  const marriageFacts = [];
+  if (rel.facts && Array.isArray(rel.facts)) {
+    rel.facts.forEach((f) => {
+      if (f.type?.includes("Marriage")) {
+        marriageFacts.push(f);
+      }
+    });
+  }
+  if (rel.details?.facts && Array.isArray(rel.details.facts)) {
+    marriageFacts.push(
+      ...rel.details.facts.filter((f) => f.type?.includes("Marriage"))
+    );
+  }
+  if (rel.details?.persons && Array.isArray(rel.details.persons)) {
+    rel.details.persons.forEach((p) => {
+      if (p.facts && Array.isArray(p.facts)) {
+        p.facts.forEach((f) => {
+          if (f.type?.includes("Marriage")) {
+            marriageFacts.push(f);
+          }
+        });
+      }
+    });
+  }
+  marriageFacts.forEach((mf) => {
+    const factLines = convertFactToGedcom(mf);
+    factLines.forEach((line) => lines.push(line));
+  });
+}
+var convertFamilySearchToGedcom = convertToGedcom;
+
+exports.convertFamilySearchToGedcom = convertFamilySearchToGedcom;
+exports.convertToGedcom = convertToGedcom;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map