@treeviz/gedcom-parser 2.0.10 → 2.1.0

package/dist/utils/index.js

@@ -1,5 +1,6 @@
 import { debounce, set, get, uniqBy, unset, difference, intersectionBy, differenceBy } from 'lodash-es';
 import { format, isValid, parse } from 'date-fns';
+import JSZip from 'jszip';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -292,11 +293,31 @@ var cacheDiscoveredPath = (gedcom, path) => {
 };
 
 // src/constants/constants.ts
-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 APP_BRANDING = "TreeViz - The Family Tree Visualiser & Editor";
+var REF_LINE_REG = /^0 (?:(@[_a-zA-Z0-9]*@) )?(?<type>_[_A-Z][_a-zA-Z0-9]{2,}|_?[A-Z][A-Za-z0-9]{2,}) ?(?<value>.*)/gm;
+var LINE_REG = /(?<indent>^[0-9]{1,2}) (?:(@[_a-zA-Z0-9]*@) )?(?<type>_[_A-Z][_a-zA-Z0-9]{2,}|_?[A-Z][A-Za-z0-9]{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) {
@@ -672,11 +693,17 @@ var List = class _List {
     const gedcom = [];
     this.entries().forEach(([_, item]) => {
       const validTag = getValidTag(tag);
-      const validKey = item.id;
-      const validValue = validKey ? validTag : item.exportValue();
-      gedcom.push(
-        `${level} ${validKey || validTag}${validValue ? ` ${validValue}` : ""}`
-      );
+      const xref = item.id;
+      const payload = item.exportValue?.();
+      if (xref) {
+        gedcom.push(
+          `${level} ${xref} ${validTag}${payload ? ` ${payload}` : ""}`
+        );
+      } else {
+        gedcom.push(
+          `${level} ${validTag}${payload ? ` ${payload}` : ""}`
+        );
+      }
       gedcom.push(
         ...item.toGedcomLines(
           validTag,
@@ -807,6 +834,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 +847,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) {
@@ -928,12 +961,14 @@ var Common = class _Common {
     );
   }
   standardizeObject(tag, options) {
-    if (tag === "OBJE" && !options?.original && options?.obje?.standardize && options?.obje?.namespace && "standardizeMedia" in this) {
+    if (tag === "OBJE" && options?.obje?.standardize && "standardizeMedia" in this) {
       const standardize = this.standardizeMedia;
       return standardize.call(
         this,
         options.obje.namespace,
-        options.obje.override
+        options.obje.override,
+        void 0,
+        options.gedcomVersion
       );
     }
   }
@@ -960,7 +995,7 @@ var Common = class _Common {
         if (typeof prop?.toObject === "function") {
           if (prop instanceof _Common) {
             json[validKey] = prop.toObject(validKey, options);
-          } else {
+          } else if (prop instanceof List) {
             json = {
               ...json,
               ...prop.toObject(validKey, options)
@@ -1018,8 +1053,12 @@ var Common = class _Common {
     this.standardizeObject(tag, options);
     const validKeys = getValidKeys(this);
     const gedcom = [];
+    const isGedcom7Export = options?.gedcomVersion === "7.0";
     validKeys.forEach((key) => {
       const validKey = key;
+      if (isGedcom7Export && validKey === "CONC") {
+        return;
+      }
       const prop = this.get(validKey);
       if (typeof prop?.toGedcomLines === "function") {
         if (prop instanceof _Common) {
@@ -1030,7 +1069,7 @@ var Common = class _Common {
           gedcom.push(
             ...prop.toGedcomLines(validKey, level + 1, options)
           );
-        } else {
+        } else if (prop instanceof List) {
           gedcom.push(
             ...prop.toGedcomLines(validKey, level, options)
           );
@@ -1039,30 +1078,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 +1135,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 +1184,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 +1194,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 +1293,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 +1363,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 +1857,352 @@ 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" });
+};
+var addNonEvent = (owner, input) => {
+  const gedcom = owner.getGedcom();
+  const eventType = input.event?.trim().toUpperCase();
+  if (!gedcom || !eventType) {
+    return void 0;
+  }
+  const no = createCommon(gedcom, void 0, owner);
+  no.type = "NO";
+  no.value = eventType;
+  if (input.date?.trim()) {
+    setDateOn(gedcom, owner, no, input.date);
+  }
+  if (input.note?.trim()) {
+    no.set("NOTE", input.note.trim());
+  }
+  owner.assign("NO", no);
+  return no;
+};
+
+// 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";
@@ -1876,6 +2277,81 @@ var getPlaces = (common, type = ["ALL" /* All */], maxLevel = 1, level = 0, main
   });
   return places;
 };
+
+// src/utils/local-media.ts
+var localMediaResolver;
+var mediaContentResolver;
+var setLocalMediaResolver = (resolver) => {
+  localMediaResolver = resolver;
+};
+var setMediaContentResolver = (resolver) => {
+  mediaContentResolver = resolver;
+};
+var isRemoteOrEmbeddedMediaUrl = (path) => {
+  if (!path) {
+    return false;
+  }
+  return path.startsWith("data:") || path.startsWith("blob:") || /^https?:\/\//i.test(path);
+};
+var resolveLocalMediaUrl = async (path) => {
+  if (!path) {
+    return void 0;
+  }
+  if (isRemoteOrEmbeddedMediaUrl(path)) {
+    return path;
+  }
+  const resolved = await localMediaResolver?.(path);
+  return resolved;
+};
+var blobToDataUrl = async (blob) => {
+  const buffer = await blob.arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  const mime = blob.type || "application/octet-stream";
+  if (typeof Buffer !== "undefined") {
+    return `data:${mime};base64,${Buffer.from(bytes).toString("base64")}`;
+  }
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return `data:${mime};base64,${btoa(binary)}`;
+};
+var resolveMediaContent = async (media) => {
+  const fromHost = await mediaContentResolver?.(media);
+  if (fromHost?.content) {
+    return fromHost;
+  }
+  const url = media.url;
+  if (!url) {
+    return void 0;
+  }
+  if (url.startsWith("data:") || url.startsWith("blob:")) {
+    return { content: url, contentType: media.contentType };
+  }
+  if (!isRemoteOrEmbeddedMediaUrl(url)) {
+    const local = await resolveLocalMediaUrl(url);
+    if (local && isRemoteOrEmbeddedMediaUrl(local)) {
+      return { content: local, contentType: media.contentType };
+    }
+    return void 0;
+  }
+  if (typeof fetch !== "function") {
+    return void 0;
+  }
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return void 0;
+    }
+    const blob = await response.blob();
+    const content = await blobToDataUrl(blob);
+    const contentType = media.contentType || blob.type.split("/").pop() || "bin";
+    return { content, contentType };
+  } catch {
+    return void 0;
+  }
+};
 var implemented = (type, ...args) => {
 };
 var notImplemented = (type, ...args) => {
@@ -1884,11 +2360,34 @@ var notImplemented = (type, ...args) => {
 
 // src/utils/media-utils.ts
 var getFileExtension = (filename) => {
-  const match = filename.match(/\.([^.]+)$/);
-  return match ? match[1] : "";
+  if (!filename) {
+    return "";
+  }
+  if (filename.startsWith("data:")) {
+    const mime = filename.slice(5).split(";")[0] || "";
+    const subtype = (mime.split("/")[1] || "").toLowerCase();
+    if (subtype === "jpeg") {
+      return "jpg";
+    }
+    return subtype.split("+")[0] || "";
+  }
+  const withoutQuery = filename.split(/[?#]/)[0] || filename;
+  const match = withoutQuery.match(/\.([^.]+)$/);
+  return match ? match[1].toLowerCase() : "";
 };
 var isImageFormat = (format2) => {
-  if (!format2) return false;
+  if (!format2) {
+    return false;
+  }
+  let normalized = format2.toLowerCase().trim();
+  if (normalized.startsWith("data:")) {
+    normalized = getFileExtension(normalized);
+  } else if (normalized.includes("/")) {
+    normalized = normalized.split("/")[1]?.split("+")[0] || "";
+    if (normalized === "jpeg") {
+      normalized = "jpg";
+    }
+  }
   const imageFormats = [
     "jpg",
     "jpeg",
@@ -1900,7 +2399,11 @@ var isImageFormat = (format2) => {
     "tiff",
     "tif"
   ];
-  return imageFormats.includes(format2.toLowerCase());
+  return imageFormats.includes(normalized);
+};
+var resolveObjeForm = (obje) => {
+  const value = obje?.get?.("FILE.FORM")?.toValue?.() ?? obje?.get?.("FORM")?.toValue?.();
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
 };
 var uniqueItemsCache = /* @__PURE__ */ new WeakMap();
 var setNestedGroup = (obj, key, value, uniqueCounting = true) => {
@@ -2445,6 +2948,34 @@ 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);
+  }
+  addNonEvent(input) {
+    return addNonEvent(this, input);
+  }
   toList() {
     return new Families().concat(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2550,19 +3081,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 +3669,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 +3681,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(
@@ -3136,10 +3699,14 @@ var Indi = class extends Common {
           const clone = obje?.get("_CLON._OID")?.toValue();
           const mser = obje?.get("_MSER._LKID")?.toValue();
           let url = obje?.get("FILE")?.toValue();
-          const title = obje?.get("TITL")?.toValue() ?? "";
-          const type = obje?.get("FORM")?.toValue() ?? "raw";
-          const imgId = clone || mser;
-          if (!www || !tree || !this.id) {
+          const title = obje?.get("FILE.TITL")?.toValue() ?? obje?.get("TITL")?.toValue() ?? "";
+          const type = resolveObjeForm(obje) ?? (url ? getFileExtension(url) : void 0) ?? "raw";
+          let imgId = clone || mser;
+          const hasEmbeddedOrLocalFile = !!url && (url.startsWith("data:") || url.startsWith("blob:") || !/^https?:\/\//i.test(url));
+          if (!hasEmbeddedOrLocalFile && (!www || !tree || !this.id)) {
+            return;
+          }
+          if (!this.id) {
             return;
           }
           if (!namespace && !url) {
@@ -3157,13 +3724,16 @@ var Indi = class extends Common {
             }
             url = url || `https://${www}/mediaui-viewer/tree/${tree}/media/${media}`;
           }
+          if (!imgId && hasEmbeddedOrLocalFile && url) {
+            imgId = typeof media === "string" && media || `local-${String(key).replace(/[@]/g, "")}-${getFileExtension(url) || "bin"}`;
+          }
           if (url && imgId) {
-            const id = `${tree}-${this.id}-${imgId}`;
+            const id = `${tree || "gedzip"}-${this.id}-${imgId}`;
             list[id] = {
               key,
               isPrimary,
               id,
-              tree,
+              tree: tree || "gedzip",
               imgId,
               person: this.id,
               title,
@@ -3178,7 +3748,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, "-");
@@ -3209,9 +3779,11 @@ var Indi = class extends Common {
       obje.standardizeMedia();
       const isPrimary = obje?.get("_PRIM")?.toValue() === "Y";
       const url = obje?.get("FILE")?.toValue();
-      const title = obje?.get("NOTE")?.toValue() ?? "";
-      const type = obje?.get("FORM")?.toValue() ?? "raw";
-      const imgId = obje?.get("_PHOTO_RIN")?.toValue();
+      const title = obje?.get("FILE.NOTE")?.toValue() ?? obje?.get("NOTE")?.toValue() ?? "";
+      const type = resolveObjeForm(obje) ?? (url ? getFileExtension(url) : void 0) ?? "raw";
+      const photoRin = obje?.get("_PHOTO_RIN")?.toValue();
+      const hasEmbeddedOrLocalFile = !!url && (url.startsWith("data:") || url.startsWith("blob:") || !/^https?:\/\//i.test(url));
+      const imgId = photoRin || (hasEmbeddedOrLocalFile && url ? `local-${String(key).replace(/[@]/g, "")}-${getFileExtension(url) || "bin"}` : void 0);
       if (url && imgId) {
         const id = `${tree}-${this.id}-${imgId}`;
         list[id] = {
@@ -3334,10 +3906,10 @@ var Indi = class extends Common {
       const isPrimary = obje?.get("_PRIM")?.toValue() === "Y";
       const url = obje?.get("FILE")?.toValue();
       const title = obje?.get("TITL")?.toValue() ?? "";
-      const type = obje?.get("FORM")?.toValue() ?? "raw";
+      const type = resolveObjeForm(obje) ?? (url ? getFileExtension(url) : void 0) ?? "raw";
       if (url) {
         const urlMatch = url.match(/\/([^/]+)\?hash=/);
-        const imgId = urlMatch?.[1] || `img-${index}-${Date.now().toString(36)}`;
+        const imgId = urlMatch?.[1] || (url.startsWith("data:") ? `data-${index}-${getFileExtension(url) || "bin"}` : `img-${index}-${Date.now().toString(36)}`);
         const id = `geni-${geniId}-${imgId}`;
         list[id] = {
           isPrimary,
@@ -3374,10 +3946,10 @@ var Indi = class extends Common {
       obje.standardizeMedia();
       const isPrimary = obje?.get("_PRIM")?.toValue() === "Y";
       const url = obje?.get("FILE")?.toValue();
-      const title = obje?.get("TITL")?.toValue() ?? "";
-      const type = obje?.get("FORM")?.toValue() ?? "raw";
+      const title = obje?.get("FILE.TITL")?.toValue() ?? obje?.get("TITL")?.toValue() ?? "";
+      const type = resolveObjeForm(obje) ?? (url ? getFileExtension(url) : void 0) ?? "raw";
       if (url) {
-        const imgId = `media-${index}-${url.split("/").pop()?.split("?")[0]?.substring(0, 20) || Date.now().toString(36)}`;
+        const imgId = `media-${index}-${url.startsWith("data:") ? getFileExtension(url) || "bin" : url.split("/").pop()?.split("?")[0]?.substring(0, 20) || Date.now().toString(36)}`;
         const id = `${treeId}-${this.id}-${imgId}`;
         list[id] = {
           isPrimary,
@@ -3417,7 +3989,20 @@ var Indi = class extends Common {
       cacheKey
     );
     if (cached !== void 0) {
-      return cached;
+      if (cached?.file && !isRemoteOrEmbeddedMediaUrl(cached.file)) {
+        const resolvedCached = await resolveLocalMediaUrl(cached.file);
+        if (resolvedCached && isRemoteOrEmbeddedMediaUrl(resolvedCached)) {
+          const refreshed = { ...cached, file: resolvedCached };
+          profilePictureCache(
+            this._gedcom,
+            cacheKey,
+            refreshed
+          );
+          return refreshed;
+        }
+      } else {
+        return cached;
+      }
     }
     const mediaList = await this.multimedia(namespace);
     if (!mediaList) {
@@ -3429,39 +4014,40 @@ var Indi = class extends Common {
       return void 0;
     }
     const mediaArray = Object.values(mediaList);
-    const primaryMedia = mediaArray.find(
-      (media) => media.isPrimary && isImageFormat(media.contentType || getFileExtension(media.url))
-    );
-    if (primaryMedia) {
-      const result = {
-        file: primaryMedia.url,
-        form: primaryMedia.contentType,
-        title: primaryMedia.title,
-        isPrimary: true
+    const toDisplayableProfile = async (media, isPrimary) => {
+      const resolvedFile = await resolveLocalMediaUrl(media.url);
+      if (!resolvedFile || !isRemoteOrEmbeddedMediaUrl(resolvedFile)) {
+        return void 0;
+      }
+      return {
+        file: resolvedFile,
+        form: media.contentType,
+        title: media.title,
+        isPrimary
       };
-      profilePictureCache(this._gedcom, cacheKey, result);
-      return result;
-    }
-    if (onlyPrimary) {
-      profilePictureCache(
-        this._gedcom,
-        cacheKey,
-        void 0
-      );
-      return void 0;
-    }
-    const secondaryMedia = mediaArray.find(
-      (media) => isImageFormat(media.contentType || getFileExtension(media.url))
+    };
+    const candidates = mediaArray.filter(
+      (media) => isImageFormat(
+        media.contentType || media.url || getFileExtension(media.url)
+      )
     );
-    if (secondaryMedia) {
-      const result = {
-        file: secondaryMedia.url,
-        form: secondaryMedia.contentType,
-        title: secondaryMedia.title,
-        isPrimary: false
-      };
-      profilePictureCache(this._gedcom, cacheKey, result);
-      return result;
+    const ordered = [
+      ...candidates.filter((media) => media.isPrimary),
+      ...candidates.filter((media) => !media.isPrimary)
+    ];
+    for (const media of ordered) {
+      if (onlyPrimary && !media.isPrimary) {
+        break;
+      }
+      const result = await toDisplayableProfile(media, !!media.isPrimary);
+      if (result) {
+        profilePictureCache(
+          this._gedcom,
+          cacheKey,
+          result
+        );
+        return result;
+      }
     }
     profilePictureCache(
       this._gedcom,
@@ -3699,31 +4285,181 @@ var Indi = class extends Common {
   isUnknownSex() {
     return !this.isMale() && !this.isFemale();
   }
-  getParentType(id) {
-    let indi;
-    if (typeof id === "string" || typeof id === "number") {
-      indi = this._gedcom?.indi(id);
-    } else {
-      indi = id;
+  addSpouse(other) {
+    if (!this.id || !other?.id || this.id === other.id || !this._gedcom) {
+      return void 0;
     }
-    if (!indi?.id || !this.id) {
-      return;
+    const existing = getFamilyWith(this, other.id);
+    if (existing) {
+      return existing;
     }
-    const parents = this.getParents();
-    let parent = parents.item(indi.id) ? indi : void 0;
-    let child = this._gedcom?.indi(this.id);
-    if (!parent?.id) {
-      const children = this.getChildren();
-      if (children.item(indi.id)) {
-        parent = this._gedcom?.indi(this.id);
-        child = indi;
-      }
+    const fam = this._gedcom.createFamily();
+    if (!fam.addSpouse(this) || !fam.addSpouse(other)) {
+      return void 0;
     }
-    const familiesOfChildren = child?.get("FAMC")?.toValueList();
-    if (!parent?.id || !child?.id || !familiesOfChildren) {
-      return;
+    return fam;
+  }
+  addChild(child, pedigree) {
+    if (!this.id || !child?.id || this.id === child.id || !this._gedcom) {
+      return void 0;
     }
-    const families = this.toFamilies(familiesOfChildren);
+    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);
+  }
+  /**
+   * Link an existing top-level OBJE record to this individual (`1 OBJE @On@`).
+   */
+  attachMultimedia(objeOrKey, options) {
+    if (!this._gedcom || !this.id) {
+      return void 0;
+    }
+    const obje = typeof objeOrKey === "string" ? this._gedcom.obje(objeOrKey) : objeOrKey;
+    if (!obje?.id) {
+      return void 0;
+    }
+    const already = this.get("OBJE")?.toList()?.values()?.some((item) => item?.toValue?.() === obje.id);
+    if (!already) {
+      const pointer = makePointer(
+        this._gedcom,
+        this,
+        obje.id,
+        "OBJE"
+      );
+      this.assign("OBJE", pointer);
+    }
+    if (options?.primary) {
+      this.get("OBJE")?.toList()?.forEach((item) => {
+        const target = item?.refType === "OBJE" ? this._gedcom?.obje(
+          String(item.toValue())
+        ) : item;
+        if (!target) {
+          return;
+        }
+        if (target.id === obje.id) {
+          target.set("_PRIM", "Y");
+        } else if (target.get("_PRIM")?.toValue() === "Y") {
+          target.set("_PRIM", "N");
+        }
+      });
+      obje.set("_PRIM", "Y");
+    }
+    return obje;
+  }
+  detachMultimedia(objeKey) {
+    const list = this.get("OBJE")?.toList();
+    if (!list) {
+      return;
+    }
+    const toRemove = list.values().filter(
+      (item) => item?.toValue?.() === objeKey || item?.id === objeKey
+    );
+    toRemove.forEach((item) => {
+      if (item) {
+        list.delete(item);
+      }
+    });
+    if (list.length === 0) {
+      this.remove("OBJE");
+    }
+  }
+  /**
+   * Create a multimedia record and attach it to this person.
+   */
+  attachMediaFromUrl(url, options) {
+    if (!this._gedcom || !url) {
+      return void 0;
+    }
+    const obje = this._gedcom.createMultimediaRecord({
+      file: url,
+      form: options?.form,
+      title: options?.title,
+      mediType: options?.mediType,
+      primary: options?.primary,
+      gedcomVersion: options?.gedcomVersion
+    });
+    return this.attachMultimedia(obje, { primary: options?.primary });
+  }
+  /**
+   * Link a shared SNOTE record via `1 NOTE @Nn@` (GEDCOM 7).
+   */
+  attachSharedNote(noteOrKey) {
+    if (!this._gedcom || !this.id) {
+      return void 0;
+    }
+    const note = typeof noteOrKey === "string" ? this._gedcom.snote(noteOrKey) : noteOrKey;
+    if (!note?.id) {
+      return void 0;
+    }
+    const already = this.get("NOTE")?.toList()?.values()?.some((item) => item?.toValue?.() === note.id);
+    if (!already) {
+      const pointer = makePointer(
+        this._gedcom,
+        this,
+        note.id,
+        "SNOTE"
+      );
+      this.assign("NOTE", pointer);
+    }
+    return note;
+  }
+  addFact(input) {
+    return addIndividualFact(this, input);
+  }
+  addNonEvent(input) {
+    return addNonEvent(this, input);
+  }
+  getParentType(id) {
+    let indi;
+    if (typeof id === "string" || typeof id === "number") {
+      indi = this._gedcom?.indi(id);
+    } else {
+      indi = id;
+    }
+    if (!indi?.id || !this.id) {
+      return;
+    }
+    const parents = this.getParents();
+    let parent = parents.item(indi.id) ? indi : void 0;
+    let child = this._gedcom?.indi(this.id);
+    if (!parent?.id) {
+      const children = this.getChildren();
+      if (children.item(indi.id)) {
+        parent = this._gedcom?.indi(this.id);
+        child = indi;
+      }
+    }
+    const familiesOfChildren = child?.get("FAMC")?.toValueList();
+    if (!parent?.id || !child?.id || !familiesOfChildren) {
+      return;
+    }
+    const families = this.toFamilies(familiesOfChildren);
     let childType = "";
     families.forEach((family) => {
       if (childType) {
@@ -3739,7 +4475,7 @@ var Indi = class extends Common {
       if (!famChild) {
         const childIndi = this._gedcom?.indi(child.id);
         const childState = childIndi?.get("FAMC")?.toList()?.filter((item) => item.value === family.id).index(0);
-        childType = childState?.get("PEDI")?.toValue() || "biological" /* BIOLOGICAL */;
+        childType = (childState?.get("PEDI") ?? childState?.get("PEDT"))?.toValue() || "biological" /* BIOLOGICAL */;
       } else {
         childType = famChild.get(usedRel)?.toValue() || "biological" /* BIOLOGICAL */;
       }
@@ -3899,7 +4635,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 */;
@@ -4298,7 +5036,7 @@ var Indi = class extends Common {
             return;
           }
           const childState = child?.get("FAMC")?.toList()?.filter((item) => item.value === family.id).index(0);
-          const childType = childState?.get("PEDI")?.toValue() || "biological" /* BIOLOGICAL */;
+          const childType = (childState?.get("PEDI") ?? childState?.get("PEDT"))?.toValue() || "biological" /* BIOLOGICAL */;
           if (childType?.toLowerCase() === filter.PEDI.toLowerCase()) {
             children.append(child);
           }
@@ -4406,7 +5144,7 @@ var Indi = class extends Common {
       const child = this.id && family.CHIL?.toValueList()?.item(this.id);
       if (!child) {
         const childState = this?.get("FAMC")?.toList()?.filter((item) => item.value === family.id).index(0);
-        const parentType = childState?.get("PEDI")?.toValue() || "biological" /* BIOLOGICAL */;
+        const parentType = (childState?.get("PEDI") ?? childState?.get("PEDT"))?.toValue() || "biological" /* BIOLOGICAL */;
         if (parentType?.toLowerCase() === filter.PEDI.toLowerCase()) {
           parents.merge(family.getParents());
         }
@@ -6807,7 +7545,11 @@ var STANDARD_QUALIFIERS = {
   BEF: "Bef.",
   BEFORE: "Bef.",
   AFT: "Aft.",
-  AFTER: "Aft."
+  AFTER: "Aft.",
+  CAL: "Abt.",
+  // calculated ≈ about for display
+  EST: "Abt."
+  // estimated ≈ about for display
 };
 var EXPORT_QUALIFIERS = {
   "Abt.": "ABT",
@@ -6815,6 +7557,11 @@ var EXPORT_QUALIFIERS = {
   "Aft.": "AFT"
 };
 var GEDCOM_MONTHS = /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\b/g;
+var CALENDAR_PREFIX = /^(?<calendar>GREGORIAN|JULIAN|FRENCH_R|HEBREW)\b\s+/i;
+var isGedcomDateValueForm = (value) => (
+  // Require space/end after the token so display forms like "Abt." are not opaque.
+  /^(FROM|TO|BET|AFT|BEF|ABT|CAL|EST|INT)(\s|$)/i.test(value) || /\bAND\b/i.test(value)
+);
 var NOTE_MARKER = "####";
 var formatDateWithComponents = (date, hasDay, hasMonth, hasYear, noteValue, baseFormat = "dd MMM yyyy", locale) => {
   const hasNote = baseFormat.includes("NOTE");
@@ -6839,29 +7586,45 @@ var CommonDate = class extends Common {
     super(gedcom, id, main, parent);
     delete this.id;
   }
+  get calendar() {
+    return this._calendar;
+  }
   set value(value) {
     if (value) {
-      const noteRegExp = /^(?<note>[a-zA-Z]+\.)/;
-      const noteMatch = value.match(noteRegExp)?.groups;
       let validValue = value;
+      const calendarMatch = validValue.match(CALENDAR_PREFIX);
+      if (calendarMatch?.groups?.calendar) {
+        this._calendar = calendarMatch.groups.calendar.toUpperCase();
+        validValue = validValue.slice(calendarMatch[0].length);
+      } else {
+        this._calendar = void 0;
+      }
+      const noteRegExp = /^(?<note>[a-zA-Z]+\.)/;
+      const noteMatch = validValue.match(noteRegExp)?.groups;
       if (noteMatch?.note) {
         this.NOTE = this.NOTE || createCommon(this._gedcom, void 0, this.main);
         this.NOTE.value = noteMatch?.note;
-        validValue = value.replace(noteRegExp, "");
+        validValue = validValue.replace(noteRegExp, "");
       } else {
-        const qualifierMatch = value.match(
-          /^(?<qualifier>ABT|ABOUT|BEF|BEFORE|AFT|AFTER)\b\s*/i
+        const qualifierMatch = validValue.match(
+          /^(?<qualifier>ABT|ABOUT|BEF|BEFORE|AFT|AFTER|CAL|EST)\b\s*/i
         );
         const qualifier = qualifierMatch?.groups?.qualifier?.toUpperCase();
         const note = qualifier ? STANDARD_QUALIFIERS[qualifier] : void 0;
         if (note) {
           this.NOTE = this.NOTE || createCommon(this._gedcom, void 0, this.main);
           this.NOTE.value = note;
-          validValue = value.slice(qualifierMatch[0].length);
+          validValue = validValue.slice(qualifierMatch[0].length);
         }
       }
       const acceptedDate = this.isValidDateFormat(validValue);
-      if (acceptedDate) {
+      if (isGedcomDateValueForm(validValue.trim())) {
+        delete this.DAY;
+        delete this.MONTH;
+        delete this.YEAR;
+        this._date = void 0;
+        this._value = value;
+      } else if (acceptedDate) {
         this.DAY = this.DAY || createCommon(this._gedcom, void 0, this.main);
         this.DAY.value = format(acceptedDate, "dd");
         this.MONTH = this.MONTH || createCommon(this._gedcom, void 0, this.main);
@@ -6964,6 +7727,15 @@ var CommonDate = class extends Common {
     );
   }
   exportValue() {
+    if (typeof this._value === "string") {
+      const withoutCalendar = this._value.replace(CALENDAR_PREFIX, "");
+      if (isGedcomDateValueForm(withoutCalendar.trim())) {
+        return this._value.replace(
+          /^((?:GREGORIAN|JULIAN|FRENCH_R|HEBREW)\s+)?(FROM|TO|BET|AFT|BEF|ABT|CAL|EST|INT)\b/i,
+          (_m, cal, q) => `${cal || ""}${q.toUpperCase()}`
+        );
+      }
+    }
     const formatted = this.toValue("NOTE dd MMM yyyy", null);
     if (!formatted) {
       return formatted;
@@ -6971,10 +7743,14 @@ var CommonDate = class extends Common {
     const note = this.NOTE?.value?.trim();
     const qualifier = note ? EXPORT_QUALIFIERS[note] : void 0;
     const standardized = qualifier ? formatted.replace(note, qualifier) : formatted;
-    return standardized.replace(
+    const withMonths = standardized.replace(
       GEDCOM_MONTHS,
       (month) => month.toUpperCase()
     );
+    if (this._calendar && this._calendar !== "GREGORIAN") {
+      return `${this._calendar} ${withMonths}`;
+    }
+    return withMonths;
   }
   toGedcomLines(tag, level = 0, options) {
     const internal = new RegExp(
@@ -6995,130 +7771,1025 @@ var isCommonDate = (value) => {
   return !!value && value !== null && typeof value === "object" && "_date" in value;
 };
 
-// package.json
-var package_default = {
-  name: "@treeviz/gedcom-parser",
-  version: "2.0.10"};
-
-// src/utils/get-product-details.ts
-var isDevelopment = () => {
-  return !process.env.NODE_ENV || process.env.NODE_ENV === "development";
-};
-var getVersion = () => package_default.version;
-var getName = () => package_default.name;
-
-// src/classes/gedcom.ts
-var isObjectPatch = (value) => {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-};
-var GedCom = class extends Common {
-  constructor() {
-    super();
-    this.tagMembers = {};
-    this.reflist = {};
-    this.refcount = 0;
-    delete this._gedcom;
-    delete this.id;
-    this.removeValue();
-  }
-  getMain(type, index) {
-    const list = !type || type instanceof List ? type : this.getList(type);
-    if (!list) {
-      return void 0;
+// src/utils/gedcom-version.ts
+var GEDCOM_EXPORT_VERSIONS = ["5.5.1", "7.0"];
+var DEFAULT_GEDCOM_EXPORT_VERSION = "5.5.1";
+var normalizeGedcomVersion = (value) => {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.startsWith("7")) {
+    return "7.0";
+  }
+  return "5.5.1";
+};
+var isGedcom7 = (value) => normalizeGedcomVersion(value) === "7.0";
+var GEDZIP_MIME = "application/vnd.familysearch.gedcom+zip";
+var GEDZIP_EXTENSION = "gdz";
+var GEDZIP_GEDCOM_ENTRY = "gedcom.ged";
+var sanitizePathSegment = (name) => name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^\.+/, "") || "file";
+var extensionFor = (contentType) => {
+  const raw = (contentType || "bin").replace(/^\./, "").toLowerCase();
+  if (raw.includes("/")) {
+    return raw.split("/").pop() || "bin";
+  }
+  return raw || "bin";
+};
+var rewriteGedcomFilePaths = (gedcomText, urlToPath) => {
+  const entries = urlToPath instanceof Map ? urlToPath : new Map(Object.entries(urlToPath));
+  let text = gedcomText;
+  entries.forEach((path, url) => {
+    const escaped = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    text = text.replace(
+      new RegExp(`(^|\\r?\\n)(\\d+ FILE )${escaped}`, "g"),
+      `$1$2${path}`
+    );
+  });
+  return text;
+};
+var assignMediaPaths = (mediaFiles) => {
+  const urlToPath = /* @__PURE__ */ new Map();
+  const usedPaths = /* @__PURE__ */ new Set([GEDZIP_GEDCOM_ENTRY]);
+  const files = [];
+  for (const file of mediaFiles) {
+    if (!file.content || !file.url) {
+      continue;
     }
-    if (typeof index === "string") {
-      return list.item(index);
+    const ext = extensionFor(file.contentType);
+    const base = sanitizePathSegment(
+      file.imgId || file.title || file.id || "media"
+    );
+    let path = `media/${base}.${ext}`;
+    let suffix = 1;
+    while (usedPaths.has(path)) {
+      path = `media/${base}-${suffix++}.${ext}`;
+    }
+    usedPaths.add(path);
+    urlToPath.set(file.url, path);
+    const marker = "base64,";
+    const idx = file.content.indexOf(marker);
+    if (idx >= 0) {
+      files.push({
+        path,
+        url: file.url,
+        content: file.content.substring(idx + marker.length),
+        base64: true
+      });
+    } else {
+      files.push({
+        path,
+        url: file.url,
+        content: file.content,
+        base64: false
+      });
     }
-    const keys = list.keys();
-    return list.item(keys[index]);
-  }
-  getList(type) {
-    return this.get(type);
   }
-  createNodeFromPatchValue(value, main) {
-    if (value === void 0 || value === null) {
-      return void 0;
-    }
-    const node = createCommon(this, void 0, main);
-    if (Array.isArray(value)) {
-      value.forEach((item) => {
-        const childNode = this.createNodeFromPatchValue(item, node);
-        if (childNode) {
-          node.assign("DATA", childNode);
-        }
-      });
-      return node;
+  return { urlToPath, files };
+};
+var buildGedzip = async (gedcomText, mediaFiles = []) => {
+  const zip = new JSZip();
+  const { urlToPath, files } = assignMediaPaths(mediaFiles);
+  for (const file of files) {
+    zip.file(file.path, file.content, { base64: file.base64 });
+  }
+  zip.file(GEDZIP_GEDCOM_ENTRY, rewriteGedcomFilePaths(gedcomText, urlToPath));
+  return zip.generateAsync({ type: "uint8array" });
+};
+var normalizeZipPath = (name) => name.replace(/\\/g, "/").replace(/^\.\//, "");
+var MIME_BY_EXT = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  svg: "image/svg+xml",
+  pdf: "application/pdf"
+};
+var mimeForPath = (path) => {
+  const ext = (path.split(".").pop() || "").toLowerCase();
+  return MIME_BY_EXT[ext] || "application/octet-stream";
+};
+var bytesToBase64 = (bytes) => {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+};
+var bytesToDataUrl = (bytes, mime) => `data:${mime};base64,${bytesToBase64(bytes)}`;
+var remountGedzipMediaAsDataUrls = (extracted) => {
+  if (!extracted.mediaEntries.length) {
+    return extracted.gedcomText;
+  }
+  const pathToDataUrl = /* @__PURE__ */ new Map();
+  for (const media of extracted.mediaEntries) {
+    const path = normalizeZipPath(media.path);
+    const dataUrl = bytesToDataUrl(media.content, mimeForPath(path));
+    pathToDataUrl.set(path, dataUrl);
+    pathToDataUrl.set(`./${path}`, dataUrl);
+    const base = path.split("/").pop();
+    if (base) {
+      pathToDataUrl.set(base, dataUrl);
+      pathToDataUrl.set(`media/${base}`, dataUrl);
+    }
+  }
+  return rewriteGedcomFilePaths(extracted.gedcomText, pathToDataUrl);
+};
+var extractGedzip = async (data) => {
+  const zip = await JSZip.loadAsync(data);
+  const entries = Object.values(zip.files).filter((entry) => !entry.dir);
+  const preferred = entries.find(
+    (entry) => normalizeZipPath(entry.name).toLowerCase() === GEDZIP_GEDCOM_ENTRY
+  ) ?? entries.find(
+    (entry) => normalizeZipPath(entry.name).toLowerCase().endsWith(".ged")
+  );
+  if (!preferred) {
+    throw new Error("No .ged file found in the archive.");
+  }
+  const gedcomText = await preferred.async("string");
+  const mediaEntries = [];
+  for (const entry of entries) {
+    const path = normalizeZipPath(entry.name);
+    if (path === normalizeZipPath(preferred.name)) {
+      continue;
     }
-    if (isObjectPatch(value)) {
-      this.applyObjectToCommon(node, value);
-      return node;
+    if (path.toLowerCase().endsWith(".ged")) {
+      continue;
     }
-    node.value = String(value);
-    return node;
+    mediaEntries.push({
+      path,
+      content: await entry.async("uint8array")
+    });
   }
-  applyObjectToCommon(target, patch) {
-    Object.entries(patch).forEach(([rawTag, value]) => {
-      if (rawTag === "value") {
-        if (value === null || value === void 0 || Array.isArray(value) || isObjectPatch(value)) {
+  return {
+    gedcomText,
+    entryName: normalizeZipPath(preferred.name),
+    mediaEntries
+  };
+};
+var extractGedzipGedcom = async (data, options) => {
+  const extracted = await extractGedzip(data);
+  if (options?.embedMediaAsDataUrls === false) {
+    return extracted.gedcomText;
+  }
+  return remountGedzipMediaAsDataUrls(extracted);
+};
+var isGedzipContainer = (file) => {
+  const name = (file.name || "").toLowerCase();
+  const type = (file.type || "").toLowerCase();
+  return name.endsWith(`.${GEDZIP_EXTENSION}`) || name.endsWith(".zip") || type === GEDZIP_MIME || type === "application/zip" || type === "application/x-zip-compressed";
+};
+var downloadGedzipMedia = async (media, onProgress) => {
+  const entries = Object.values(media).filter((item) => !!item.url);
+  const total = entries.length;
+  let done = 0;
+  const downloaded = [];
+  await Promise.all(
+    entries.map(async (item) => {
+      try {
+        const resolved = await resolveMediaContent({
+          url: item.url,
+          id: item.id,
+          imgId: item.imgId,
+          key: "key" in item ? item.key : void 0,
+          contentType: item.contentType
+        });
+        if (!resolved?.content) {
           return;
         }
-        target.value = String(value);
-        return;
-      }
-      if (rawTag === "id") {
-        if (typeof value === "string") {
-          target.id = value;
-        }
-        return;
-      }
-      const tag = rawTag;
-      if (value === void 0) {
-        return;
-      }
-      if (value === null) {
-        target.remove(tag);
-        return;
-      }
-      if (Array.isArray(value)) {
-        target.remove(tag);
-        value.forEach((item) => {
-          const listNode = this.createNodeFromPatchValue(
-            item,
-            target.main ?? this
-          );
-          if (listNode) {
-            target.assign(tag, listNode);
-          }
+        downloaded.push({
+          ...item,
+          content: resolved.content,
+          contentType: resolved.contentType || item.contentType
         });
-        return;
-      }
-      if (isObjectPatch(value)) {
-        const existing = target.get(tag);
-        const objectNode = existing ?? createCommon(this, void 0, target.main ?? this);
-        this.applyObjectToCommon(objectNode, value);
-        target.set(tag, objectNode);
-        return;
+      } catch {
+      } finally {
+        done += 1;
+        onProgress?.(done, total);
       }
-      target.set(tag, String(value));
+    })
+  );
+  return downloaded;
+};
+var buildGedzipBlob = async (gedcomText, mediaFiles = []) => {
+  const bytes = await buildGedzip(gedcomText, mediaFiles);
+  return new Blob([bytes], { type: GEDZIP_MIME });
+};
+
+// src/utils/gedcom7-enumerations.ts
+var GEDCOM7_SEX_VALUES = ["M", "F", "U", "X", "N"];
+var GEDCOM7_PEDI_VALUES = [
+  "adopted",
+  "birth",
+  "foster",
+  "sealing"
+];
+var GEDCOM7_ROLE_VALUES = [
+  "CHIL",
+  "CLERGY",
+  "FATH",
+  "FRIEND",
+  "GODP",
+  "HUSB",
+  "MOTH",
+  "MULTIPLE",
+  "NGHBR",
+  "OFFICIATOR",
+  "OTHER",
+  "PARENT",
+  "SPOU",
+  "WIFE",
+  "WITN"
+];
+var GEDCOM7_RESN_VALUES = [
+  "CONFIDENTIAL",
+  "LOCKED",
+  "PRIVACY"
+];
+var isAllowed = (value, allowed) => allowed.includes(value);
+var moveToPhrase = (node, phrase) => {
+  const previousValue = node.value;
+  const previousPhrase = node.get("PHRASE");
+  const previousPhraseValue = previousPhrase?.toValue();
+  node.removeValue();
+  if (previousPhrase) {
+    previousPhrase.value = phrase;
+  } else {
+    const phraseNode = createCommon(node.getGedcom(), void 0, node.main);
+    phraseNode.value = phrase;
+    node.set("PHRASE", phraseNode);
+  }
+  return () => {
+    if (previousValue === void 0) {
+      node.removeValue();
+    } else {
+      node.value = previousValue;
+    }
+    if (previousPhrase) {
+      previousPhrase.value = previousPhraseValue;
+    } else {
+      node.remove("PHRASE");
+    }
+  };
+};
+var normalizeEnum = (node, allowed, mode, restores) => {
+  const value = node?.toValue();
+  if (!node || typeof value !== "string" || !value.trim()) {
+    return;
+  }
+  const normalized = mode === "upper" ? value.trim().toUpperCase() : value.trim().toLowerCase();
+  if (isAllowed(normalized, allowed)) {
+    if (value !== normalized) {
+      const previous = node.value;
+      node.value = normalized;
+      restores.push(() => {
+        node.value = previous;
+      });
+    }
+    return;
+  }
+  restores.push(moveToPhrase(node, value.trim()));
+};
+var applyGedcom7Enumerations = (gedcom) => {
+  const restores = [];
+  gedcom.indis()?.forEach((indi) => {
+    if (!indi) return;
+    normalizeEnum(indi.get("SEX"), GEDCOM7_SEX_VALUES, "upper", restores);
+    normalizeEnum(indi.get("RESN"), GEDCOM7_RESN_VALUES, "upper", restores);
+    indi.get("FAMC")?.toList()?.forEach((famc) => {
+      normalizeEnum(
+        famc?.get("PEDI") ?? famc?.get("PEDT"),
+        GEDCOM7_PEDI_VALUES,
+        "lower",
+        restores
+      );
+    });
+    indi.get("ASSO")?.toList()?.forEach((asso) => {
+      normalizeEnum(
+        asso?.get("ROLE"),
+        GEDCOM7_ROLE_VALUES,
+        "upper",
+        restores
+      );
     });
+  });
+  gedcom.fams()?.forEach((fam) => {
+    if (!fam) return;
+    normalizeEnum(fam.get("RESN"), GEDCOM7_RESN_VALUES, "upper", restores);
+    fam.get("ASSO")?.toList()?.forEach((asso) => {
+      normalizeEnum(
+        asso?.get("ROLE"),
+        GEDCOM7_ROLE_VALUES,
+        "upper",
+        restores
+      );
+    });
+  });
+  return () => {
+    for (let i = restores.length - 1; i >= 0; i -= 1) {
+      restores[i]?.();
+    }
+  };
+};
+
+// src/utils/gedcom7-dates.ts
+var GEDCOM7_CALENDARS = [
+  "GREGORIAN",
+  "JULIAN",
+  "FRENCH_R",
+  "HEBREW"
+];
+var CALENDAR_PREFIX2 = /^(?<calendar>GREGORIAN|JULIAN|FRENCH_R|HEBREW)\b\s+/i;
+var parseGedcom7CalendarPrefix = (value) => {
+  const match = value.match(CALENDAR_PREFIX2);
+  if (!match?.groups?.calendar) {
+    return { calendar: void 0, rest: value };
   }
-  applyObject(patch) {
-    this.applyObjectToCommon(this, patch);
-    return this;
+  return {
+    calendar: match.groups.calendar.toUpperCase(),
+    rest: value.slice(match[0].length)
+  };
+};
+var withGedcom7Calendar = (value, calendar) => {
+  if (!calendar || calendar.toUpperCase() === "GREGORIAN") {
+    return value;
   }
-  indis() {
-    return this.getList("@@INDI");
+  const upper = calendar.toUpperCase();
+  if (GEDCOM7_CALENDARS.includes(upper)) {
+    const { rest } = parseGedcom7CalendarPrefix(value);
+    return `${upper} ${rest}`.trim();
   }
-  cloneIndis(target, source, avoidKeys = [], removeFromOriginalList = true) {
-    const hasFAMS = avoidKeys.includes("FAMS");
-    const targetIndi = typeof target === "string" ? this.indi(target) : target;
-    const sourceIndi = typeof source === "string" ? this.indi(source) : source;
-    if (!targetIndi || !sourceIndi) {
-      return this;
+  return value;
+};
+var applyGedcom7DatePhrases = (gedcom) => {
+  const restores = [];
+  const visitDate = (dateNode) => {
+    if (!dateNode || typeof dateNode.toValue !== "function") {
+      return;
     }
-    const spousesFamily = hasFAMS ? sourceIndi.FAMS?.toList() : void 0;
-    const childrenFamily = sourceIndi.FAMC?.toList();
-    const cloned = targetIndi.clone(false, avoidKeys);
+    const asDate = dateNode;
+    const hasComponents = !!(asDate.DAY || asDate.MONTH || asDate.YEAR);
+    const raw = dateNode.exportValue?.() ?? dateNode.toValue();
+    if (typeof raw !== "string" || !raw.trim()) {
+      return;
+    }
+    const { calendar, rest } = parseGedcom7CalendarPrefix(raw.trim());
+    const looksStructured = hasComponents || /^(ABT|CAL|EST|BEF|AFT|FROM|TO|BET|INT)(\s|$)/i.test(rest) || /\bAND\b/i.test(rest) || /^\d{1,2}\s+[A-Z]{3}\s+\d{1,4}/i.test(rest) || /^[A-Z]{3}\s+\d{1,4}/i.test(rest) || /^\d{1,4}$/.test(rest);
+    if (looksStructured) {
+      if (calendar && calendar !== "GREGORIAN") {
+        const previous = dateNode.value;
+        const next = withGedcom7Calendar(rest, calendar);
+        if (previous !== next) {
+          dateNode.value = next;
+          restores.push(() => {
+            dateNode.value = previous;
+          });
+        }
+      }
+      return;
+    }
+    const previousValue = dateNode.value;
+    const previousPhrase = dateNode.get("PHRASE");
+    const previousPhraseValue = previousPhrase?.toValue();
+    dateNode.removeValue();
+    if (previousPhrase) {
+      previousPhrase.value = raw.trim();
+    } else {
+      const phrase = createCommon(
+        dateNode.getGedcom(),
+        void 0,
+        dateNode.main
+      );
+      phrase.value = raw.trim();
+      dateNode.set("PHRASE", phrase);
+    }
+    restores.push(() => {
+      if (previousValue === void 0) {
+        dateNode.removeValue();
+      } else {
+        dateNode.value = previousValue;
+      }
+      if (previousPhrase) {
+        previousPhrase.value = previousPhraseValue;
+      } else {
+        dateNode.remove("PHRASE");
+      }
+    });
+  };
+  const walk = (node) => {
+    if (!node) return;
+    node.get("DATE")?.toList()?.forEach((item) => visitDate(item));
+    node.get("SDATE")?.toList()?.forEach((item) => visitDate(item));
+  };
+  gedcom.indis()?.forEach((indi) => {
+    if (!indi) return;
+    walk(indi);
+    [
+      "BIRT",
+      "DEAT",
+      "CHR",
+      "BAPM",
+      "BURI",
+      "CREM",
+      "ADOP",
+      "EVEN",
+      "RESI",
+      "OCCU",
+      "MARR"
+    ].forEach((tag) => {
+      indi.get(tag)?.toList()?.forEach((event) => walk(event));
+    });
+  });
+  gedcom.fams()?.forEach((fam) => {
+    if (!fam) return;
+    ["MARR", "DIV", "ENGA", "ANUL", "EVEN"].forEach((tag) => {
+      fam.get(tag)?.toList()?.forEach((event) => walk(event));
+    });
+  });
+  return () => {
+    for (let i = restores.length - 1; i >= 0; i -= 1) {
+      restores[i]?.();
+    }
+  };
+};
+
+// src/utils/uid.ts
+var createGedcomUid = () => {
+  const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
+    return cryptoObj.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+    const rand = Math.random() * 16 | 0;
+    const value = char === "x" ? rand : rand & 3 | 8;
+    return value.toString(16);
+  });
+};
+
+// src/utils/gedcom7-metadata.ts
+var GEDCOM_MONTHS2 = [
+  "JAN",
+  "FEB",
+  "MAR",
+  "APR",
+  "MAY",
+  "JUN",
+  "JUL",
+  "AUG",
+  "SEP",
+  "OCT",
+  "NOV",
+  "DEC"
+];
+var formatGedcom7Timestamp = (date = /* @__PURE__ */ new Date()) => {
+  const day = String(date.getUTCDate());
+  const month = GEDCOM_MONTHS2[date.getUTCMonth()];
+  const year = String(date.getUTCFullYear());
+  const hh = String(date.getUTCHours()).padStart(2, "0");
+  const mm = String(date.getUTCMinutes()).padStart(2, "0");
+  const ss = String(date.getUTCSeconds()).padStart(2, "0");
+  return {
+    date: `${day} ${month} ${year}`,
+    time: `${hh}:${mm}:${ss}Z`
+  };
+};
+var ensureMetaDate = (gedcom, record, tag, when, restores) => {
+  if (record.get(tag)) {
+    return;
+  }
+  const { date, time } = formatGedcom7Timestamp(when);
+  const meta = createCommon(gedcom, void 0, record);
+  meta.type = tag;
+  const dateNode = createCommonDate(gedcom, void 0, record, meta);
+  dateNode.type = "DATE";
+  dateNode.value = date;
+  dateNode.set("TIME", time);
+  meta.set("DATE", dateNode);
+  record.set(tag, meta);
+  restores.push(() => {
+    record.remove(tag);
+  });
+};
+var ensureUid = (record, restores) => {
+  const existing = record.get("UID")?.toValue();
+  if (typeof existing === "string" && existing.trim()) {
+    return;
+  }
+  const uid = createGedcomUid();
+  record.set("UID", uid);
+  restores.push(() => {
+    record.remove("UID");
+  });
+};
+var applyGedcom7RecordMetadata = (gedcom, options) => {
+  const restores = [];
+  const now = options?.now ?? /* @__PURE__ */ new Date();
+  const visit = (record) => {
+    if (!record?.id) {
+      return;
+    }
+    ensureUid(record, restores);
+    ensureMetaDate(gedcom, record, "CREA", now, restores);
+    ensureMetaDate(gedcom, record, "CHAN", now, restores);
+  };
+  gedcom.indis()?.forEach((indi) => visit(indi));
+  gedcom.fams()?.forEach((fam) => visit(fam));
+  gedcom.objes()?.forEach((obje) => visit(obje));
+  gedcom.sours()?.forEach((sour) => visit(sour));
+  gedcom.repos()?.forEach((repo) => visit(repo));
+  gedcom.subms()?.forEach((subm) => visit(subm));
+  gedcom.snotes()?.forEach((note) => visit(note));
+  return () => {
+    for (let i = restores.length - 1; i >= 0; i -= 1) {
+      restores[i]?.();
+    }
+  };
+};
+
+// src/utils/gedcom7-schema.ts
+var TREEVIZ_EXTENSION_BASE_URI = "https://treeviz.com/gedcom";
+var TREEVIZ_EXTENSION_URIS = {
+  _ORIGHEAD: `${TREEVIZ_EXTENSION_BASE_URI}#_ORIGHEAD`,
+  _TREE: `${TREEVIZ_EXTENSION_BASE_URI}#_TREE`,
+  _TID: `${TREEVIZ_EXTENSION_BASE_URI}#_TID`,
+  _PRIM: `${TREEVIZ_EXTENSION_BASE_URI}#_PRIM`,
+  _FREL: `${TREEVIZ_EXTENSION_BASE_URI}#_FREL`,
+  _MREL: `${TREEVIZ_EXTENSION_BASE_URI}#_MREL`,
+  _SREL: `${TREEVIZ_EXTENSION_BASE_URI}#_SREL`,
+  _UID: `${TREEVIZ_EXTENSION_BASE_URI}#_UID`,
+  _WLNK: `${TREEVIZ_EXTENSION_BASE_URI}#_WLNK`,
+  _MTTAG: `${TREEVIZ_EXTENSION_BASE_URI}#_MTTAG`,
+  _MTCAT: `${TREEVIZ_EXTENSION_BASE_URI}#_MTCAT`,
+  _CLON: `${TREEVIZ_EXTENSION_BASE_URI}#_CLON`,
+  _MSER: `${TREEVIZ_EXTENSION_BASE_URI}#_MSER`,
+  _OID: `${TREEVIZ_EXTENSION_BASE_URI}#_OID`,
+  _LKID: `${TREEVIZ_EXTENSION_BASE_URI}#_LKID`,
+  _PHOTO_RIN: `${TREEVIZ_EXTENSION_BASE_URI}#_PHOTO_RIN`,
+  _EXPORTED_FROM_SITE_ID: `${TREEVIZ_EXTENSION_BASE_URI}#_EXPORTED_FROM_SITE_ID`,
+  _FS_ID: `${TREEVIZ_EXTENSION_BASE_URI}#_FS_ID`,
+  _FS_LINK: `${TREEVIZ_EXTENSION_BASE_URI}#_FS_LINK`,
+  _FS_MATCH: `${TREEVIZ_EXTENSION_BASE_URI}#_FS_MATCH`,
+  _FS_SOUR: `${TREEVIZ_EXTENSION_BASE_URI}#_FS_SOUR`,
+  _IS_FS: `${TREEVIZ_EXTENSION_BASE_URI}#_IS_FS`,
+  _LABEL: `${TREEVIZ_EXTENSION_BASE_URI}#_LABEL`,
+  _MILT: `${TREEVIZ_EXTENSION_BASE_URI}#_MILT`,
+  _MILTID: `${TREEVIZ_EXTENSION_BASE_URI}#_MILTID`,
+  _ORIG: `${TREEVIZ_EXTENSION_BASE_URI}#_ORIG`,
+  _ENV: `${TREEVIZ_EXTENSION_BASE_URI}#_ENV`,
+  _TREEVIZ_SETTINGS: `${TREEVIZ_EXTENSION_BASE_URI}#_TREEVIZ_SETTINGS`,
+  _TREEVIZ_VIEW: `${TREEVIZ_EXTENSION_BASE_URI}#_TREEVIZ_VIEW`,
+  _TREEVIZ_DETECTIVE: `${TREEVIZ_EXTENSION_BASE_URI}#_TREEVIZ_DETECTIVE`,
+  _TREEVIZ_DETECTIVE_STATE: `${TREEVIZ_EXTENSION_BASE_URI}#_TREEVIZ_DETECTIVE_STATE`
+};
+var parseTagDefinition = (payload) => {
+  const trimmed = payload.trim();
+  const space = trimmed.indexOf(" ");
+  if (space <= 0) {
+    return void 0;
+  }
+  const tag = trimmed.slice(0, space).trim();
+  const uri = trimmed.slice(space + 1).trim();
+  if (!tag || !uri) {
+    return void 0;
+  }
+  return { tag, uri };
+};
+var getExtensionSchema = (gedcom) => {
+  const map = /* @__PURE__ */ new Map();
+  const schma = gedcom.get("HEAD")?.get("SCHMA");
+  if (!schma) {
+    return map;
+  }
+  schma.get("TAG")?.toList()?.forEach((tagNode) => {
+    const payload = tagNode?.toValue();
+    if (typeof payload !== "string") {
+      return;
+    }
+    const parsed = parseTagDefinition(payload);
+    if (parsed) {
+      map.set(parsed.tag.toUpperCase(), parsed.uri);
+    }
+  });
+  return map;
+};
+var ensureSchemaNode = (gedcom) => {
+  const head = gedcom.get("HEAD");
+  if (!head) {
+    return void 0;
+  }
+  let schma = head.get("SCHMA");
+  if (!schma) {
+    schma = createCommon(gedcom, void 0, head);
+    head.set("SCHMA", schma);
+  }
+  return schma;
+};
+var registerExtensionTag = (gedcom, tag, uri) => {
+  const normalizedTag = tag.trim().toUpperCase();
+  const normalizedUri = uri.trim();
+  if (!normalizedTag.startsWith("_") || !normalizedUri) {
+    return void 0;
+  }
+  const schma = ensureSchemaNode(gedcom);
+  if (!schma) {
+    return void 0;
+  }
+  const payload = `${normalizedTag} ${normalizedUri}`;
+  const existingList = schma.get("TAG")?.toList();
+  const existing = existingList?.values().find((node) => {
+    const value = node?.toValue();
+    return typeof value === "string" && value.trim().toUpperCase().startsWith(`${normalizedTag} `);
+  });
+  if (existing) {
+    existing.value = payload;
+    return existing;
+  }
+  const tagNode = createCommon(gedcom, void 0, schma);
+  tagNode.value = payload;
+  schma.assign("TAG", tagNode);
+  return tagNode;
+};
+var ensureExtensionSchema = (gedcom, extraTags) => {
+  const head = gedcom.get("HEAD");
+  const hadSchma = !!head?.get("SCHMA");
+  const previousPayloads = head?.get("SCHMA")?.get("TAG")?.toList()?.values().map((node) => ({
+    node,
+    value: node?.toValue()
+  })) ?? [];
+  const tags = /* @__PURE__ */ new Set([
+    ...Object.keys(TREEVIZ_EXTENSION_URIS),
+    ...(extraTags ?? []).map((tag) => tag.toUpperCase())
+  ]);
+  tags.forEach((tag) => {
+    const uri = TREEVIZ_EXTENSION_URIS[tag] ?? `${TREEVIZ_EXTENSION_BASE_URI}#${tag}`;
+    if (tag.startsWith("_")) {
+      registerExtensionTag(gedcom, tag, uri);
+    }
+  });
+  return () => {
+    if (!head) {
+      return;
+    }
+    if (!hadSchma) {
+      head.remove("SCHMA");
+      return;
+    }
+    const schma = head.get("SCHMA");
+    const list = schma?.get("TAG")?.toList();
+    const keep = new Set(
+      previousPayloads.map(
+        (item) => typeof item.value === "string" ? item.value : void 0
+      ).filter((value) => !!value)
+    );
+    list?.values().forEach((node) => {
+      const value = node?.toValue();
+      if (typeof value === "string" && !keep.has(value) && node) {
+        list.delete(node);
+      }
+    });
+    previousPayloads.forEach(({ node, value }) => {
+      if (node && value !== void 0) {
+        node.value = value;
+      }
+    });
+  };
+};
+var collectExtensionTagsFrom = (node, into = /* @__PURE__ */ new Set()) => {
+  if (!node) {
+    return into;
+  }
+  const keys = Object.keys(node).filter(
+    (key) => key.startsWith("_") && !key.startsWith("_gedcom") && !key.startsWith("_value") && !key.startsWith("_id") && !key.startsWith("_main") && !key.startsWith("_parent") && !key.startsWith("_unique") && !key.startsWith("_type") && !key.startsWith("_refs") && !key.startsWith("_date")
+  );
+  keys.forEach((key) => {
+    const tag = key.toUpperCase();
+    if (/^_[A-Z0-9_]+$/.test(tag)) {
+      into.add(tag);
+    }
+  });
+  return into;
+};
+
+// package.json
+var package_default = {
+  name: "@treeviz/gedcom-parser",
+  version: "2.1.0"};
+
+// src/utils/get-product-details.ts
+var isDevelopment = () => {
+  return !process.env.NODE_ENV || process.env.NODE_ENV === "development";
+};
+var getVersion = () => package_default.version;
+var getName = () => package_default.name;
+
+// src/utils/multimedia.ts
+var inferMediaForm = (file, fallback = "bin") => {
+  const withoutQuery = file.split("?")[0] || file;
+  const ext = getFileExtension(withoutQuery);
+  if (ext) {
+    return ext.toLowerCase() === "jpeg" ? "jpg" : ext.toLowerCase();
+  }
+  return fallback;
+};
+var mergeMediaLists = (...lists) => {
+  const merged = {};
+  for (const list of lists) {
+    if (!list) continue;
+    Object.assign(merged, list);
+  }
+  return merged;
+};
+var isObjePointer = (value) => typeof value === "string" && /^@O\d+@$/.test(value);
+
+// src/classes/note.ts
+var CommonNote = class extends Common {
+  constructor(gedcom, id, main, parent) {
+    super(gedcom, id, main, parent);
+    if (!id) {
+      delete this.id;
+    }
+  }
+  set value(value) {
+    const [note, ...contents] = value?.split(/\r?\n/) ?? [];
+    this._value = note;
+    if (contents.length) {
+      const newContents = new List();
+      contents.forEach((c, i) => {
+        const newContent = createCommon(
+          this._gedcom,
+          void 0,
+          this.main
+        );
+        newContent.id = `@U${i}@`;
+        newContent.value = c;
+        newContents.append(newContent);
+      });
+      const firstItem = newContents.index(0);
+      if (firstItem) {
+        if (newContents.length === 1) {
+          this.set("CONT", firstItem);
+        } else {
+          this.set("CONT", newContents);
+        }
+      }
+    }
+  }
+  get value() {
+    const contents = this.get("CONT")?.toList().map((content) => content.value).join("\n");
+    if (contents) {
+      return `${this._value}
+${contents}`;
+    }
+    return this._value;
+  }
+  exportValue() {
+    return this._value;
+  }
+};
+var createCommonNote = (gedcom, id, main, parent) => {
+  return createProxy(
+    new CommonNote(gedcom, id, main, parent)
+  );
+};
+
+// src/classes/obje.ts
+var Obje = class extends Common {
+  standardizeMedia(namespace, override = true, urlGetter, gedcomVersion) {
+    if (!this._gedcom) {
+      return this;
+    }
+    const rin = this?.get("RIN")?.toValue();
+    const clone = this?.get("_CLON._OID")?.toValue();
+    const mser = this?.get("_MSER._LKID")?.toValue();
+    const title = this?.get("FILE.TITL")?.toValue() ?? this?.get("TITL")?.toValue() ?? "";
+    const note = this?.get("FILE.NOTE")?.toValue() ?? this?.get("NOTE")?.toValue() ?? "";
+    const formRaw = this?.get("FILE.FORM")?.toValue() ?? this?.get("FORM")?.toValue();
+    const mediType = this?.get("FILE.FORM.TYPE")?.toValue() ?? this?.get("FORM.TYPE")?.toValue() ?? this?.get("MEDI")?.toValue();
+    const file = this?.get("FILE")?.toValue();
+    const imgId = rin || clone || mser;
+    const url = file || namespace && urlGetter?.(namespace, imgId);
+    if (!url) {
+      return this;
+    }
+    const version = normalizeGedcomVersion(
+      gedcomVersion ?? this._gedcom.getGedcomVersion?.()
+    );
+    const form = formRaw || inferMediaForm(String(url));
+    const newObject = createObje(this._gedcom, this.id, this.main);
+    if (!override) {
+      Object.assign(newObject, this);
+    }
+    const fileNode = createCommon(this._gedcom, void 0, this.main);
+    fileNode.value = url;
+    if (version === "7.0") {
+      const formNode = createCommon(this._gedcom, void 0, fileNode);
+      formNode.value = form;
+      if (mediType) {
+        formNode.set("TYPE", String(mediType));
+      }
+      fileNode.set("FORM", formNode);
+      if (title) {
+        fileNode.set("TITL", String(title));
+      }
+      if (note) {
+        fileNode.set("NOTE", String(note));
+      }
+      newObject.set("FILE", fileNode);
+    } else {
+      newObject.set("FILE", fileNode);
+      newObject.set("FORM", form);
+      if (mediType) {
+        newObject.set("MEDI", String(mediType));
+      }
+      if (title) {
+        newObject.set("TITL", String(title));
+        if (!note) {
+          newObject.set("NOTE", String(title));
+        }
+      }
+      if (note) {
+        newObject.set("NOTE", String(note));
+        if (!title) {
+          newObject.set("TITL", String(note));
+        }
+      }
+    }
+    const prim = this.get("_PRIM")?.toValue();
+    if (prim === "Y" || prim === "N") {
+      newObject.set("_PRIM", prim);
+    }
+    const photoRin = this.get("_PHOTO_RIN")?.toValue();
+    if (rin) {
+      newObject.set("RIN", String(rin));
+    }
+    if (photoRin) {
+      newObject.set("_PHOTO_RIN", String(photoRin));
+    }
+    const clonNode = this.get("_CLON");
+    if (clonNode) {
+      newObject.set("_CLON", clonNode);
+    }
+    const mserNode = this.get("_MSER");
+    if (mserNode) {
+      newObject.set("_MSER", mserNode);
+    }
+    const oidNode = this.get("_OID");
+    if (oidNode && !newObject.get("_OID")) {
+      newObject.set("_OID", oidNode);
+    }
+    const lkidNode = this.get("_LKID");
+    if (lkidNode && !newObject.get("_LKID")) {
+      newObject.set("_LKID", lkidNode);
+    }
+    if (override) {
+      this.remove("FILE");
+      this.remove("FORM");
+      this.remove("MEDI");
+      this.remove("TITL");
+      this.remove("NOTE");
+      Object.assign(this, newObject);
+      return this;
+    }
+    return newObject;
+  }
+};
+var createObje = (gedcom, id, main, parent) => {
+  return createProxy(
+    new Obje(gedcom, id, main, parent)
+  );
+};
+
+// src/classes/objes.ts
+var Objects = class _Objects extends List {
+  copy() {
+    const newList = new _Objects();
+    this.entries().forEach(([key, value]) => {
+      newList.item(key, value);
+    });
+    return newList;
+  }
+  except(item) {
+    return this.copy().delete(item);
+  }
+};
+
+// src/classes/gedcom.ts
+var isObjectPatch = (value) => {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+};
+var GedCom = class extends Common {
+  constructor() {
+    super();
+    this.tagMembers = {};
+    this.reflist = {};
+    this.refcount = 0;
+    delete this._gedcom;
+    delete this.id;
+    this.removeValue();
+  }
+  getMain(type, index) {
+    const list = !type || type instanceof List ? type : this.getList(type);
+    if (!list) {
+      return void 0;
+    }
+    if (typeof index === "string") {
+      return list.item(index);
+    }
+    const keys = list.keys();
+    return list.item(keys[index]);
+  }
+  getList(type) {
+    return this.get(type);
+  }
+  createNodeFromPatchValue(value, main) {
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    const node = createCommon(this, void 0, main);
+    if (Array.isArray(value)) {
+      value.forEach((item) => {
+        const childNode = this.createNodeFromPatchValue(item, node);
+        if (childNode) {
+          node.assign("DATA", childNode);
+        }
+      });
+      return node;
+    }
+    if (isObjectPatch(value)) {
+      this.applyObjectToCommon(node, value);
+      return node;
+    }
+    node.value = String(value);
+    return node;
+  }
+  applyObjectToCommon(target, patch) {
+    Object.entries(patch).forEach(([rawTag, value]) => {
+      if (rawTag === "value") {
+        if (value === null || value === void 0 || Array.isArray(value) || isObjectPatch(value)) {
+          return;
+        }
+        target.value = String(value);
+        return;
+      }
+      if (rawTag === "id") {
+        if (typeof value === "string") {
+          target.id = value;
+        }
+        return;
+      }
+      const tag = rawTag;
+      if (value === void 0) {
+        return;
+      }
+      if (value === null) {
+        target.remove(tag);
+        return;
+      }
+      if (Array.isArray(value)) {
+        target.remove(tag);
+        value.forEach((item) => {
+          const listNode = this.createNodeFromPatchValue(
+            item,
+            target.main ?? this
+          );
+          if (listNode) {
+            target.assign(tag, listNode);
+          }
+        });
+        return;
+      }
+      if (isObjectPatch(value)) {
+        const existing = target.get(tag);
+        const objectNode = existing ?? createCommon(this, void 0, target.main ?? this);
+        this.applyObjectToCommon(objectNode, value);
+        target.set(tag, objectNode);
+        return;
+      }
+      target.set(tag, String(value));
+    });
+  }
+  applyObject(patch) {
+    this.applyObjectToCommon(this, patch);
+    return this;
+  }
+  indis() {
+    return this.getList("@@INDI");
+  }
+  cloneIndis(target, source, avoidKeys = [], removeFromOriginalList = true) {
+    const hasFAMS = avoidKeys.includes("FAMS");
+    const targetIndi = typeof target === "string" ? this.indi(target) : target;
+    const sourceIndi = typeof source === "string" ? this.indi(source) : source;
+    if (!targetIndi || !sourceIndi) {
+      return this;
+    }
+    const spousesFamily = hasFAMS ? sourceIndi.FAMS?.toList() : void 0;
+    const childrenFamily = sourceIndi.FAMC?.toList();
+    const cloned = targetIndi.clone(false, avoidKeys);
     const newCloned = sourceIndi.merge(cloned);
     newCloned.cloneOf = targetIndi.id;
     targetIndi.clonedBy = newCloned.id;
@@ -7202,6 +8873,189 @@ 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";
+    if (this.getGedcomVersion() === "7.0") {
+      indi.set("UID", createGedcomUid());
+    }
+    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";
+    if (this.getGedcomVersion() === "7.0") {
+      fam.set("UID", createGedcomUid());
+    }
+    fams.item(id, fam);
+    return fam;
+  }
+  nextObjeKey() {
+    const ids = [];
+    this.objes()?.forEach((_obje, id) => {
+      ids.push(String(id));
+    });
+    return nextRecordId(ids, "O");
+  }
+  /**
+   * Create a top-level multimedia record (`0 @On@ OBJE`) with FILE/FORM/TITL.
+   * GEDCOM 7 uses nested `FILE → FORM [→ TYPE]`; 5.5.1 uses sibling FORM/TITL.
+   */
+  createMultimediaRecord(input) {
+    const existing = this.objes();
+    const objes = existing ?? new Objects();
+    if (!existing) {
+      this.set("@@OBJE", objes);
+    }
+    const id = this.nextObjeKey();
+    const obje = createObje(this, id);
+    obje.type = "OBJE";
+    objes.item(id, obje);
+    const version = normalizeGedcomVersion(
+      input.gedcomVersion ?? this.getGedcomVersion()
+    );
+    const form = input.form || inferMediaForm(input.file);
+    const fileNode = createCommon(this, void 0, obje);
+    fileNode.value = input.file;
+    if (version === "7.0") {
+      const formNode = createCommon(
+        this,
+        void 0,
+        fileNode
+      );
+      formNode.value = form;
+      if (input.mediType) {
+        formNode.set("TYPE", input.mediType);
+      }
+      fileNode.set("FORM", formNode);
+      if (input.title) {
+        fileNode.set("TITL", input.title);
+      }
+      obje.set("FILE", fileNode);
+    } else {
+      obje.set("FILE", fileNode);
+      obje.set("FORM", form);
+      if (input.mediType) {
+        obje.set("MEDI", input.mediType);
+      }
+      if (input.title) {
+        obje.set("TITL", input.title);
+      }
+    }
+    if (input.primary) {
+      obje.set("_PRIM", "Y");
+    }
+    if (normalizeGedcomVersion(
+      input.gedcomVersion ?? this.getGedcomVersion()
+    ) === "7.0") {
+      obje.set("UID", createGedcomUid());
+    }
+    return obje;
+  }
+  nextSnoteKey() {
+    const ids = [];
+    this.snotes()?.forEach((_note, id) => {
+      ids.push(String(id));
+    });
+    return nextRecordId(ids, "N");
+  }
+  snotes() {
+    return this.getList("@@SNOTE");
+  }
+  snote(index) {
+    return this.getMain(this.snotes(), index);
+  }
+  /**
+   * Create a top-level shared note record (`0 @Nn@ SNOTE` for GEDCOM 7).
+   */
+  createSharedNote(text) {
+    const existing = this.snotes();
+    const notes = existing ?? new List();
+    if (!existing) {
+      this.set("@@SNOTE", notes);
+    }
+    const id = this.nextSnoteKey();
+    const note = createCommonNote(this, id);
+    note.type = "SNOTE";
+    note.value = text;
+    if (this.getGedcomVersion() === "7.0") {
+      note.set("UID", createGedcomUid());
+    }
+    notes.item(id, note);
+    return note;
+  }
+  registerExtensionTag(tag, uri) {
+    return registerExtensionTag(this, tag, uri);
+  }
+  getExtensionSchema() {
+    return getExtensionSchema(this);
+  }
+  ensureExtensionSchema(extraTags) {
+    ensureExtensionSchema(this, extraTags);
+    return getExtensionSchema(this);
+  }
+  /**
+   * Collect multimedia descriptors via each individual's `multimedia()`.
+   */
+  async collectMultimedia(options) {
+    const people = [];
+    if (options?.indiIds?.length) {
+      options.indiIds.forEach((id) => {
+        const indi = this.indi(id);
+        if (indi) {
+          people.push(indi);
+        }
+      });
+    } else {
+      this.indis()?.forEach((indi) => {
+        if (indi) {
+          people.push(indi);
+        }
+      });
+    }
+    const lists = await Promise.all(
+      people.map((indi) => indi.multimedia(options?.namespace))
+    );
+    return mergeMediaLists(...lists);
+  }
+  /**
+   * Serialize as GEDCOM 7 and pack a FamilySearch GEDZIP (`.gdz`).
+   * Media bytes must be supplied by the caller (cache/fetch outside the parser).
+   */
+  async toGedzip(options) {
+    const text = this.toGedcom(void 0, 0, {
+      ...options,
+      gedcomVersion: "7.0"
+    });
+    return buildGedzip(text, options?.media ?? []);
+  }
   objes() {
     return this.getList("@@OBJE");
   }
@@ -7286,18 +9140,70 @@ var GedCom = class extends Common {
     });
     return lists;
   }
-  getDownloadHeader() {
+  getGedcomVersion() {
+    const raw = this.get("HEAD")?.get("GEDC")?.get("VERS")?.toValue();
+    return normalizeGedcomVersion(
+      typeof raw === "string" ? raw : void 0
+    );
+  }
+  /** Rewrite HEAD.GEDC (and CHAR/FORM) for the requested export version. */
+  applyExportVersion(version) {
+    const head = this.get("HEAD");
+    if (!head) {
+      return;
+    }
+    this.applyGedcomSpecToHead(head, normalizeGedcomVersion(version));
+  }
+  applyGedcomSpecToHead(head, version) {
+    const previousGedc = head.get("GEDC");
+    const previousForm = previousGedc?.get("FORM")?.toValue();
+    const previousChar = head.get("CHAR")?.toValue();
+    head.remove("GEDC");
+    const gedc = head.set("GEDC", "");
+    if (!gedc) {
+      return;
+    }
+    gedc.set("VERS", version);
+    if (version === "7.0") {
+      head.remove("CHAR");
+      return;
+    }
+    gedc.set(
+      "FORM",
+      typeof previousForm === "string" && previousForm ? previousForm : "LINEAGE-LINKED"
+    );
+    if (!head.get("CHAR")?.toValue()) {
+      head.set(
+        "CHAR",
+        typeof previousChar === "string" && previousChar ? previousChar : "UTF-8"
+      );
+    }
+  }
+  getDownloadHeader(gedcomVersion) {
     const newHead = createCommon();
     Object.assign(newHead, this.get("HEAD") ?? {});
+    this.applyGedcomSpecToHead(
+      newHead,
+      gedcomVersion ?? this.getGedcomVersion()
+    );
+    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,20 +9232,45 @@ 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 requestedVersion = options?.gedcomVersion;
+    const exportVersion = requestedVersion ? normalizeGedcomVersion(requestedVersion) : this.getGedcomVersion();
+    const exportOptions = {
+      ...options,
+      obje: {
+        standardize: options?.obje?.standardize ?? (requestedVersion !== void 0 || !options?.original),
+        override: options?.obje?.override,
+        namespace: options?.obje?.namespace
+      }
+    };
     const newGedcom = createGedCom();
-    if (!options?.original) {
+    Object.assign(newGedcom, this);
+    if (!exportOptions.original) {
       Object.assign(newGedcom, {
-        HEAD: this.getDownloadHeader()
+        HEAD: this.getDownloadHeader(exportVersion)
       });
     }
-    Object.assign(newGedcom, this);
-    if (options?.indis?.length) {
-      const newContent = this.getIndiRelatedLists(options.indis);
+    if (exportOptions.indis?.length) {
+      const newContent = this.getIndiRelatedLists(exportOptions.indis);
       Object.assign(newGedcom, newContent);
     }
-    return newGedcom.toGedcom(tag, level, { ...options, super: true });
+    const restoreEnums = exportVersion === "7.0" ? applyGedcom7Enumerations(newGedcom) : void 0;
+    const restoreDates = exportVersion === "7.0" ? applyGedcom7DatePhrases(newGedcom) : void 0;
+    const restoreMetadata = exportVersion === "7.0" ? applyGedcom7RecordMetadata(newGedcom) : void 0;
+    const restoreSchema = exportVersion === "7.0" ? ensureExtensionSchema(newGedcom) : void 0;
+    try {
+      return newGedcom.toGedcom(tag, level, {
+        ...exportOptions,
+        gedcomVersion: exportVersion,
+        super: true
+      });
+    } finally {
+      restoreSchema?.();
+      restoreMetadata?.();
+      restoreDates?.();
+      restoreEnums?.();
+    }
   }
   hasTag(tag) {
     const tagName = typeof tag === "string" ? tag : tag?.get("NAME")?.toValue();
@@ -7555,144 +9486,6 @@ var createGedCom = () => {
   return new GedCom();
 };
 
-// src/classes/note.ts
-var CommonNote = class extends Common {
-  constructor(gedcom, id, main, parent) {
-    super(gedcom, id, main, parent);
-    delete this.id;
-  }
-  set value(value) {
-    const [note, ...contents] = value?.split(/\r?\n/) ?? [];
-    this._value = note;
-    if (contents.length) {
-      const newContents = new List();
-      contents.forEach((c, i) => {
-        const newContent = createCommon(
-          this._gedcom,
-          void 0,
-          this.main
-        );
-        newContent.id = `@U${i}@`;
-        newContent.value = c;
-        newContents.append(newContent);
-      });
-      const firstItem = newContents.index(0);
-      if (firstItem) {
-        if (newContents.length === 1) {
-          this.set("CONT", firstItem);
-        } else {
-          this.set("CONT", newContents);
-        }
-      }
-    }
-  }
-  get value() {
-    const contents = this.get("CONT")?.toList().map((content) => content.value).join("\n");
-    if (contents) {
-      return `${this._value}
-${contents}`;
-    }
-    return this._value;
-  }
-  exportValue() {
-    return this._value;
-  }
-};
-var createCommonNote = (gedcom, id, main, parent) => {
-  return createProxy(
-    new CommonNote(gedcom, id, main, parent)
-  );
-};
-
-// src/classes/obje.ts
-var Obje = class extends Common {
-  standardizeMedia(namespace, override = true, urlGetter) {
-    if (!this._gedcom) {
-      return this;
-    }
-    const rin = this?.get("RIN")?.toValue();
-    const clone = this?.get("_CLON._OID")?.toValue();
-    const mser = this?.get("_MSER._LKID")?.toValue();
-    const title = this?.get("FILE.TITL")?.toValue() ?? this?.get("TITL")?.toValue() ?? "";
-    const note = this?.get("FILE.NOTE")?.toValue() ?? this?.get("NOTE")?.toValue() ?? "";
-    const form = this?.get("FILE.FORM")?.toValue();
-    const file = this?.get("FILE")?.toValue();
-    const imgId = rin || clone || mser;
-    const url = file || namespace && urlGetter?.(namespace, imgId);
-    if (!url) {
-      return this;
-    }
-    const newObject = createObje(this._gedcom, this.id, this.main);
-    if (!override) {
-      Object.assign(newObject, this);
-    }
-    if (form) {
-      if (typeof form === "string") {
-        const newForm = createCommon(
-          this._gedcom,
-          void 0,
-          this.main
-        );
-        newForm.value = form;
-        newObject.set("FORM", newForm);
-      } else {
-        newObject.set("FORM", form);
-      }
-    }
-    if (title) {
-      if (typeof title === "string") {
-        const newTitle = createCommon(
-          this._gedcom,
-          void 0,
-          this.main
-        );
-        newTitle.value = title;
-        newObject.set("TITL", newTitle);
-        if (!note) {
-          newObject.set("NOTE", newTitle);
-        }
-      } else {
-        newObject.set("TITL", title);
-        if (!note) {
-          newObject.set("NOTE", title);
-        }
-      }
-    }
-    if (note) {
-      if (typeof note === "string") {
-        const newNote = createCommon(
-          this._gedcom,
-          void 0,
-          this.main
-        );
-        newNote.value = note;
-        newObject.set("NOTE", newNote);
-        if (!title) {
-          newObject.set("TITL", newNote);
-        }
-      } else {
-        newObject.set("NOTE", note);
-        if (!title) {
-          newObject.set("TITL", note);
-        }
-      }
-    }
-    const newUrl = createCommon(this._gedcom, void 0, this.main);
-    newUrl.value = url;
-    newObject.set("FILE", newUrl);
-    if (override) {
-      Object.assign(this, newObject);
-      return this;
-    }
-    return newObject;
-  }
-};
-var createObje = (gedcom, id, main, parent) => {
-  return createProxy(
-    new Obje(gedcom, id, main, parent)
-  );
-};
-
 // src/classes/repo.ts
 var Repo = class extends Common {
 };
@@ -7741,6 +9534,8 @@ var create = (gedcom, type, id, nodes) => {
       prevNode = createIndi(gedcom, id);
     } else if (convertType === "FAM") {
       prevNode = createFam(gedcom, id);
+    } else if (convertType === "SNOTE" || convertType === "NOTE") {
+      prevNode = createCommonNote(gedcom, id);
     } else {
       prevNode = createCommon(gedcom, id);
     }
@@ -7756,7 +9551,7 @@ var create = (gedcom, type, id, nodes) => {
       prevNode = createObje(gedcom, void 0, mainNode, curNode);
     } else if (type === "DATE") {
       prevNode = createCommonDate(gedcom, void 0, mainNode, curNode);
-    } else if (type === "NOTE") {
+    } else if (type === "NOTE" || type === "SNOTE") {
       prevNode = createCommonNote(gedcom, void 0, mainNode, curNode);
     } else if (type === "NAME" && mainNode instanceof Indi) {
       prevNode = createCommonName(gedcom, void 0, mainNode, curNode);
@@ -7773,20 +9568,6 @@ var getRawSize = (raw) => {
   return `${raw || ""}`?.length ?? 0;
 };
 
-// src/classes/objes.ts
-var Objects = class _Objects extends List {
-  copy() {
-    const newList = new _Objects();
-    this.entries().forEach(([key, value]) => {
-      newList.item(key, value);
-    });
-    return newList;
-  }
-  except(item) {
-    return this.copy().delete(item);
-  }
-};
-
 // src/classes/repos.ts
 var Repositories = class _Repositories extends List {
   copy() {
@@ -7864,9 +9645,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 +9658,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}`);
@@ -7890,6 +9676,13 @@ var GedcomTree = {
         if (linesAcc._inHead && lineIndent === 1 && lineType === "FILE") {
           linesAcc._hasFile = true;
         }
+        if (lineType.toUpperCase() === "CONC") {
+          const last = acc[acc.length - 1];
+          if (last !== void 0) {
+            acc[acc.length - 1] = `${last}${lineValue}`;
+            return acc;
+          }
+        }
         if (lineIndent > 0 && lineIndent > prevLineIndent && lineValue && isId(lineValue)) {
           const refLines = lineValue.split(/,\s*/).map((id) => line.replace(lineValue, id));
           if (refLines.length > 1) {
@@ -7933,8 +9726,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 +9865,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, DEFAULT_GEDCOM_EXPORT_VERSION, GEDCOM7_CALENDARS, GEDCOM7_PEDI_VALUES, GEDCOM7_RESN_VALUES, GEDCOM7_ROLE_VALUES, GEDCOM7_SEX_VALUES, GEDCOM_EXPORT_VERSIONS, GEDCOM_TRAILER_TAG, GEDZIP_EXTENSION, GEDZIP_GEDCOM_ENTRY, GEDZIP_MIME, parser_default as GedcomTree, PEDIGREE_VALUES, PlaceType, TREEVIZ_EXTENSION_BASE_URI, TREEVIZ_EXTENSION_URIS, addFamilyFact, addIndividualFact, addNonEvent, appendGedcomTrailer, applyGedcom7DatePhrases, applyGedcom7Enumerations, applyGedcom7RecordMetadata, attachChildToFamily, attachSpouseToFamily, buildGedzip, buildGedzipBlob, bytesToDataUrl, cacheDiscoveredPath, canAttachAsSpouse, collectExtensionTagsFrom, commonDateFormatter, create, createEmptyGedcom, createGedcomUid, dateFormatter, downloadGedzipMedia, ensureExtensionSchema, extractGedzip, extractGedzipGedcom, extractSeparationYears, extractSplitPoints, familyHasChild, familyHasParent, findMatchingRangeForSplitRange, findReusableParentChildFamily, firstPointerId, formatGedcom7Timestamp, fromTuple, generateSplitRanges, getAllProp, getExtensionSchema, getFamilyWith, getFileExtension, getName, getPlaceParts, getPlaces, getRawSize, getVersion, hungarianOrdinalize, implemented, inRange, inferMediaForm, initializeCache, isDevelopment, isGedcom7, isGedcomTrailerLine, isGedcomTrailerTag, isGedzipContainer, isImageFormat, isIntersectedRange, isObjePointer, isRangeContained, isRemoteOrEmbeddedMediaUrl, makePointer, marriageDateFormatter, mergeMediaLists, nameFormatter, nextRecordId, normalizeGedcomVersion, notImplemented, noteDateFormatter, ordinalize, parseGedcom7CalendarPrefix, parseRangeBounds, pathCache, placeTranslator, pointerIds, profilePictureCache, registerExtensionTag, relativesCache, remountGedzipMediaAsDataUrls, resetRelativesCache, resolveLocalMediaUrl, resolveMediaContent, resolveObjeForm, rewriteGedcomFilePaths, setCauseOfDeath, setChildPedigree, setDeceased, setFamilyMarriage, setLocalMediaResolver, setMediaContentResolver, setNestedGroup, splitOverlappingRanges, splitRange, spouseTagFor, toGedcomPedigree, updateFactRecord, withGedcom7Calendar };