@treeviz/gedcom-parser 2.0.10 → 2.1.0

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'url';
 import { Command } from 'commander';
 import { debounce, set, get, uniqBy, unset, difference, intersectionBy, differenceBy } from 'lodash-es';
 import { format, isValid, parse } from 'date-fns';
+import JSZip from 'jszip';
 import chalk from 'chalk';
 import * as readline from 'readline';
 
@@ -15,11 +16,31 @@ var __export = (target, all) => {
 };
 
 // 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) {
@@ -395,11 +416,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,
@@ -530,6 +557,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;
@@ -540,6 +570,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) {
@@ -651,12 +684,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
       );
     }
   }
@@ -683,7 +718,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)
@@ -741,8 +776,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) {
@@ -753,7 +792,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)
           );
@@ -762,30 +801,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)
@@ -802,22 +858,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()) {
@@ -851,8 +907,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";
@@ -862,14 +917,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;
     }
@@ -961,11 +1016,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}`;
     }
@@ -1031,7 +1086,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) => {
@@ -1066,6 +1121,178 @@ var idGetter = (id) => {
   return newId;
 };
 
+// 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/factories/cache-factory.ts
 var defaultCacheFactory = () => {
   let cache = null;
@@ -1139,131 +1366,322 @@ var PARTNER = {
 var SPOUSE = {
   PART: "spouse" /* SPOUSE */
 };
-var getGedcomId = (gedcom) => {
-  if (!gedcom) {
-    return "unknown";
-  }
-  const treeId = gedcom.getTreeId?.() || "";
-  const treeName = gedcom.getTreeName?.() || "";
-  const sanitizedName = treeName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-  if (treeId && sanitizedName) {
-    return `${treeId}_${sanitizedName}`;
-  } else if (treeId) {
-    return treeId;
-  } else if (sanitizedName) {
-    return sanitizedName;
-  }
-  return `gedcom_${gedcom.refcount}`;
-};
-var caches = {
-  pathCache: {},
-  relativesOnDegreeCache: {},
-  relativesOnLevelCache: {},
-  profilePictureCache: {}
+
+// src/utils/get-family-with.ts
+var getFamilyWith = (person1, person2, famType = "FAMS") => {
+  return person1?.get(famType)?.toValueList().find((fam) => {
+    const family = fam;
+    return famType === "FAMC" || family?.HUSB?.value === person2 || family?.WIFE?.value === person2;
+  });
 };
-var cacheDbs;
-var getCacheDbs = () => {
-  if (!cacheDbs) {
-    const getInstance = getCacheManagerFactory();
-    cacheDbs = {
-      pathCache: getInstance(
-        "ftv",
-        "Main",
-        "path",
-        true
-      ),
-      relativesOnDegreeCache: getInstance("ftv", "Main", "path", true),
-      relativesOnLevelCache: getInstance(
-        "ftv",
-        "Main",
-        "path",
-        true
-      ),
-      profilePictureCache: getInstance(
-        "ftv",
-        "Main",
-        "images",
-        false
-      )
-    };
+
+// src/constants/orders.ts
+var BIRTH_ASC = {
+  "BIRT.DATE": {
+    direction: "ASC",
+    getter: (value, raw) => {
+      if (isCommonDate(raw) && raw.rawValue) {
+        return raw.rawValue.getTime();
+      }
+      return new Date(value).getTime();
+    }
   }
-  return cacheDbs;
 };
-var storeCache = {
-  // NOTE: pathCache, relativesOnLevelCache, and relativesOnDegreeCache are intentionally
-  // kept in memory only. These debounced functions exist to satisfy the type system
-  // but are never called.
-  pathCache: debounce((value) => {
-    if (value) {
-      getCacheDbs().pathCache.setItem(value);
-    }
-  }, 50),
-  relativesOnLevelCache: debounce((value) => {
-    if (value) {
-      getCacheDbs().relativesOnLevelCache.setItem(value);
-    }
-  }, 50),
-  relativesOnDegreeCache: debounce((value) => {
-    if (value) {
-      getCacheDbs().relativesOnDegreeCache.setItem(value);
-    }
-  }, 50),
-  // profilePictureCache IS persisted to IndexedDB
-  profilePictureCache: debounce((value) => {
-    if (value) {
-      getCacheDbs().profilePictureCache.setItem(value);
+var BIRTH_DESC = {
+  "BIRT.DATE": {
+    direction: "DESC",
+    getter: (value, raw) => {
+      if (isCommonDate(raw) && raw.rawValue) {
+        return raw.rawValue.getTime();
+      }
+      return new Date(value).getTime();
     }
-  }, 100)
-};
-var relativesCache = (cacheKey) => (gedcom, key, subKey, value) => {
-  const gedcomId = getGedcomId(gedcom);
-  const fullKey = `${gedcomId}:${key}`;
-  const cache = caches[cacheKey];
-  if (!cache) {
-    caches[cacheKey] = {};
   }
-  if (value) {
-    const typedCache2 = caches[cacheKey];
-    if (!typedCache2[fullKey]) {
-      typedCache2[fullKey] = {};
+};
+var DEATH_ASC = {
+  "DEAT.DATE": {
+    direction: "ASC",
+    getter: (value, raw) => {
+      if (isCommonDate(raw) && raw.rawValue) {
+        return raw.rawValue.getTime();
+      }
+      return new Date(value).getTime();
     }
-    typedCache2[fullKey][subKey] = value;
-    return typedCache2[fullKey][subKey];
   }
-  const typedCache = caches[cacheKey];
-  return typedCache?.[fullKey]?.[subKey];
 };
-var pathCache = (gedcom, key, value) => {
-  const gedcomId = getGedcomId(gedcom);
-  const fullKey = `${gedcomId}:${key}`;
-  if (!caches.pathCache) {
-    caches.pathCache = {};
-  }
-  if (value && caches.pathCache) {
-    caches.pathCache[fullKey] = value;
-    return caches.pathCache[fullKey];
+var DEATH_DESC = {
+  "DEAT.DATE": {
+    direction: "DESC",
+    getter: (value, raw) => {
+      if (isCommonDate(raw) && raw.rawValue) {
+        return raw.rawValue.getTime();
+      }
+      return new Date(value).getTime();
+    }
   }
-  return caches.pathCache?.[fullKey];
 };
-var profilePictureCache = (gedcom, key, value) => {
-  const gedcomId = getGedcomId(gedcom);
-  const fullKey = `${gedcomId}:${key}`;
-  if (!caches.profilePictureCache) {
-    caches.profilePictureCache = {};
-  }
-  if (value && caches.profilePictureCache) {
-    caches.profilePictureCache[fullKey] = value;
-    storeCache.profilePictureCache(caches.profilePictureCache);
-    return caches.profilePictureCache[fullKey];
+var DATE_ASC = {
+  DATE: {
+    direction: "ASC",
+    getter: (value, raw) => {
+      if (isCommonDate(raw) && raw.rawValue) {
+        return raw.rawValue.getTime();
+      }
+      return new Date(value).getTime();
+    }
   }
-  const cached = caches.profilePictureCache?.[fullKey];
-  return cached;
 };
-var isNonBiologicalPath = (path) => path.some(
-  (item) => item.relation && item.relation !== "biological" /* BIOLOGICAL */
-);
-var invertHop = (kinship) => {
-  if (kinship === "parent") {
+var chars = [
+  "a",
+  "\xE0",
+  "\xE1",
+  "\xE2",
+  "\xE4",
+  "\xE6",
+  "\xE3",
+  "\xE5",
+  "\u0101",
+  "b",
+  "c",
+  "\xE7",
+  "\u0107",
+  "\u010D",
+  "cs",
+  "d",
+  "dz",
+  "dzs",
+  "e",
+  "\xE8",
+  "\xE9",
+  "\xEA",
+  "\xEB",
+  "\u0113",
+  "\u0117",
+  "\u0119",
+  "f",
+  "g",
+  "gy",
+  "h",
+  "i",
+  "\xEE",
+  "\xEF",
+  "\xED",
+  "\u012B",
+  "\u012F",
+  "\xEC",
+  "j",
+  "k",
+  "l",
+  "\u0142",
+  "ly",
+  "m",
+  "n",
+  "\xF1",
+  "\u0144",
+  "ny",
+  "o",
+  "\xF3",
+  "\xF6",
+  "\u0151",
+  "\xF4",
+  "\xF2",
+  "\xF5",
+  "\u0153",
+  "\xF8",
+  "\u014D",
+  "p",
+  "q",
+  "r",
+  "s",
+  "\u015B",
+  "\u0161",
+  "\xDF",
+  "sz",
+  "t",
+  "ty",
+  "u",
+  "\xFA",
+  "\xFC",
+  "\u0171",
+  "\xFB",
+  "\xF9",
+  "\u016B",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "zs"
+];
+chars.reduce((acc, curr, idx) => {
+  acc[curr] = idx;
+  return acc;
+}, {});
+var getBirthAsc = (itemA, _keyA, itemB, _keyB) => {
+  const birthA = itemA?.BIRT?.index(0);
+  const birthB = itemB?.BIRT?.index(0);
+  const valueA = birthA?.DATE?.rawValue;
+  const valueB = birthB?.DATE?.rawValue;
+  if (valueA?.getTime() === valueB?.getTime()) {
+    return 0;
+  }
+  if (!valueA || valueB && valueA > valueB) {
+    return 1;
+  }
+  return -1;
+};
+var getMarriageAsc = (person, famType = "FAMS") => (itemA, _keyA, itemB, _keyB) => {
+  if (!person && famType === "FAMS") {
+    return 0;
+  }
+  const familyA = getFamilyWith(itemA, person);
+  const familyB = getFamilyWith(itemB, person);
+  const marriageA = familyA?.MARR?.DATE?.rawValue;
+  const marriageB = familyB?.MARR?.DATE?.rawValue;
+  if (marriageA?.getTime() === marriageB?.getTime()) {
+    return 0;
+  }
+  if (!marriageA || marriageB && marriageA > marriageB) {
+    return 1;
+  }
+  return -1;
+};
+var getMarriageAscAndChildBirth = (person) => (itemA, keyA, itemB, keyB) => {
+  const marriageSort = getMarriageAsc(person)(itemA, keyA, itemB, keyB);
+  if (marriageSort !== 0) {
+    return marriageSort;
+  }
+  const familyA = getFamilyWith(itemA, person);
+  const familyB = getFamilyWith(itemB, person);
+  const childA = familyA?.getChildren().orderBy(BIRTH_ASC).index(0);
+  const childB = familyB?.getChildren().orderBy(BIRTH_ASC).index(0);
+  return getBirthAsc(childA, keyA, childB);
+};
+var getGedcomId = (gedcom) => {
+  if (!gedcom) {
+    return "unknown";
+  }
+  const treeId = gedcom.getTreeId?.() || "";
+  const treeName = gedcom.getTreeName?.() || "";
+  const sanitizedName = treeName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (treeId && sanitizedName) {
+    return `${treeId}_${sanitizedName}`;
+  } else if (treeId) {
+    return treeId;
+  } else if (sanitizedName) {
+    return sanitizedName;
+  }
+  return `gedcom_${gedcom.refcount}`;
+};
+var caches = {
+  pathCache: {},
+  relativesOnDegreeCache: {},
+  relativesOnLevelCache: {},
+  profilePictureCache: {}
+};
+var cacheDbs;
+var getCacheDbs = () => {
+  if (!cacheDbs) {
+    const getInstance = getCacheManagerFactory();
+    cacheDbs = {
+      pathCache: getInstance(
+        "ftv",
+        "Main",
+        "path",
+        true
+      ),
+      relativesOnDegreeCache: getInstance("ftv", "Main", "path", true),
+      relativesOnLevelCache: getInstance(
+        "ftv",
+        "Main",
+        "path",
+        true
+      ),
+      profilePictureCache: getInstance(
+        "ftv",
+        "Main",
+        "images",
+        false
+      )
+    };
+  }
+  return cacheDbs;
+};
+var storeCache = {
+  // NOTE: pathCache, relativesOnLevelCache, and relativesOnDegreeCache are intentionally
+  // kept in memory only. These debounced functions exist to satisfy the type system
+  // but are never called.
+  pathCache: debounce((value) => {
+    if (value) {
+      getCacheDbs().pathCache.setItem(value);
+    }
+  }, 50),
+  relativesOnLevelCache: debounce((value) => {
+    if (value) {
+      getCacheDbs().relativesOnLevelCache.setItem(value);
+    }
+  }, 50),
+  relativesOnDegreeCache: debounce((value) => {
+    if (value) {
+      getCacheDbs().relativesOnDegreeCache.setItem(value);
+    }
+  }, 50),
+  // profilePictureCache IS persisted to IndexedDB
+  profilePictureCache: debounce((value) => {
+    if (value) {
+      getCacheDbs().profilePictureCache.setItem(value);
+    }
+  }, 100)
+};
+var relativesCache = (cacheKey) => (gedcom, key, subKey, value) => {
+  const gedcomId = getGedcomId(gedcom);
+  const fullKey = `${gedcomId}:${key}`;
+  const cache = caches[cacheKey];
+  if (!cache) {
+    caches[cacheKey] = {};
+  }
+  if (value) {
+    const typedCache2 = caches[cacheKey];
+    if (!typedCache2[fullKey]) {
+      typedCache2[fullKey] = {};
+    }
+    typedCache2[fullKey][subKey] = value;
+    return typedCache2[fullKey][subKey];
+  }
+  const typedCache = caches[cacheKey];
+  return typedCache?.[fullKey]?.[subKey];
+};
+var pathCache = (gedcom, key, value) => {
+  const gedcomId = getGedcomId(gedcom);
+  const fullKey = `${gedcomId}:${key}`;
+  if (!caches.pathCache) {
+    caches.pathCache = {};
+  }
+  if (value && caches.pathCache) {
+    caches.pathCache[fullKey] = value;
+    return caches.pathCache[fullKey];
+  }
+  return caches.pathCache?.[fullKey];
+};
+var profilePictureCache = (gedcom, key, value) => {
+  const gedcomId = getGedcomId(gedcom);
+  const fullKey = `${gedcomId}:${key}`;
+  if (!caches.profilePictureCache) {
+    caches.profilePictureCache = {};
+  }
+  if (value && caches.profilePictureCache) {
+    caches.profilePictureCache[fullKey] = value;
+    storeCache.profilePictureCache(caches.profilePictureCache);
+    return caches.profilePictureCache[fullKey];
+  }
+  const cached = caches.profilePictureCache?.[fullKey];
+  return cached;
+};
+var isNonBiologicalPath = (path) => path.some(
+  (item) => item.relation && item.relation !== "biological" /* BIOLOGICAL */
+);
+var invertHop = (kinship) => {
+  if (kinship === "parent") {
     return "child";
   }
   if (kinship === "child") {
@@ -1649,16 +2067,58 @@ var getPlaces = (common, type = ["ALL" /* All */], maxLevel = 1, level = 0, main
   });
   return places;
 };
-var implemented = (type, ...args) => {
-};
 
-// src/utils/media-utils.ts
-var getFileExtension = (filename) => {
-  const match = filename.match(/\.([^.]+)$/);
-  return match ? match[1] : "";
-};
+// src/utils/local-media.ts
+var localMediaResolver;
+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 implemented = (type, ...args) => {
+};
+
+// src/utils/media-utils.ts
+var getFileExtension = (filename) => {
+  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",
@@ -1670,178 +2130,731 @@ var isImageFormat = (format2) => {
     "tiff",
     "tif"
   ];
-  return imageFormats.includes(format2.toLowerCase());
+  return imageFormats.includes(normalized);
 };
-
-// src/classes/name.ts
-var CommonName = class extends Common {
-  constructor(gedcom, id, main, parent) {
-    super(gedcom, id, main, parent);
-    delete this.id;
-  }
-  set value(value) {
-    if (value && this._main instanceof Indi) {
-      const nameParts = value.match(
-        /(?<givenname>[^/]*)(\/(?<surname>[^/]*)\/)?(?<suffix>.*)$/
-      )?.groups;
-      if (nameParts?.givenname?.trim()) {
-        this.GIVN = this.GIVN || createCommon(this._gedcom, void 0, this.main);
-        this.GIVN.isListable = false;
-        this.GIVN.value = nameParts.givenname.trim();
-      }
-      if (nameParts?.surname?.trim()) {
-        this.SURN = this.SURN || createCommon(this._gedcom, void 0, this.main);
-        this.SURN.value = nameParts.surname.trim();
-        this.SURN.isListable = false;
-      }
-      if (nameParts?.suffix?.trim()) {
-        this.NSFX = this.NSFX || createCommon(this._gedcom, void 0, this.main);
-        this.NSFX.value = nameParts.suffix.trim();
-        this.NSFX.isListable = false;
+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) => {
+  const parts = Array.isArray(key) ? key : key.split(/,\s*/);
+  set(obj, [...parts, "items"], value);
+  parts.forEach((_, index) => {
+    if (!uniqueCounting) {
+      const key2 = [...parts.toSpliced(index + 1), "length"];
+      const length = get(obj, key2);
+      set(obj, key2, (length ?? 0) + value.length);
+      return;
+    }
+    const pathKey = [...parts.toSpliced(index + 1)];
+    const node = get(obj, pathKey);
+    if (node) {
+      let uniqueItems = uniqueItemsCache.get(node);
+      if (!uniqueItems) {
+        uniqueItems = new Individuals();
+        uniqueItemsCache.set(node, uniqueItems);
       }
+      uniqueItems.merge(value);
+      set(obj, [...pathKey, "length"], uniqueItems.length);
     }
-    this._value = value;
+  });
+};
+
+// src/utils/place-parser.ts
+var getPlaceParts = (place = []) => {
+  const partsString = Array.isArray(place) ? place.filter(Boolean).join(", ") : place;
+  if (!partsString) {
+    return [{}];
   }
-  get value() {
-    if (this._value === void 0 && this.DISPLAY?.value) {
-      return this.DISPLAY?.value;
-    }
-    return this._value;
+  const parts = partsString.split(/,\s*/).map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    return [{}];
   }
-  name(value) {
-    this.value = value;
-    return this;
+  const result = {};
+  if (parts.length === 1) {
+    result.town = parts[0];
+  } else if (parts.length === 2) {
+    result.town = parts[0];
+    result.country = parts[1];
+  } else if (parts.length === 3) {
+    result.town = parts[0];
+    result.county = parts[1];
+    result.country = parts[2];
+  } else {
+    result.leftParts = parts.slice(0, parts.length - 3);
+    result.town = parts[parts.length - 3];
+    result.county = parts[parts.length - 2];
+    result.country = parts[parts.length - 1];
   }
+  return [result];
 };
-var createCommonName = (gedcom, id, main, parent) => {
-  return createProxy(
-    new CommonName(gedcom, id, main, parent)
-  );
+
+// src/utils/place-translator.ts
+var placeTranslator = (place) => {
+  return Array.isArray(place) ? place.join(", ") : place;
 };
 
-// src/classes/indi.ts
-var ALLOWED_FACTS = [
-  "EVEN",
-  "OCCU",
-  "OCCUPATIONS",
-  "RESI",
-  "BAPT",
-  "CHRI",
-  "CHR",
-  "BURI",
-  "EDUC",
-  "GRAD",
-  "DIV",
-  "IMMI",
-  "RELI",
-  "_MILT",
-  "_MILTID",
-  "FACT",
-  "_ORIG"
-];
-var DISALLOWED_CUSTOM_FACTS = ["DNA Test", "Newspaper"];
-var CustomFactRenderers = {
-  AKA: (label, fact, indi) => {
-    const originalNameObj = indi?.NAME;
-    const note = fact.get("NOTE");
-    const factName = note?.toValue();
-    const name = createCommonName(fact.getGedcom(), void 0, indi);
-    const suffix = originalNameObj?.NSFX?.toValue();
-    const surname = originalNameObj?.SURN?.toValue();
-    const givenname = originalNameObj?.GIVN?.toValue();
-    const nameParts = [
-      ...givenname?.split(" ").map((s) => ({ name: s, givenname: true })) ?? [],
-      ...surname?.split(" ").map((s) => ({ name: s, surname: true })) ?? [],
-      ...suffix?.split(" ").map((s) => ({ name: s, suffix: true })) ?? []
-    ].filter(Boolean);
-    const factParts = factName?.split(" ");
-    if (nameParts.length === factParts?.length && !(note instanceof CommonName)) {
-      const guessedSuffix = [];
-      const guessedSurname = [];
-      const guessedGivenname = [];
-      factParts.forEach((f, i) => {
-        const namePart = nameParts[i];
-        if (!f) {
-          return;
-        }
-        if (namePart.suffix) {
-          guessedSuffix.push(f);
-        } else if (namePart.givenname) {
-          guessedGivenname.push(f);
-        } else if (namePart.surname) {
-          guessedSurname.push(f);
-        }
-      });
-      const allNamePart = [];
-      if (guessedGivenname.length) {
-        allNamePart.push(guessedGivenname.join(" "));
-      }
-      if (guessedSurname.length) {
-        allNamePart.push(`/${guessedSurname.join(" ")}/`);
-      }
-      if (guessedSuffix.length) {
-        allNamePart.push(guessedSuffix.join(" "));
-      }
-      name.value = allNamePart.join(" ");
-    } else {
-      name.value = factName;
-    }
-    fact.set("NOTE", name);
-    label.value = "AKA";
-    fact.set("_LABEL", label);
+// src/classes/indis.ts
+var Individuals = class _Individuals extends List {
+  copy() {
+    return super.copy(_Individuals);
   }
-};
-var relativesOnLevelCache = relativesCache("relativesOnLevelCache");
-var relativesOnDegreeCache = relativesCache("relativesOnDegreeCache");
-var Indi = class extends Common {
-  toName() {
-    return this.get("NAME")?.toValue();
+  except(item) {
+    return super.except(item, _Individuals);
   }
-  toNaturalName() {
-    return this.get("NAME")?.toValue()?.replaceAll("/", "");
+  filter(filters) {
+    return super.filter(filters, _Individuals);
   }
-  toList() {
-    return new Individuals().concat(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      this.id ? { [this.id]: this } : { ...[this] }
-    );
+  find(filters) {
+    return super.find(filters, _Individuals);
   }
-  generateTree(props) {
-    const {
-      generations,
-      level,
-      index,
-      showDescendants,
-      offspringSpouses,
-      ancestorSpouses,
-      onlyDescendants,
-      maxLevel,
-      minLevel,
-      drawNonBiologicalAncestors,
-      ancestorSiblings
-    } = props;
-    if (!this.id) {
-      throw new Error("Indi must have an id");
+  unattachedFilter(useUnattached) {
+    if (useUnattached) {
+      return this;
     }
-    const isMainDescendantLevel = showDescendants && level <= 1;
-    const isDescendantLevel = showDescendants && level < 1;
-    if (level < 1 && !isDescendantLevel) {
-      throw new Error("Arguments 2 must be greater than 0.");
+    return this.filter((item) => !item.isUnattachedMember());
+  }
+  orderBy(orders) {
+    return super.orderBy(orders, _Individuals);
+  }
+  getFirstEvent() {
+    const firstBirthPerson = this.getFirstBirth();
+    const firstDeathPerson = this.getFirstDeath();
+    const firstBirth = firstBirthPerson?.BIRT?.index(0);
+    const firstDeath = firstDeathPerson?.DEAT?.index(0);
+    if (!firstBirth?.DATE?.rawValue && !firstDeath?.DATE?.rawValue) {
+      return void 0;
     }
-    if (maxLevel !== void 0 && maxLevel < level || minLevel !== void 0 && minLevel > level) {
-      return this;
+    if (!firstBirth?.DATE?.rawValue) {
+      return firstDeathPerson;
     }
-    const gens = generations ?? {
-      existed: {},
-      tree: {},
-      halves: {},
-      lastItems: {}
-    };
-    const families = this.getFamiliesBiologicalFirst("FAMC");
-    const familiesAllMember = families.getParents();
-    families.forEach((fam, famKey, famIndex) => {
-      if (!this.id) {
-        return;
+    if (!firstDeath?.DATE?.rawValue) {
+      return firstBirthPerson;
+    }
+    if (firstDeath.DATE.rawValue < firstBirth.DATE.rawValue) {
+      return firstDeathPerson;
+    }
+    return firstBirthPerson;
+  }
+  getLastEvent() {
+    const lastDeathPerson = this.getLastDeath();
+    const lastBirthPerson = this.getLastBirth();
+    const lastBirth = lastBirthPerson?.BIRT?.index(0);
+    const lastDeath = lastDeathPerson?.DEAT?.index(0);
+    if (!lastBirth?.DATE?.rawValue && !lastDeath?.DATE?.rawValue) {
+      return void 0;
+    }
+    if (!lastDeath?.DATE?.rawValue) {
+      return lastBirthPerson;
+    }
+    if (!lastBirth?.DATE?.rawValue) {
+      return lastDeathPerson;
+    }
+    if (lastDeath.DATE.rawValue < lastBirth.DATE.rawValue) {
+      return lastBirthPerson;
+    }
+    return lastDeathPerson;
+  }
+  getFirstBirth() {
+    return this.filter((item) => {
+      const birth = item.BIRT?.index(0);
+      if (birth?.DATE?.rawValue?.getTime() === 0) {
+        return true;
+      }
+      return !!birth?.DATE?.rawValue?.getTime();
+    }).orderBy(BIRTH_ASC).index(0);
+  }
+  getLastBirth() {
+    return this.filter((item) => {
+      const birth = item.BIRT?.index(0);
+      if (birth?.DATE?.rawValue?.getTime() === 0) {
+        return true;
+      }
+      return !!birth?.DATE?.rawValue?.getTime();
+    }).orderBy(BIRTH_DESC).index(0);
+  }
+  getFirstDeath() {
+    return this.filter((item) => {
+      const death = item.DEAT?.index(0);
+      if (death?.DATE?.rawValue?.getTime() === 0) {
+        return true;
+      }
+      return !!death?.DATE?.rawValue?.getTime();
+    }).orderBy(DEATH_ASC).index(0);
+  }
+  getLastDeath() {
+    return this.filter((item) => {
+      const death = item.DEAT?.index(0);
+      if (death?.DATE?.rawValue?.getTime() === 0) {
+        return true;
+      }
+      return !!death?.DATE?.rawValue?.getTime();
+    }).orderBy(DEATH_DESC).index(0);
+  }
+  groupBy(group, sort, minOccurance = -1, lessOccuranceLabel) {
+    return super.groupBy(
+      group,
+      sort,
+      minOccurance,
+      lessOccuranceLabel,
+      _Individuals
+    );
+  }
+  groupByFirstLetters(sort = "group", minOccurance = -1, settings) {
+    return this.groupBy(
+      (item) => {
+        const { letter } = nameFormatter(item, settings);
+        return letter.trim() || "Unknown";
+      },
+      sort,
+      minOccurance,
+      "Letters appearing less than 5 times"
+    );
+  }
+  groupBySurnames(sort, minOccurance = -1) {
+    return this.groupBy(
+      "NAME.SURN",
+      sort,
+      minOccurance,
+      "Surnames appearing less than 5 times"
+    );
+  }
+  groupByTimeRanges(range, sort = "group", minOccurance = -1) {
+    return this.groupBy(
+      {
+        ["BIRT.DATE.YEAR"]: {
+          getter: (year) => {
+            if (!Number(year)) {
+              return;
+            }
+            if (range === 1 /* Year */) {
+              return `${Math.floor(Number(year) / range) * range}`;
+            }
+            return `${Math.floor(Number(year) / range) * range + 1}-${Math.ceil((Number(year) + 1) / range) * range}`;
+          }
+        }
+      },
+      sort,
+      minOccurance,
+      "Time ranges appearing less than 5 times"
+    );
+  }
+  nestedGroupByPlacesAndTimeRanges(sort, minOccurance = -1, uniqueCounting = true) {
+    const placesWithYear = this.groupBy(
+      (item) => item.getPlaces().map((place) => {
+        const date = place.obj?.get("DATE");
+        if (date?.YEAR) {
+          return `${place.place}, ${date.YEAR}`;
+        }
+        return `${place.place}, Unknown`;
+      }).filter(Boolean),
+      sort,
+      minOccurance,
+      "Places appearing less than 5 times"
+    );
+    return Object.entries(placesWithYear).reduce(
+      (acc, [place, indis]) => {
+        setNestedGroup(acc, place, indis, uniqueCounting);
+        return acc;
+      },
+      {}
+    );
+  }
+  nestedGroupByTimeRangesAndPlaces(sort, minOccurance = -1, uniqueCounting = true) {
+    const placesWithYear = this.groupBy(
+      (item) => item.getPlaces().map((place) => {
+        const date = place.obj?.get("DATE");
+        if (date?.YEAR) {
+          return `${date.YEAR}, ${place.place}`;
+        }
+        return `Unknown, ${place.place}`;
+      }).filter(Boolean),
+      sort,
+      minOccurance,
+      "Places appearing less than 5 times"
+    );
+    return Object.entries(placesWithYear).reduce(
+      (acc, [place, indis]) => {
+        setNestedGroup(acc, place, indis, uniqueCounting);
+        return acc;
+      },
+      {}
+    );
+  }
+  nestedGroupByPlaces(sort, minOccurance = -1, partOrder = "reverse", translate = true, uniqueCounting = true, groupKeyTranslator) {
+    const places = this.groupByPlaces(
+      sort,
+      minOccurance,
+      partOrder,
+      translate,
+      groupKeyTranslator
+    );
+    return Object.entries(places).reduce(
+      (acc, [place, indis]) => {
+        setNestedGroup(acc, place, indis, uniqueCounting);
+        return acc;
+      },
+      {}
+    );
+  }
+  groupByPlaces(sort, minOccurance = -1, partOrder = "reverse", translate = true, groupKeyTranslator) {
+    return this.groupBy(
+      (item) => item.getPlaces().map((place) => {
+        const placeParts = getPlaceParts(place.place || "");
+        const {
+          leftParts = [],
+          town,
+          county,
+          country
+        } = placeParts[0] || {};
+        const normalizedParts = [
+          ...leftParts,
+          town,
+          county,
+          country
+        ].filter(Boolean);
+        const orderedParts = partOrder === "original" ? normalizedParts : normalizedParts.toReversed();
+        let newPlace = "";
+        if (groupKeyTranslator) {
+          newPlace = groupKeyTranslator(orderedParts);
+        } else if (translate) {
+          {
+            newPlace = placeTranslator(orderedParts);
+          }
+        } else {
+          newPlace = orderedParts.join(", ");
+        }
+        if (!newPlace) {
+          return void 0;
+        }
+        return {
+          marker: place.place,
+          group: newPlace
+        };
+      }).filter(Boolean),
+      sort,
+      minOccurance,
+      "Places appearing less than 5 times"
+    );
+  }
+  getFacts() {
+    const facts = new List();
+    this.values().forEach((indi) => {
+      const indiFacts = indi?.getFacts();
+      if (indi?.id && indiFacts) {
+        facts.merge(indiFacts);
+      }
+    });
+    return facts;
+  }
+  isRelativeOf(type, indi, every = false) {
+    const usedIndi = typeof indi === "string" ? this.index(0)?.getGedcom()?.indi(indi) : indi;
+    let getter;
+    if (type === "sibling") {
+      getter = "getSiblings";
+    }
+    if (type === "parent") {
+      getter = "getParents";
+    }
+    if (type === "child") {
+      getter = "getChildren";
+    }
+    if (type === "spouse") {
+      getter = "getCoParents";
+    }
+    if (type === "parentInLaw") {
+      getter = "getParentsInLaw";
+    }
+    if (type === "childInLaw") {
+      getter = "getChildrenInLaw";
+    }
+    if (!usedIndi || !getter) {
+      return false;
+    }
+    const relatives = usedIndi[getter]();
+    const thisIds = this.keys();
+    if (relatives.length <= 0 || this.length <= 0) {
+      return false;
+    }
+    const filtered = relatives.filter({ id: thisIds });
+    if (every) {
+      return filtered.length === this.length ? filtered.index(0)?.id || true : false;
+    }
+    return filtered.length > 0 ? filtered.index(0)?.id || true : false;
+  }
+  isSiblingOf(indi, every = false) {
+    return this.isRelativeOf("sibling", indi, every);
+  }
+  isSpouseOf(indi, every = false) {
+    return this.isRelativeOf("spouse", indi, every);
+  }
+  isParentOf(indi, every = false) {
+    return this.isRelativeOf("parent", indi, every);
+  }
+  isChildOf(indi, every = false) {
+    return this.isRelativeOf("child", indi, every);
+  }
+  isParentInLawOf(indi, every = false) {
+    return this.isRelativeOf("parentInLaw", indi, every);
+  }
+  isChildInLawOf(indi, every = false) {
+    return this.isRelativeOf("childInLaw", indi, every);
+  }
+  splitByFamily(type, relativeTo) {
+    const splittedList = {};
+    const familiesRelativeTo = relativeTo?.get(type !== "Parents" ? "FAMS" : "FAMC")?.toValueList().keys() ?? [];
+    let lengthOfIndividuals = 0;
+    this.forEach((indi) => {
+      const families = indi.get(type === "Spouses" ? "FAMS" : "FAMC")?.toValueList();
+      if (families) {
+        families.keys().forEach((fKey) => {
+          const famKey = fKey;
+          if (familiesRelativeTo && !familiesRelativeTo.includes(famKey)) {
+            return;
+          }
+          if (!splittedList[famKey]) {
+            splittedList[famKey] = new _Individuals();
+          }
+          splittedList[famKey]?.append(indi);
+          lengthOfIndividuals++;
+        });
+      }
+    });
+    if (type === "Spouses" && relativeTo) {
+      const missingFams = difference(
+        familiesRelativeTo,
+        Object.keys(splittedList)
+      );
+      if (missingFams.length) {
+        missingFams.forEach((fKey) => {
+          const famKey = fKey;
+          if (familiesRelativeTo && !familiesRelativeTo.includes(famKey)) {
+            return;
+          }
+          const missingChildren = relativeTo.getGedcom()?.fam(famKey)?.getChildren();
+          if (!splittedList[famKey] && missingChildren?.length) {
+            splittedList[famKey] = new _Individuals();
+          }
+        });
+      }
+    }
+    return {
+      items: splittedList,
+      lengthOfFamily: Object.keys(splittedList).length,
+      lengthOfIndividuals
+    };
+  }
+  getRelativesOnDegree(degree = 0) {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getRelativesOnLevel(degree));
+      }
+    });
+    return persons;
+  }
+  getRelativesOnLevel(level = 0, filter) {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getRelativesOnLevel(level, filter));
+      }
+    });
+    return persons;
+  }
+  getAscendants(level = 0, filter) {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getAscendants(level, filter));
+      }
+    });
+    return persons;
+  }
+  getDescendants(level = 0, filter) {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getDescendants(level, filter));
+      }
+    });
+    return persons;
+  }
+  getAllAscendants(individuals) {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getAllAscendants(individuals));
+      }
+    });
+    return persons;
+  }
+  getAllDescendants(individuals, containDescendantsInLaw = false) {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(
+          indi.getAllDescendants(individuals, containDescendantsInLaw)
+        );
+      }
+    });
+    return persons;
+  }
+  getSiblings() {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getSiblings());
+      }
+    });
+    return persons;
+  }
+  getChildren() {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getChildren());
+      }
+    });
+    return persons;
+  }
+  getParents() {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getParents());
+      }
+    });
+    return persons;
+  }
+  getCoParents() {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getCoParents());
+      }
+    });
+    return persons;
+  }
+  getSpouses() {
+    const persons = new _Individuals();
+    this.values().forEach((indi) => {
+      if (indi) {
+        persons.merge(indi.getCoParents());
+      }
+    });
+    return persons;
+  }
+  toName() {
+    return super.toProp("NAME")?.toValue();
+  }
+  toList() {
+    return new _Individuals().concat(this.getItems());
+  }
+};
+
+// src/classes/name.ts
+var CommonName = class extends Common {
+  constructor(gedcom, id, main, parent) {
+    super(gedcom, id, main, parent);
+    delete this.id;
+  }
+  set value(value) {
+    if (value && this._main instanceof Indi) {
+      const nameParts = value.match(
+        /(?<givenname>[^/]*)(\/(?<surname>[^/]*)\/)?(?<suffix>.*)$/
+      )?.groups;
+      if (nameParts?.givenname?.trim()) {
+        this.GIVN = this.GIVN || createCommon(this._gedcom, void 0, this.main);
+        this.GIVN.isListable = false;
+        this.GIVN.value = nameParts.givenname.trim();
+      }
+      if (nameParts?.surname?.trim()) {
+        this.SURN = this.SURN || createCommon(this._gedcom, void 0, this.main);
+        this.SURN.value = nameParts.surname.trim();
+        this.SURN.isListable = false;
+      }
+      if (nameParts?.suffix?.trim()) {
+        this.NSFX = this.NSFX || createCommon(this._gedcom, void 0, this.main);
+        this.NSFX.value = nameParts.suffix.trim();
+        this.NSFX.isListable = false;
+      }
+    }
+    this._value = value;
+  }
+  get value() {
+    if (this._value === void 0 && this.DISPLAY?.value) {
+      return this.DISPLAY?.value;
+    }
+    return this._value;
+  }
+  name(value) {
+    this.value = value;
+    return this;
+  }
+};
+var createCommonName = (gedcom, id, main, parent) => {
+  return createProxy(
+    new CommonName(gedcom, id, main, parent)
+  );
+};
+
+// src/classes/indi.ts
+var ALLOWED_FACTS = [
+  "EVEN",
+  "OCCU",
+  "OCCUPATIONS",
+  "RESI",
+  "BIRT",
+  "DEAT",
+  "BAPT",
+  "BAPM",
+  "CHRI",
+  "CHR",
+  "CHRA",
+  "BURI",
+  "CREM",
+  "ADOP",
+  "BARM",
+  "BASM",
+  "BLES",
+  "CONF",
+  "FCOM",
+  "ORDN",
+  "NATU",
+  "EMIG",
+  "IMMI",
+  "CENS",
+  "PROB",
+  "WILL",
+  "GRAD",
+  "RETI",
+  "EDUC",
+  "DIV",
+  "RELI",
+  "CAST",
+  "DSCR",
+  "NATI",
+  "PROP",
+  "SSN",
+  "TITL",
+  "ADDR",
+  "BAPL",
+  "CONL",
+  "ENDL",
+  "SLGC",
+  "_MILT",
+  "_MILTID",
+  "FACT",
+  "_ORIG",
+  "_WLNK",
+  "WWW",
+  "URL"
+];
+var DISALLOWED_CUSTOM_FACTS = ["DNA Test", "Newspaper"];
+var CustomFactRenderers = {
+  AKA: (label, fact, indi) => {
+    const originalNameObj = indi?.NAME;
+    const note = fact.get("NOTE");
+    const factName = note?.toValue();
+    const name = createCommonName(fact.getGedcom(), void 0, indi);
+    const suffix = originalNameObj?.NSFX?.toValue();
+    const surname = originalNameObj?.SURN?.toValue();
+    const givenname = originalNameObj?.GIVN?.toValue();
+    const nameParts = [
+      ...givenname?.split(" ").map((s) => ({ name: s, givenname: true })) ?? [],
+      ...surname?.split(" ").map((s) => ({ name: s, surname: true })) ?? [],
+      ...suffix?.split(" ").map((s) => ({ name: s, suffix: true })) ?? []
+    ].filter(Boolean);
+    const factParts = factName?.split(" ");
+    if (nameParts.length === factParts?.length && !(note instanceof CommonName)) {
+      const guessedSuffix = [];
+      const guessedSurname = [];
+      const guessedGivenname = [];
+      factParts.forEach((f, i) => {
+        const namePart = nameParts[i];
+        if (!f) {
+          return;
+        }
+        if (namePart.suffix) {
+          guessedSuffix.push(f);
+        } else if (namePart.givenname) {
+          guessedGivenname.push(f);
+        } else if (namePart.surname) {
+          guessedSurname.push(f);
+        }
+      });
+      const allNamePart = [];
+      if (guessedGivenname.length) {
+        allNamePart.push(guessedGivenname.join(" "));
+      }
+      if (guessedSurname.length) {
+        allNamePart.push(`/${guessedSurname.join(" ")}/`);
+      }
+      if (guessedSuffix.length) {
+        allNamePart.push(guessedSuffix.join(" "));
+      }
+      name.value = allNamePart.join(" ");
+    } else {
+      name.value = factName;
+    }
+    fact.set("NOTE", name);
+    label.value = "AKA";
+    fact.set("_LABEL", label);
+  }
+};
+var relativesOnLevelCache = relativesCache("relativesOnLevelCache");
+var relativesOnDegreeCache = relativesCache("relativesOnDegreeCache");
+var Indi = class extends Common {
+  toName() {
+    return this.get("NAME")?.toValue();
+  }
+  toNaturalName() {
+    return this.get("NAME")?.toValue()?.replaceAll("/", "");
+  }
+  toList() {
+    return new Individuals().concat(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.id ? { [this.id]: this } : { ...[this] }
+    );
+  }
+  generateTree(props) {
+    const {
+      generations,
+      level,
+      index,
+      showDescendants,
+      offspringSpouses,
+      ancestorSpouses,
+      onlyDescendants,
+      maxLevel,
+      minLevel,
+      drawNonBiologicalAncestors,
+      ancestorSiblings
+    } = props;
+    if (!this.id) {
+      throw new Error("Indi must have an id");
+    }
+    const isMainDescendantLevel = showDescendants && level <= 1;
+    const isDescendantLevel = showDescendants && level < 1;
+    if (level < 1 && !isDescendantLevel) {
+      throw new Error("Arguments 2 must be greater than 0.");
+    }
+    if (maxLevel !== void 0 && maxLevel < level || minLevel !== void 0 && minLevel > level) {
+      return this;
+    }
+    const gens = generations ?? {
+      existed: {},
+      tree: {},
+      halves: {},
+      lastItems: {}
+    };
+    const families = this.getFamiliesBiologicalFirst("FAMC");
+    const familiesAllMember = families.getParents();
+    families.forEach((fam, famKey, famIndex) => {
+      if (!this.id) {
+        return;
       }
       const id = fam.id;
       let father = isDescendantLevel ? void 0 : fam.getHusband().index(0);
@@ -2281,7 +3294,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(
@@ -2293,7 +3306,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(
@@ -2311,10 +3324,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) {
@@ -2332,13 +3349,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,
@@ -2353,7 +3373,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, "-");
@@ -2384,9 +3404,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] = {
@@ -2509,10 +3531,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,
@@ -2549,10 +3571,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,
@@ -2592,7 +3614,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) {
@@ -2604,39 +3639,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,
@@ -2868,11 +3904,161 @@ var Indi = class extends Common {
   isMale() {
     return this.get("SEX")?.toValue() === "M";
   }
-  isFemale() {
-    return this.get("SEX")?.toValue() === "F";
+  isFemale() {
+    return this.get("SEX")?.toValue() === "F";
+  }
+  isUnknownSex() {
+    return !this.isMale() && !this.isFemale();
+  }
+  addSpouse(other) {
+    if (!this.id || !other?.id || this.id === other.id || !this._gedcom) {
+      return void 0;
+    }
+    const existing = getFamilyWith(this, other.id);
+    if (existing) {
+      return existing;
+    }
+    const fam = this._gedcom.createFamily();
+    if (!fam.addSpouse(this) || !fam.addSpouse(other)) {
+      return void 0;
+    }
+    return fam;
+  }
+  addChild(child, pedigree) {
+    if (!this.id || !child?.id || this.id === child.id || !this._gedcom) {
+      return void 0;
+    }
+    const existing = findReusableParentChildFamily(
+      this,
+      child
+    );
+    if (existing === "already") {
+      const fam2 = child.getFamilies("FAMC")?.find(
+        (item) => !!item && item.hasParent(this.id) && item.hasChild(child.id)
+      );
+      if (fam2) {
+        setChildPedigree(
+          fam2,
+          child,
+          pedigree,
+          this
+        );
+      }
+      return fam2;
+    }
+    const fam = existing ?? this._gedcom.createFamily();
+    if (!fam.addSpouse(this)) {
+      return void 0;
+    }
+    if (!fam.addChild(child, pedigree, this)) {
+      return void 0;
+    }
+    return fam;
+  }
+  addParent(parent, pedigree) {
+    return parent.addChild(this, pedigree);
+  }
+  /**
+   * 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);
   }
-  isUnknownSex() {
-    return !this.isMale() && !this.isFemale();
+  addNonEvent(input) {
+    return addNonEvent(this, input);
   }
   getParentType(id) {
     let indi;
@@ -2914,7 +4100,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 */;
       }
@@ -3074,7 +4260,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 */;
@@ -3473,7 +4661,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);
           }
@@ -3581,7 +4769,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());
         }
@@ -5780,7 +6968,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",
@@ -5788,6 +6980,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");
@@ -5812,29 +7009,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);
@@ -5937,6 +7150,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;
@@ -5944,826 +7166,987 @@ 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(
-      `^${level} (DAY|MONTH|YEAR)( |$)|^${level} NOTE (Abt\\.|Bef\\.|Aft\\.)$`
-    );
-    return super.toGedcomLines(tag, level, options).filter((line) => !internal.test(line));
-  }
-  inRange(range, trueIfNoYear = false) {
-    return inRange(this.YEAR?.value, range, trueIfNoYear);
-  }
-};
-var createCommonDate = (gedcom, id, main, parent) => {
-  return createProxy(
-    new CommonDate(gedcom, id, main, parent)
-  );
-};
-var isCommonDate = (value) => {
-  return !!value && value !== null && typeof value === "object" && "_date" in value;
-};
-
-// src/utils/get-family-with.ts
-var getFamilyWith = (person1, person2, famType = "FAMS") => {
-  return person1?.get(famType)?.toValueList().find((fam) => {
-    const family = fam;
-    return famType === "FAMC" || family?.HUSB?.value === person2 || family?.WIFE?.value === person2;
-  });
-};
-
-// src/constants/orders.ts
-var BIRTH_ASC = {
-  "BIRT.DATE": {
-    direction: "ASC",
-    getter: (value, raw) => {
-      if (isCommonDate(raw) && raw.rawValue) {
-        return raw.rawValue.getTime();
-      }
-      return new Date(value).getTime();
-    }
-  }
-};
-var BIRTH_DESC = {
-  "BIRT.DATE": {
-    direction: "DESC",
-    getter: (value, raw) => {
-      if (isCommonDate(raw) && raw.rawValue) {
-        return raw.rawValue.getTime();
-      }
-      return new Date(value).getTime();
-    }
-  }
-};
-var DEATH_ASC = {
-  "DEAT.DATE": {
-    direction: "ASC",
-    getter: (value, raw) => {
-      if (isCommonDate(raw) && raw.rawValue) {
-        return raw.rawValue.getTime();
-      }
-      return new Date(value).getTime();
-    }
-  }
-};
-var DEATH_DESC = {
-  "DEAT.DATE": {
-    direction: "DESC",
-    getter: (value, raw) => {
-      if (isCommonDate(raw) && raw.rawValue) {
-        return raw.rawValue.getTime();
-      }
-      return new Date(value).getTime();
-    }
-  }
-};
-var DATE_ASC = {
-  DATE: {
-    direction: "ASC",
-    getter: (value, raw) => {
-      if (isCommonDate(raw) && raw.rawValue) {
-        return raw.rawValue.getTime();
-      }
-      return new Date(value).getTime();
-    }
-  }
-};
-var chars = [
-  "a",
-  "\xE0",
-  "\xE1",
-  "\xE2",
-  "\xE4",
-  "\xE6",
-  "\xE3",
-  "\xE5",
-  "\u0101",
-  "b",
-  "c",
-  "\xE7",
-  "\u0107",
-  "\u010D",
-  "cs",
-  "d",
-  "dz",
-  "dzs",
-  "e",
-  "\xE8",
-  "\xE9",
-  "\xEA",
-  "\xEB",
-  "\u0113",
-  "\u0117",
-  "\u0119",
-  "f",
-  "g",
-  "gy",
-  "h",
-  "i",
-  "\xEE",
-  "\xEF",
-  "\xED",
-  "\u012B",
-  "\u012F",
-  "\xEC",
-  "j",
-  "k",
-  "l",
-  "\u0142",
-  "ly",
-  "m",
-  "n",
-  "\xF1",
-  "\u0144",
-  "ny",
-  "o",
-  "\xF3",
-  "\xF6",
-  "\u0151",
-  "\xF4",
-  "\xF2",
-  "\xF5",
-  "\u0153",
-  "\xF8",
-  "\u014D",
-  "p",
-  "q",
-  "r",
-  "s",
-  "\u015B",
-  "\u0161",
-  "\xDF",
-  "sz",
-  "t",
-  "ty",
-  "u",
-  "\xFA",
-  "\xFC",
-  "\u0171",
-  "\xFB",
-  "\xF9",
-  "\u016B",
-  "v",
-  "w",
-  "x",
-  "y",
-  "z",
-  "zs"
-];
-chars.reduce((acc, curr, idx) => {
-  acc[curr] = idx;
-  return acc;
-}, {});
-var getBirthAsc = (itemA, _keyA, itemB, _keyB) => {
-  const birthA = itemA?.BIRT?.index(0);
-  const birthB = itemB?.BIRT?.index(0);
-  const valueA = birthA?.DATE?.rawValue;
-  const valueB = birthB?.DATE?.rawValue;
-  if (valueA?.getTime() === valueB?.getTime()) {
-    return 0;
-  }
-  if (!valueA || valueB && valueA > valueB) {
-    return 1;
-  }
-  return -1;
-};
-var getMarriageAsc = (person, famType = "FAMS") => (itemA, _keyA, itemB, _keyB) => {
-  if (!person && famType === "FAMS") {
-    return 0;
-  }
-  const familyA = getFamilyWith(itemA, person);
-  const familyB = getFamilyWith(itemB, person);
-  const marriageA = familyA?.MARR?.DATE?.rawValue;
-  const marriageB = familyB?.MARR?.DATE?.rawValue;
-  if (marriageA?.getTime() === marriageB?.getTime()) {
-    return 0;
-  }
-  if (!marriageA || marriageB && marriageA > marriageB) {
-    return 1;
-  }
-  return -1;
-};
-var getMarriageAscAndChildBirth = (person) => (itemA, keyA, itemB, keyB) => {
-  const marriageSort = getMarriageAsc(person)(itemA, keyA, itemB, keyB);
-  if (marriageSort !== 0) {
-    return marriageSort;
-  }
-  const familyA = getFamilyWith(itemA, person);
-  const familyB = getFamilyWith(itemB, person);
-  const childA = familyA?.getChildren().orderBy(BIRTH_ASC).index(0);
-  const childB = familyB?.getChildren().orderBy(BIRTH_ASC).index(0);
-  return getBirthAsc(childA, keyA, childB);
-};
-var uniqueItemsCache = /* @__PURE__ */ new WeakMap();
-var setNestedGroup = (obj, key, value, uniqueCounting = true) => {
-  const parts = Array.isArray(key) ? key : key.split(/,\s*/);
-  set(obj, [...parts, "items"], value);
-  parts.forEach((_, index) => {
-    if (!uniqueCounting) {
-      const key2 = [...parts.toSpliced(index + 1), "length"];
-      const length = get(obj, key2);
-      set(obj, key2, (length ?? 0) + value.length);
-      return;
-    }
-    const pathKey = [...parts.toSpliced(index + 1)];
-    const node = get(obj, pathKey);
-    if (node) {
-      let uniqueItems = uniqueItemsCache.get(node);
-      if (!uniqueItems) {
-        uniqueItems = new Individuals();
-        uniqueItemsCache.set(node, uniqueItems);
-      }
-      uniqueItems.merge(value);
-      set(obj, [...pathKey, "length"], uniqueItems.length);
-    }
-  });
-};
-
-// src/utils/place-parser.ts
-var getPlaceParts = (place = []) => {
-  const partsString = Array.isArray(place) ? place.filter(Boolean).join(", ") : place;
-  if (!partsString) {
-    return [{}];
-  }
-  const parts = partsString.split(/,\s*/).map((p) => p.trim()).filter(Boolean);
-  if (parts.length === 0) {
-    return [{}];
+  toGedcomLines(tag, level = 0, options) {
+    const internal = new RegExp(
+      `^${level} (DAY|MONTH|YEAR)( |$)|^${level} NOTE (Abt\\.|Bef\\.|Aft\\.)$`
+    );
+    return super.toGedcomLines(tag, level, options).filter((line) => !internal.test(line));
   }
-  const result = {};
-  if (parts.length === 1) {
-    result.town = parts[0];
-  } else if (parts.length === 2) {
-    result.town = parts[0];
-    result.country = parts[1];
-  } else if (parts.length === 3) {
-    result.town = parts[0];
-    result.county = parts[1];
-    result.country = parts[2];
-  } else {
-    result.leftParts = parts.slice(0, parts.length - 3);
-    result.town = parts[parts.length - 3];
-    result.county = parts[parts.length - 2];
-    result.country = parts[parts.length - 1];
+  inRange(range, trueIfNoYear = false) {
+    return inRange(this.YEAR?.value, range, trueIfNoYear);
   }
-  return [result];
 };
-
-// src/utils/place-translator.ts
-var placeTranslator = (place) => {
-  return Array.isArray(place) ? place.join(", ") : place;
+var createCommonDate = (gedcom, id, main, parent) => {
+  return createProxy(
+    new CommonDate(gedcom, id, main, parent)
+  );
+};
+var isCommonDate = (value) => {
+  return !!value && value !== null && typeof value === "object" && "_date" in value;
 };
 
-// src/classes/indis.ts
-var Individuals = class _Individuals extends List {
-  copy() {
-    return super.copy(_Individuals);
+// src/utils/fact-edit.ts
+var SINGLETON_TAGS = /* @__PURE__ */ new Set(["BIRT", "DEAT", "SSN", "SEX", "DSCR"]);
+var firstRecord = (node) => {
+  if (!node) {
+    return void 0;
   }
-  except(item) {
-    return super.except(item, _Individuals);
+  if (node instanceof List) {
+    return node.index(0);
   }
-  filter(filters) {
-    return super.filter(filters, _Individuals);
+  return node.index(0) ?? node;
+};
+var setDateOn = (gedcom, owner, parent, date) => {
+  const trimmed = date.trim();
+  if (!trimmed) {
+    return;
   }
-  find(filters) {
-    return super.find(filters, _Individuals);
+  let dateNode = parent.get("DATE");
+  if (!dateNode || dateNode instanceof List) {
+    dateNode = createCommonDate(gedcom, void 0, owner, parent);
+    dateNode.type = "DATE";
+    parent.set("DATE", dateNode);
   }
-  unattachedFilter(useUnattached) {
-    if (useUnattached) {
-      return this;
-    }
-    return this.filter((item) => !item.isUnattachedMember());
+  dateNode.value = trimmed;
+};
+var fillFact = (gedcom, owner, event, input) => {
+  if (input.value?.trim()) {
+    event.value = input.value.trim();
   }
-  orderBy(orders) {
-    return super.orderBy(orders, _Individuals);
+  if (input.type?.trim()) {
+    event.set("TYPE", input.type.trim());
   }
-  getFirstEvent() {
-    const firstBirthPerson = this.getFirstBirth();
-    const firstDeathPerson = this.getFirstDeath();
-    const firstBirth = firstBirthPerson?.BIRT?.index(0);
-    const firstDeath = firstDeathPerson?.DEAT?.index(0);
-    if (!firstBirth?.DATE?.rawValue && !firstDeath?.DATE?.rawValue) {
-      return void 0;
-    }
-    if (!firstBirth?.DATE?.rawValue) {
-      return firstDeathPerson;
-    }
-    if (!firstDeath?.DATE?.rawValue) {
-      return firstBirthPerson;
-    }
-    if (firstDeath.DATE.rawValue < firstBirth.DATE.rawValue) {
-      return firstDeathPerson;
-    }
-    return firstBirthPerson;
+  if (input.date) {
+    setDateOn(gedcom, owner, event, input.date);
   }
-  getLastEvent() {
-    const lastDeathPerson = this.getLastDeath();
-    const lastBirthPerson = this.getLastBirth();
-    const lastBirth = lastBirthPerson?.BIRT?.index(0);
-    const lastDeath = lastDeathPerson?.DEAT?.index(0);
-    if (!lastBirth?.DATE?.rawValue && !lastDeath?.DATE?.rawValue) {
-      return void 0;
-    }
-    if (!lastDeath?.DATE?.rawValue) {
-      return lastBirthPerson;
-    }
-    if (!lastBirth?.DATE?.rawValue) {
-      return lastDeathPerson;
-    }
-    if (lastDeath.DATE.rawValue < lastBirth.DATE.rawValue) {
-      return lastBirthPerson;
-    }
-    return lastDeathPerson;
+  if (input.place?.trim()) {
+    event.set("PLAC", input.place.trim());
   }
-  getFirstBirth() {
-    return this.filter((item) => {
-      const birth = item.BIRT?.index(0);
-      if (birth?.DATE?.rawValue?.getTime() === 0) {
-        return true;
-      }
-      return !!birth?.DATE?.rawValue?.getTime();
-    }).orderBy(BIRTH_ASC).index(0);
+  if (input.note?.trim()) {
+    event.set("NOTE", input.note.trim());
   }
-  getLastBirth() {
-    return this.filter((item) => {
-      const birth = item.BIRT?.index(0);
-      if (birth?.DATE?.rawValue?.getTime() === 0) {
-        return true;
-      }
-      return !!birth?.DATE?.rawValue?.getTime();
-    }).orderBy(BIRTH_DESC).index(0);
+};
+var addIndividualFact = (indi, input) => {
+  const gedcom = indi.getGedcom();
+  if (!gedcom) {
+    return void 0;
   }
-  getFirstDeath() {
-    return this.filter((item) => {
-      const death = item.DEAT?.index(0);
-      if (death?.DATE?.rawValue?.getTime() === 0) {
-        return true;
-      }
-      return !!death?.DATE?.rawValue?.getTime();
-    }).orderBy(DEATH_ASC).index(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);
+    }
   }
-  getLastDeath() {
-    return this.filter((item) => {
-      const death = item.DEAT?.index(0);
-      if (death?.DATE?.rawValue?.getTime() === 0) {
-        return true;
-      }
-      return !!death?.DATE?.rawValue?.getTime();
-    }).orderBy(DEATH_DESC).index(0);
+  fillFact(gedcom, indi, event, input);
+  return event;
+};
+var addFamilyFact = (fam, input) => {
+  const gedcom = fam.getGedcom();
+  if (!gedcom) {
+    return void 0;
   }
-  groupBy(group, sort, minOccurance = -1, lessOccuranceLabel) {
-    return super.groupBy(
-      group,
-      sort,
-      minOccurance,
-      lessOccuranceLabel,
-      _Individuals
-    );
+  const event = createCommon(gedcom, void 0, fam);
+  event.type = input.tag;
+  fam.assign(input.tag, event);
+  fillFact(gedcom, fam, event, input);
+  return event;
+};
+var addNonEvent = (owner, input) => {
+  const gedcom = owner.getGedcom();
+  const eventType = input.event?.trim().toUpperCase();
+  if (!gedcom || !eventType) {
+    return void 0;
   }
-  groupByFirstLetters(sort = "group", minOccurance = -1, settings) {
-    return this.groupBy(
-      (item) => {
-        const { letter } = nameFormatter(item, settings);
-        return letter.trim() || "Unknown";
-      },
-      sort,
-      minOccurance,
-      "Letters appearing less than 5 times"
-    );
+  const no = createCommon(gedcom, void 0, owner);
+  no.type = "NO";
+  no.value = eventType;
+  if (input.date?.trim()) {
+    setDateOn(gedcom, owner, no, input.date);
   }
-  groupBySurnames(sort, minOccurance = -1) {
-    return this.groupBy(
-      "NAME.SURN",
-      sort,
-      minOccurance,
-      "Surnames appearing less than 5 times"
-    );
+  if (input.note?.trim()) {
+    no.set("NOTE", input.note.trim());
   }
-  groupByTimeRanges(range, sort = "group", minOccurance = -1) {
-    return this.groupBy(
-      {
-        ["BIRT.DATE.YEAR"]: {
-          getter: (year) => {
-            if (!Number(year)) {
-              return;
-            }
-            if (range === 1 /* Year */) {
-              return `${Math.floor(Number(year) / range) * range}`;
-            }
-            return `${Math.floor(Number(year) / range) * range + 1}-${Math.ceil((Number(year) + 1) / range) * range}`;
-          }
-        }
-      },
-      sort,
-      minOccurance,
-      "Time ranges appearing less than 5 times"
-    );
+  owner.assign("NO", no);
+  return no;
+};
+
+// src/classes/fam.ts
+var Fam = class extends Common {
+  getFamilyMembers(type) {
+    const familyMembers = new Individuals();
+    this.get(type)?.toList().forEach((item) => {
+      const indiId = item.value;
+      const indi = this._gedcom?.indi(indiId);
+      if (indi) {
+        familyMembers.item(indiId, indi);
+      }
+    });
+    return familyMembers;
   }
-  nestedGroupByPlacesAndTimeRanges(sort, minOccurance = -1, uniqueCounting = true) {
-    const placesWithYear = this.groupBy(
-      (item) => item.getPlaces().map((place) => {
-        const date = place.obj?.get("DATE");
-        if (date?.YEAR) {
-          return `${place.place}, ${date.YEAR}`;
-        }
-        return `${place.place}, Unknown`;
-      }).filter(Boolean),
-      sort,
-      minOccurance,
-      "Places appearing less than 5 times"
-    );
-    return Object.entries(placesWithYear).reduce(
-      (acc, [place, indis]) => {
-        setNestedGroup(acc, place, indis, uniqueCounting);
-        return acc;
-      },
-      {}
-    );
+  getChildren() {
+    return this.getFamilyMembers("CHIL");
   }
-  nestedGroupByTimeRangesAndPlaces(sort, minOccurance = -1, uniqueCounting = true) {
-    const placesWithYear = this.groupBy(
-      (item) => item.getPlaces().map((place) => {
-        const date = place.obj?.get("DATE");
-        if (date?.YEAR) {
-          return `${date.YEAR}, ${place.place}`;
-        }
-        return `Unknown, ${place.place}`;
-      }).filter(Boolean),
-      sort,
-      minOccurance,
-      "Places appearing less than 5 times"
-    );
-    return Object.entries(placesWithYear).reduce(
-      (acc, [place, indis]) => {
-        setNestedGroup(acc, place, indis, uniqueCounting);
-        return acc;
-      },
-      {}
-    );
+  getHusband() {
+    return this.getFamilyMembers("HUSB");
   }
-  nestedGroupByPlaces(sort, minOccurance = -1, partOrder = "reverse", translate = true, uniqueCounting = true, groupKeyTranslator) {
-    const places = this.groupByPlaces(
-      sort,
-      minOccurance,
-      partOrder,
-      translate,
-      groupKeyTranslator
-    );
-    return Object.entries(places).reduce(
-      (acc, [place, indis]) => {
-        setNestedGroup(acc, place, indis, uniqueCounting);
-        return acc;
-      },
-      {}
+  getWife() {
+    return this.getFamilyMembers("WIFE");
+  }
+  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
     );
   }
-  groupByPlaces(sort, minOccurance = -1, partOrder = "reverse", translate = true, groupKeyTranslator) {
-    return this.groupBy(
-      (item) => item.getPlaces().map((place) => {
-        const placeParts = getPlaceParts(place.place || "");
-        const {
-          leftParts = [],
-          town,
-          county,
-          country
-        } = placeParts[0] || {};
-        const normalizedParts = [
-          ...leftParts,
-          town,
-          county,
-          country
-        ].filter(Boolean);
-        const orderedParts = partOrder === "original" ? normalizedParts : normalizedParts.toReversed();
-        let newPlace = "";
-        if (groupKeyTranslator) {
-          newPlace = groupKeyTranslator(orderedParts);
-        } else if (translate) {
-          {
-            newPlace = placeTranslator(orderedParts);
-          }
-        } else {
-          newPlace = orderedParts.join(", ");
-        }
-        if (!newPlace) {
-          return void 0;
-        }
-        return {
-          marker: place.place,
-          group: newPlace
-        };
-      }).filter(Boolean),
-      sort,
-      minOccurance,
-      "Places appearing less than 5 times"
+  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
+      this.id ? { [this.id]: this } : { ...[this] }
     );
   }
-  getFacts() {
-    const facts = new List();
-    this.values().forEach((indi) => {
-      const indiFacts = indi?.getFacts();
-      if (indi?.id && indiFacts) {
-        facts.merge(indiFacts);
+};
+var createFam = (gedcom, id, main, parent) => {
+  return createProxy(
+    new Fam(gedcom, id, main, parent)
+  );
+};
+
+// src/classes/fams.ts
+var Families = class _Families extends List {
+  copy() {
+    return super.copy(_Families);
+  }
+  except(item) {
+    return super.except(item, _Families);
+  }
+  filter(filters) {
+    return super.filter(filters, _Families);
+  }
+  find(filters) {
+    return super.find(filters, _Families);
+  }
+  orderBy(orders) {
+    return super.orderBy(orders, _Families);
+  }
+  getParents() {
+    const persons = new Individuals();
+    this.values().forEach((fam) => {
+      if (fam && fam instanceof Fam) {
+        persons.merge(fam.getParents());
       }
     });
-    return facts;
+    return persons;
   }
-  isRelativeOf(type, indi, every = false) {
-    const usedIndi = typeof indi === "string" ? this.index(0)?.getGedcom()?.indi(indi) : indi;
-    let getter;
-    if (type === "sibling") {
-      getter = "getSiblings";
-    }
-    if (type === "parent") {
-      getter = "getParents";
-    }
-    if (type === "child") {
-      getter = "getChildren";
-    }
-    if (type === "spouse") {
-      getter = "getCoParents";
-    }
-    if (type === "parentInLaw") {
-      getter = "getParentsInLaw";
-    }
-    if (type === "childInLaw") {
-      getter = "getChildrenInLaw";
-    }
-    if (!usedIndi || !getter) {
-      return false;
-    }
-    const relatives = usedIndi[getter]();
-    const thisIds = this.keys();
-    if (relatives.length <= 0 || this.length <= 0) {
-      return false;
+  getChildren() {
+    const persons = new Individuals();
+    this.values().forEach((fam) => {
+      if (fam && fam instanceof Fam) {
+        persons.merge(fam.getChildren());
+      }
+    });
+    return persons;
+  }
+  toList() {
+    return new _Families().concat(this.getItems());
+  }
+};
+
+// src/utils/gedcom-version.ts
+var normalizeGedcomVersion = (value) => {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.startsWith("7")) {
+    return "7.0";
+  }
+  return "5.5.1";
+};
+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;
     }
-    const filtered = relatives.filter({ id: thisIds });
-    if (every) {
-      return filtered.length === this.length ? filtered.index(0)?.id || true : false;
+    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
+      });
     }
-    return filtered.length > 0 ? filtered.index(0)?.id || true : false;
   }
-  isSiblingOf(indi, every = false) {
-    return this.isRelativeOf("sibling", indi, every);
+  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 });
   }
-  isSpouseOf(indi, every = false) {
-    return this.isRelativeOf("spouse", indi, every);
+  zip.file(GEDZIP_GEDCOM_ENTRY, rewriteGedcomFilePaths(gedcomText, urlToPath));
+  return zip.generateAsync({ type: "uint8array" });
+};
+
+// 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);
   }
-  isParentOf(indi, every = false) {
-    return this.isRelativeOf("parent", indi, every);
+  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;
   }
-  isChildOf(indi, every = false) {
-    return this.isRelativeOf("child", indi, every);
+  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;
   }
-  isParentInLawOf(indi, every = false) {
-    return this.isRelativeOf("parentInLaw", indi, every);
+  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 };
   }
-  isChildInLawOf(indi, every = false) {
-    return this.isRelativeOf("childInLaw", indi, every);
+  return {
+    calendar: match.groups.calendar.toUpperCase(),
+    rest: value.slice(match[0].length)
+  };
+};
+var withGedcom7Calendar = (value, calendar) => {
+  if (!calendar || calendar.toUpperCase() === "GREGORIAN") {
+    return value;
   }
-  splitByFamily(type, relativeTo) {
-    const splittedList = {};
-    const familiesRelativeTo = relativeTo?.get(type !== "Parents" ? "FAMS" : "FAMC")?.toValueList().keys() ?? [];
-    let lengthOfIndividuals = 0;
-    this.forEach((indi) => {
-      const families = indi.get(type === "Spouses" ? "FAMS" : "FAMC")?.toValueList();
-      if (families) {
-        families.keys().forEach((fKey) => {
-          const famKey = fKey;
-          if (familiesRelativeTo && !familiesRelativeTo.includes(famKey)) {
-            return;
-          }
-          if (!splittedList[famKey]) {
-            splittedList[famKey] = new _Individuals();
-          }
-          splittedList[famKey]?.append(indi);
-          lengthOfIndividuals++;
-        });
+  const upper = calendar.toUpperCase();
+  if (GEDCOM7_CALENDARS.includes(upper)) {
+    const { rest } = parseGedcom7CalendarPrefix(value);
+    return `${upper} ${rest}`.trim();
+  }
+  return value;
+};
+var applyGedcom7DatePhrases = (gedcom) => {
+  const restores = [];
+  const visitDate = (dateNode) => {
+    if (!dateNode || typeof dateNode.toValue !== "function") {
+      return;
+    }
+    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;
+          });
+        }
       }
-    });
-    if (type === "Spouses" && relativeTo) {
-      const missingFams = difference(
-        familiesRelativeTo,
-        Object.keys(splittedList)
+      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
       );
-      if (missingFams.length) {
-        missingFams.forEach((fKey) => {
-          const famKey = fKey;
-          if (familiesRelativeTo && !familiesRelativeTo.includes(famKey)) {
-            return;
-          }
-          const missingChildren = relativeTo.getGedcom()?.fam(famKey)?.getChildren();
-          if (!splittedList[famKey] && missingChildren?.length) {
-            splittedList[famKey] = new _Individuals();
-          }
-        });
-      }
+      phrase.value = raw.trim();
+      dateNode.set("PHRASE", phrase);
     }
-    return {
-      items: splittedList,
-      lengthOfFamily: Object.keys(splittedList).length,
-      lengthOfIndividuals
-    };
-  }
-  getRelativesOnDegree(degree = 0) {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getRelativesOnLevel(degree));
+    restores.push(() => {
+      if (previousValue === void 0) {
+        dateNode.removeValue();
+      } else {
+        dateNode.value = previousValue;
       }
-    });
-    return persons;
-  }
-  getRelativesOnLevel(level = 0, filter) {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getRelativesOnLevel(level, filter));
+      if (previousPhrase) {
+        previousPhrase.value = previousPhraseValue;
+      } else {
+        dateNode.remove("PHRASE");
       }
     });
-    return persons;
-  }
-  getAscendants(level = 0, filter) {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getAscendants(level, filter));
-      }
+  };
+  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));
     });
-    return persons;
-  }
-  getDescendants(level = 0, filter) {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getDescendants(level, filter));
-      }
+  });
+  gedcom.fams()?.forEach((fam) => {
+    if (!fam) return;
+    ["MARR", "DIV", "ENGA", "ANUL", "EVEN"].forEach((tag) => {
+      fam.get(tag)?.toList()?.forEach((event) => walk(event));
     });
-    return persons;
+  });
+  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;
   }
-  getAllAscendants(individuals) {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getAllAscendants(individuals));
-      }
-    });
-    return persons;
+  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;
   }
-  getAllDescendants(individuals, containDescendantsInLaw = false) {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(
-          indi.getAllDescendants(individuals, containDescendantsInLaw)
-        );
-      }
-    });
-    return persons;
+  const uid = createGedcomUid();
+  record.set("UID", uid);
+  restores.push(() => {
+    record.remove("UID");
+  });
+};
+var applyGedcom7RecordMetadata = (gedcom, options) => {
+  const restores = [];
+  const 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;
   }
-  getSiblings() {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getSiblings());
-      }
-    });
-    return persons;
+  const tag = trimmed.slice(0, space).trim();
+  const uri = trimmed.slice(space + 1).trim();
+  if (!tag || !uri) {
+    return void 0;
   }
-  getChildren() {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getChildren());
-      }
-    });
-    return persons;
+  return { tag, uri };
+};
+var getExtensionSchema = (gedcom) => {
+  const map = /* @__PURE__ */ new Map();
+  const schma = gedcom.get("HEAD")?.get("SCHMA");
+  if (!schma) {
+    return map;
   }
-  getParents() {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getParents());
-      }
-    });
-    return persons;
+  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;
   }
-  getCoParents() {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getCoParents());
+  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);
       }
     });
-    return persons;
-  }
-  getSpouses() {
-    const persons = new _Individuals();
-    this.values().forEach((indi) => {
-      if (indi) {
-        persons.merge(indi.getCoParents());
+    previousPayloads.forEach(({ node, value }) => {
+      if (node && value !== void 0) {
+        node.value = value;
       }
     });
-    return persons;
-  }
-  toName() {
-    return super.toProp("NAME")?.toValue();
+  };
+};
+
+// package.json
+var package_default = {
+  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;
+
+// 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();
   }
-  toList() {
-    return new _Individuals().concat(this.getItems());
+  return fallback;
+};
+var mergeMediaLists = (...lists) => {
+  const merged = {};
+  for (const list of lists) {
+    if (!list) continue;
+    Object.assign(merged, list);
   }
+  return merged;
 };
 
-// src/classes/fam.ts
-var Fam = class extends Common {
-  getFamilyMembers(type) {
-    const familyMembers = new Individuals();
-    this.get(type)?.toList().forEach((item) => {
-      const indiId = item.value;
-      const indi = this._gedcom?.indi(indiId);
-      if (indi) {
-        familyMembers.item(indiId, indi);
-      }
-    });
-    return familyMembers;
-  }
-  getChildren() {
-    return this.getFamilyMembers("CHIL");
+// src/classes/note.ts
+var CommonNote = class extends Common {
+  constructor(gedcom, id, main, parent) {
+    super(gedcom, id, main, parent);
+    if (!id) {
+      delete this.id;
+    }
   }
-  getHusband() {
-    return this.getFamilyMembers("HUSB");
+  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);
+        }
+      }
+    }
   }
-  getWife() {
-    return this.getFamilyMembers("WIFE");
+  get value() {
+    const contents = this.get("CONT")?.toList().map((content) => content.value).join("\n");
+    if (contents) {
+      return `${this._value}
+${contents}`;
+    }
+    return this._value;
   }
-  getParents() {
-    return this.getHusband().copy().merge(this.getWife());
+  exportValue() {
+    return this._value;
   }
-  toList() {
-    return new Families().concat(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      this.id ? { [this.id]: this } : { ...[this] }
+};
+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 createFam = (gedcom, id, main, parent) => {
+var createObje = (gedcom, id, main, parent) => {
   return createProxy(
-    new Fam(gedcom, id, main, parent)
+    new Obje(gedcom, id, main, parent)
   );
 };
 
-// src/classes/fams.ts
-var Families = class _Families extends List {
+// src/classes/objes.ts
+var Objects = class _Objects extends List {
   copy() {
-    return super.copy(_Families);
-  }
-  except(item) {
-    return super.except(item, _Families);
-  }
-  filter(filters) {
-    return super.filter(filters, _Families);
-  }
-  find(filters) {
-    return super.find(filters, _Families);
-  }
-  orderBy(orders) {
-    return super.orderBy(orders, _Families);
-  }
-  getParents() {
-    const persons = new Individuals();
-    this.values().forEach((fam) => {
-      if (fam && fam instanceof Fam) {
-        persons.merge(fam.getParents());
-      }
-    });
-    return persons;
-  }
-  getChildren() {
-    const persons = new Individuals();
-    this.values().forEach((fam) => {
-      if (fam && fam instanceof Fam) {
-        persons.merge(fam.getChildren());
-      }
+    const newList = new _Objects();
+    this.entries().forEach(([key, value]) => {
+      newList.item(key, value);
     });
-    return persons;
+    return newList;
   }
-  toList() {
-    return new _Families().concat(this.getItems());
+  except(item) {
+    return this.copy().delete(item);
   }
 };
 
-// package.json
-var package_default = {
-  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;
-
 // src/classes/gedcom.ts
 var isObjectPatch = (value) => {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -6959,6 +8342,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");
   }
@@ -7043,18 +8609,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;
   }
@@ -7083,20 +8701,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();
@@ -7540,20 +9183,6 @@ var mergeGedcoms = (targetGedcom, sourceGedcom, strategy = "id") => {
   return mergedGedcom;
 };
 
-// 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() {
@@ -7596,144 +9225,6 @@ var Submitters = class _Submitters extends List {
   }
 };
 
-// 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 {
 };
@@ -7782,6 +9273,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);
     }
@@ -7797,7 +9290,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);
@@ -7849,9 +9342,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);
@@ -7864,6 +9355,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}`);
@@ -7875,6 +9373,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) {
@@ -7918,8 +9423,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);