@treeviz/gedcom-parser 1.0.23 → 2.0.0

package/dist/utils/index.js

@@ -23,70 +23,143 @@ var getCacheManagerFactory = () => {
 };
 
 // src/utils/cache.ts
+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: {}
+  relativesOnLevelCache: {},
+  profilePictureCache: {}
 };
-var getInstance = getCacheManagerFactory();
-var cacheDbs = {
-  pathCache: getInstance("ftv", "Main", "path", true),
-  relativesOnDegreeCache: getInstance(
-    "ftv",
-    "Main",
-    "path",
-    true
-  ),
-  relativesOnLevelCache: getInstance(
-    "ftv",
-    "Main",
-    "path",
-    true
-  )
+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) {
-      cacheDbs.pathCache.setItem(value);
+      getCacheDbs().pathCache.setItem(value);
     }
   }, 50),
   relativesOnLevelCache: debounce((value) => {
     if (value) {
-      cacheDbs.relativesOnLevelCache.setItem(value);
+      getCacheDbs().relativesOnLevelCache.setItem(value);
     }
   }, 50),
   relativesOnDegreeCache: debounce((value) => {
     if (value) {
-      cacheDbs.relativesOnDegreeCache.setItem(value);
+      getCacheDbs().relativesOnDegreeCache.setItem(value);
     }
-  }, 50)
-});
+  }, 50),
+  // profilePictureCache IS persisted to IndexedDB
+  profilePictureCache: debounce((value) => {
+    if (value) {
+      getCacheDbs().profilePictureCache.setItem(value);
+    }
+  }, 100)
+};
+var cacheInitialized = false;
+var initializeCache = async () => {
+  if (cacheInitialized) {
+    return;
+  }
+  cacheInitialized = true;
+  try {
+    const profilePictureData = await getCacheDbs().profilePictureCache.getItem();
+    if (profilePictureData) {
+      caches.profilePictureCache = profilePictureData;
+    }
+  } catch (_error) {
+  }
+};
 var resetRelativesCache = () => {
   caches.relativesOnDegreeCache = {};
   caches.relativesOnLevelCache = {};
 };
-var relativesCache = (cacheKey) => (key, subKey, value) => {
-  if (!caches[cacheKey]) {
+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 && caches[cacheKey]) {
-    if (!caches[cacheKey][key]) {
-      caches[cacheKey][key] = {};
+  if (value) {
+    const typedCache2 = caches[cacheKey];
+    if (!typedCache2[fullKey]) {
+      typedCache2[fullKey] = {};
     }
-    caches[cacheKey][key][subKey] = value;
-    return caches[cacheKey][key][subKey];
+    typedCache2[fullKey][subKey] = value;
+    return typedCache2[fullKey][subKey];
   }
-  return caches[cacheKey]?.[key]?.[subKey];
+  const typedCache = caches[cacheKey];
+  return typedCache?.[fullKey]?.[subKey];
 };
-var pathCache = (key, value) => {
+var pathCache = (gedcom, key, value) => {
+  const gedcomId = getGedcomId(gedcom);
+  const fullKey = `${gedcomId}:${key}`;
   if (!caches.pathCache) {
     caches.pathCache = {};
   }
   if (value && caches.pathCache) {
-    caches.pathCache[key] = value;
-    return caches.pathCache[key];
+    caches.pathCache[fullKey] = value;
+    return caches.pathCache[fullKey];
   }
-  return caches.pathCache?.[key];
+  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;
 };
 
 // src/constants/constants.ts
@@ -862,11 +935,30 @@ var Common = class _Common {
     const sour = get(head, "SOUR.value");
     return !!sour?.toLowerCase()?.startsWith("myheritage");
   }
+  /**
+   * Get the source type as a string (for prefixing tree IDs and names)
+   * Returns the detected source type or undefined if unknown
+   */
+  getSourceType() {
+    if (this.isAncestry()) return "Ancestry";
+    if (this.isMyHeritage()) return "MyHeritage";
+    if (this.isFamilySearch()) return "FamilySearch";
+    if (this.isGNO2GED()) return "GNO2GED";
+    if (this.isGenoPro()) return "GenoPro";
+    if (this.isAhnenblatt()) return "Ahnenblatt";
+    if (this.isGeni()) return "Geni";
+    return void 0;
+  }
   isFamilySearch() {
     const head = get(this, "HEAD") || get(this.getGedcom(), "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";
+  }
   getAncestryTreeId() {
     const path = "HEAD.SOUR._TREE.RIN.value";
     return get(this, path) || get(this.getGedcom(), path);
@@ -877,11 +969,34 @@ var Common = class _Common {
   }
   getTreeId() {
     if (this?.isAncestry()) {
-      return this.getAncestryTreeId();
+      const id = this.getAncestryTreeId();
+      if (id !== void 0) return id;
     }
     if (this?.isMyHeritage()) {
-      return this.getMyHeritageTreeId();
+      const id = this.getMyHeritageTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isFamilySearch()) {
+      const id = this.getFamilySearchTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isGNO2GED()) {
+      const id = this.getGNO2GEDTreeId();
+      if (id !== void 0) return id;
     }
+    if (this?.isAhnenblatt()) {
+      const id = this.getAhnenblattTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isGeni()) {
+      const id = this.getGeniTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isGenoPro()) {
+      const id = this.getGenoProTreeId();
+      if (id !== void 0) return id;
+    }
+    return this.getUniversalTreeId();
   }
   getAncestryTreeName() {
     const path = "HEAD.SOUR._TREE.value";
@@ -894,13 +1009,146 @@ var Common = class _Common {
       /Exported by MyHeritage.com from (?<tree>.+) in.+$/
     )?.groups?.tree;
   }
+  getFamilySearchTreeId() {
+    const rin = 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");
+    if (treeName) {
+      return treeName;
+    }
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName || "FamilySearch Import";
+  }
+  getAhnenblattTreeId() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return idMatch[1];
+      }
+    }
+    return void 0;
+  }
+  getAhnenblattTreeName() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  }
+  getGeniTreeId() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return idMatch[1];
+      }
+    }
+    return void 0;
+  }
+  getGeniTreeName() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  }
+  getGenoProTreeId() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return idMatch[1];
+      }
+    }
+    return void 0;
+  }
+  getGenoProTreeName() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  }
+  getGNO2GEDTreeId() {
+    const rin = get(this, "HEAD._TREE.RIN.value") || get(this.getGedcom(), "HEAD._TREE.RIN.value");
+    if (rin) {
+      return rin;
+    }
+    return `gno_${this._gedcom?.refcount || "unknown"}`;
+  }
+  getGNO2GEDTreeName() {
+    const treeName = get(this, "HEAD._TREE.value") || get(this.getGedcom(), "HEAD._TREE.value");
+    if (treeName) {
+      return treeName;
+    }
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName || "GNO2GED Export";
+  }
+  /**
+   * Universal tree ID getter for unknown/unrecognized GEDCOM sources
+   * Tries to extract an ID from various common locations
+   */
+  getUniversalTreeId() {
+    const sourceType = this.getSourceType();
+    const prefix = sourceType ? sourceType.toLowerCase() : "tree";
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return `${prefix}_${idMatch[1]}`;
+      }
+    }
+    return `${prefix}_${this._gedcom?.refcount || "unknown"}`;
+  }
+  /**
+   * Universal tree name getter for unknown/unrecognized GEDCOM sources
+   * Tries to extract a name from various common locations
+   */
+  getUniversalTreeName() {
+    const sourceType = this.getSourceType();
+    const prefix = sourceType ? `${sourceType}-` : "";
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      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");
+    if (sourName) {
+      return `${prefix}${sourName}`;
+    }
+    const sourValue = get(this, "HEAD.SOUR.value") || get(this.getGedcom(), "HEAD.SOUR.value");
+    if (sourValue) {
+      return `${prefix}${sourValue}`;
+    }
+    return `${prefix}Unknown Tree`;
+  }
   getTreeName() {
     if (this?.isAncestry()) {
-      return this.getAncestryTreeName();
+      const name = this.getAncestryTreeName();
+      if (name) return name;
     }
     if (this?.isMyHeritage()) {
-      return this.getMyHeritageTreeName();
+      const name = this.getMyHeritageTreeName();
+      if (name) return name;
+    }
+    if (this?.isFamilySearch()) {
+      const name = this.getFamilySearchTreeName();
+      if (name) return name;
+    }
+    if (this?.isGNO2GED()) {
+      const name = this.getGNO2GEDTreeName();
+      if (name) return name;
     }
+    if (this?.isAhnenblatt()) {
+      const name = this.getAhnenblattTreeName();
+      if (name) return name;
+    }
+    if (this?.isGeni()) {
+      const name = this.getGeniTreeName();
+      if (name) return name;
+    }
+    if (this?.isGenoPro()) {
+      const name = this.getGenoProTreeName();
+      if (name) return name;
+    }
+    return this.getUniversalTreeName();
   }
 };
 var createProxy = (target) => {
@@ -2739,7 +2987,7 @@ var Indi = class extends Common {
   }
   async ancestryMedia(namespace) {
     const list = {};
-    const objeList = this.get("OBJE")?.toList();
+    const objeList = this.get("OBJE")?.toList().copy();
     const www = this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
     const tree = this.getAncestryTreeId();
     if (objeList) {
@@ -2813,11 +3061,12 @@ var Indi = class extends Common {
     if (!tree) {
       return;
     }
-    const objeList = this.get("OBJE")?.toList();
-    const birthObj = this.get("BIRT.OBJE")?.toList();
-    const deathObj = this.get("DEAT.OBJE")?.toList();
+    const objeList = this.get("OBJE")?.toList().copy();
+    const birthObj = this.get("BIRT.OBJE")?.toList().copy();
+    const deathObj = this.get("DEAT.OBJE")?.toList().copy();
+    objeList?.merge(birthObj).merge(deathObj);
     (this.get("FAMS")?.toValueList().values() ?? []).concat(this.get("FAMC")?.toValueList().values() ?? []).forEach((fam) => {
-      objeList?.merge(birthObj).merge(deathObj).merge(fam?.get("MARR.OBJE"));
+      objeList.merge(fam?.get("MARR.OBJE"));
     });
     objeList?.forEach((o, index) => {
       if (!o) {
@@ -2935,6 +3184,88 @@ var Indi = class extends Common {
       };
     });
   }
+  geniMedia() {
+    const list = {};
+    const objeList = this.get("OBJE")?.toList().copy();
+    const sourList = this.get("SOUR")?.toList().copy();
+    sourList?.forEach((sour) => {
+      const sourObje = sour?.get("OBJE")?.toList();
+      objeList.merge(sourObje);
+    });
+    if (!objeList || objeList.length === 0) {
+      return void 0;
+    }
+    const rfn = this.get("RFN")?.toValue();
+    const geniId = rfn?.replace(/^geni:/, "") || "unknown";
+    objeList.forEach((obje, index) => {
+      if (!obje) {
+        return;
+      }
+      const key = `@O${index}@`;
+      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";
+      if (url) {
+        const urlMatch = url.match(/\/([^/]+)\?hash=/);
+        const imgId = urlMatch?.[1] || `img-${index}-${Date.now().toString(36)}`;
+        const id = `geni-${geniId}-${imgId}`;
+        list[id] = {
+          isPrimary,
+          key,
+          id,
+          tree: geniId,
+          imgId,
+          person: this.id,
+          title,
+          url,
+          contentType: type,
+          downloadName: `${this.id.replaceAll("@", "")}_${this.toNaturalName()?.replaceAll(" ", "-") || ""}_${(title || key.replaceAll("@", "").toString()).replaceAll(" ", "-")}`
+        };
+      }
+    });
+    return list;
+  }
+  universalMedia() {
+    const list = {};
+    if (!this.id) {
+      return list;
+    }
+    const objeList = this.get("OBJE")?.toList().copy();
+    if (!objeList || objeList.length === 0) {
+      return list;
+    }
+    const rfn = this.get("RFN")?.toValue();
+    const treeId = rfn || "universal";
+    objeList.forEach((obje, index) => {
+      if (!obje) {
+        return;
+      }
+      const key = `@O${index}@`;
+      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";
+      if (url) {
+        const imgId = `media-${index}-${url.split("/").pop()?.split("?")[0]?.substring(0, 20) || Date.now().toString(36)}`;
+        const id = `${treeId}-${this.id}-${imgId}`;
+        list[id] = {
+          isPrimary,
+          key,
+          id,
+          tree: treeId,
+          imgId,
+          person: this.id,
+          title,
+          url,
+          contentType: type,
+          downloadName: `${this.id.replaceAll("@", "")}_${this.toNaturalName()?.replaceAll(" ", "-") || ""}_${(title || key.replaceAll("@", "").toString()).replaceAll(" ", "-")}`
+        };
+      }
+    });
+    return list;
+  }
   async multimedia(namespace) {
     if (this?.isAncestry()) {
       return await this.ancestryMedia(namespace);
@@ -2942,11 +3273,30 @@ var Indi = class extends Common {
     if (this?.isMyHeritage()) {
       return this.myheritageMedia();
     }
-    return void 0;
+    if (this?.isGeni()) {
+      return this.geniMedia();
+    }
+    return this.universalMedia();
   }
   async getProfilePicture(namespace, onlyPrimary = true) {
+    if (!this.id) {
+      return void 0;
+    }
+    const cacheKey = this.id;
+    const cached = profilePictureCache(
+      this._gedcom,
+      cacheKey
+    );
+    if (cached !== void 0) {
+      return cached;
+    }
     const mediaList = await this.multimedia(namespace);
     if (!mediaList) {
+      profilePictureCache(
+        this._gedcom,
+        cacheKey,
+        void 0
+      );
       return void 0;
     }
     const mediaArray = Object.values(mediaList);
@@ -2954,27 +3304,41 @@ var Indi = class extends Common {
       (media) => media.isPrimary && isImageFormat(media.contentType || getFileExtension(media.url))
     );
     if (primaryMedia) {
-      return {
+      const result = {
         file: primaryMedia.url,
         form: primaryMedia.contentType,
         title: primaryMedia.title,
         isPrimary: true
       };
-    }
-    if (!onlyPrimary) {
+      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))
     );
     if (secondaryMedia) {
-      return {
+      const result = {
         file: secondaryMedia.url,
         form: secondaryMedia.contentType,
         title: secondaryMedia.title,
         isPrimary: false
       };
+      profilePictureCache(this._gedcom, cacheKey, result);
+      return result;
     }
+    profilePictureCache(
+      this._gedcom,
+      cacheKey,
+      void 0
+    );
     return void 0;
   }
   link(poolId) {
@@ -3342,7 +3706,7 @@ var Indi = class extends Common {
       return;
     }
     const cacheKey = `${this.id}|${usedIndi.id}`;
-    const cache = pathCache(cacheKey);
+    const cache = pathCache(this._gedcom, cacheKey);
     if (cache) {
       return cache;
     }
@@ -3387,7 +3751,7 @@ var Indi = class extends Common {
         if (breakOnNext) {
           return void 0;
         }
-        pathCache(cacheKey, path2);
+        pathCache(this._gedcom, cacheKey, path2);
         return path2;
       }
       visited.append(indi);
@@ -3557,7 +3921,7 @@ var Indi = class extends Common {
   }
   getRelativesOnDegree(degree = 0) {
     this.id = this.id || `@I${Math.random()}@`;
-    const cache = relativesOnDegreeCache(this.id, degree);
+    const cache = relativesOnDegreeCache(this._gedcom, this.id, degree);
     if (cache) {
       return cache;
     }
@@ -3565,6 +3929,7 @@ var Indi = class extends Common {
     const excludes = persons;
     if (!Math.abs(degree)) {
       return relativesOnDegreeCache(
+        this._gedcom,
         this.id,
         degree,
         persons.except(this)
@@ -3575,11 +3940,11 @@ var Indi = class extends Common {
       excludes.merge(persons);
       persons = this.getRelativesOnLevel(validDegree).getRelativesOnDegree(-validDegree).copy().exclude(excludes);
     }
-    return relativesOnDegreeCache(this.id, degree, persons);
+    return relativesOnDegreeCache(this._gedcom, this.id, degree, persons);
   }
   getRelativesOnLevel(level = 0, filter) {
     this.id = this.id || `@I${Math.random()}@`;
-    const cache = relativesOnLevelCache(this.id, level);
+    const cache = relativesOnLevelCache(this._gedcom, this.id, level);
     if (cache) {
       return cache;
     }
@@ -3590,7 +3955,7 @@ var Indi = class extends Common {
     };
     let families = this.get(config.key)?.toValueList();
     if (!families) {
-      return relativesOnLevelCache(this.id, level, persons);
+      return relativesOnLevelCache(this._gedcom, this.id, level, persons);
     }
     if (filter) {
       families = families.filter(filter);
@@ -3601,7 +3966,12 @@ var Indi = class extends Common {
       persons = this.toFamilies(families).getParents();
     }
     if (level >= -1 && level <= 1) {
-      return relativesOnLevelCache(this.id, level, persons.except(this));
+      return relativesOnLevelCache(
+        this._gedcom,
+        this.id,
+        level,
+        persons.except(this)
+      );
     }
     for (let i = 1; i < Math.abs(level); i++) {
       if (config.isAscendant) {
@@ -3610,7 +3980,12 @@ var Indi = class extends Common {
         persons = persons.getParents();
       }
     }
-    return relativesOnLevelCache(this.id, level, persons.except(this));
+    return relativesOnLevelCache(
+      this._gedcom,
+      this.id,
+      level,
+      persons.except(this)
+    );
   }
   getAscendants(level = 0, filter) {
     if (!level) {
@@ -3649,7 +4024,12 @@ var Indi = class extends Common {
       }
       currentGen++;
       generations[currentGen] = descentants;
-      relativesOnLevelCache(this.id, -currentGen, descentants);
+      relativesOnLevelCache(
+        this._gedcom,
+        this.id,
+        -currentGen,
+        descentants
+      );
       descentants && relatives.merge(descentants);
     }
     return { relatives, generations };
@@ -3682,7 +4062,7 @@ var Indi = class extends Common {
       }
       currentGen++;
       generations[currentGen] = parents;
-      relativesOnLevelCache(this.id, currentGen, parents);
+      relativesOnLevelCache(this._gedcom, this.id, currentGen, parents);
       parents && relatives.merge(parents);
     }
     return { relatives, generations };
@@ -6110,7 +6490,7 @@ var isCommonDate = (value) => {
 // package.json
 var package_default = {
   name: "@treeviz/gedcom-parser",
-  version: "1.0.23"};
+  version: "2.0.0"};
 
 // src/utils/get-product-details.ts
 var isDevelopment = () => {
@@ -6874,7 +7254,7 @@ var GedcomTree = {
     return this.parseHierarchy(content, options);
   },
   parseHierarchy: function(content, options) {
-    const { settings } = options ?? {};
+    const { settings, filename = "" } = options ?? {};
     const { linkedPersons = "skip", linkingKey } = settings ?? {};
     const gedcom = createGedCom();
     gedcom.removeValue();
@@ -6909,6 +7289,25 @@ var GedcomTree = {
       if (lineMatch) {
         const lineIndent = Number(lineMatch?.groups?.indent ?? 0);
         const lineValue = lineMatch?.groups?.value ?? "";
+        const lineType = lineMatch?.groups?.type ?? "";
+        const linesAcc = acc;
+        if (lineIndent === 0 && lineType === "HEAD") {
+          acc.push(line);
+          linesAcc._inHead = true;
+          linesAcc._hasFile = false;
+          return acc;
+        }
+        if (lineIndent === 0 && linesAcc._inHead) {
+          if (filename && !linesAcc._hasFile) {
+            acc.push(`1 FILE ${filename}`);
+          }
+          linesAcc._inHead = false;
+          acc.push(line);
+          return acc;
+        }
+        if (linesAcc._inHead && lineIndent === 1 && lineType === "FILE") {
+          linesAcc._hasFile = true;
+        }
         if (lineIndent > 0 && lineIndent > prevLineIndent && lineValue && isId(lineValue)) {
           const refLines = lineValue.split(/,\s*/).map((id) => line.replace(lineValue, id));
           if (refLines.length > 1) {
@@ -7091,4 +7490,4 @@ if (isDev) {
 }
 var parser_default = GedcomTree;
 
-export { ACCEPTED_DATE_FORMATS, ACCEPTED_DATE_FORMATS_REGEX, parser_default as GedcomTree, PlaceType, commonDateFormatter, create, dateFormatter, extractSeparationYears, extractSplitPoints, findMatchingRangeForSplitRange, fromTuple, generateSplitRanges, getAllProp, getFamilyWith, getFileExtension, getName, getPlaceParts, getPlaces, getRawSize, getVersion, hungarianOrdinalize, implemented, inRange, isDevelopment, isImageFormat, isIntersectedRange, isRangeContained, marriageDateFormatter, nameFormatter, notImplemented, noteDateFormatter, ordinalize, parseRangeBounds, pathCache, placeTranslator, relativesCache, resetRelativesCache, setNestedGroup, splitOverlappingRanges, splitRange };
+export { ACCEPTED_DATE_FORMATS, ACCEPTED_DATE_FORMATS_REGEX, parser_default as GedcomTree, PlaceType, commonDateFormatter, create, dateFormatter, extractSeparationYears, extractSplitPoints, findMatchingRangeForSplitRange, fromTuple, generateSplitRanges, getAllProp, getFamilyWith, getFileExtension, getName, getPlaceParts, getPlaces, getRawSize, getVersion, hungarianOrdinalize, implemented, inRange, initializeCache, isDevelopment, isImageFormat, isIntersectedRange, isRangeContained, marriageDateFormatter, nameFormatter, notImplemented, noteDateFormatter, ordinalize, parseRangeBounds, pathCache, placeTranslator, profilePictureCache, relativesCache, resetRelativesCache, setNestedGroup, splitOverlappingRanges, splitRange };