@treeviz/gedcom-parser 1.0.22 → 2.0.0

package/dist/constants/index.d.ts

@@ -1,4 +1,4 @@
-import { x as Filter, y as RequiredFilter, W as RelationType, X as PartnerType, A as Order, K as NameOrder, B as OrderIterator, a1 as IndiType, n as IndiKey } from '../index-BPEVN_DY.js';
+import { aT as RequiredFilter, aO as RelationType, n as Filter, aA as PartnerType, ax as Order, az as OrderIterator, af as IndiType, ac as IndiKey, ap as NameOrder } from '../index-CzYZg44D.js';
 import 'date-fns';
 
 /**

package/dist/constants/index.js

@@ -97,66 +97,125 @@ __export(translators_exports, {
   fr: () => KinshipTranslatorFr,
   hu: () => KinshipTranslatorHU
 });
+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)
-});
-var relativesCache = (cacheKey) => (key, subKey, value) => {
-  if (!caches[cacheKey]) {
+  }, 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 && 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/utils/get-all-prop.ts
@@ -707,11 +766,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);
@@ -722,11 +800,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";
@@ -739,13 +840,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) => {
@@ -2522,7 +2756,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) {
@@ -2596,11 +2830,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) {
@@ -2718,6 +2953,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);
@@ -2725,11 +3042,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) {
+  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);
@@ -2737,24 +3073,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
       };
+      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) {
@@ -3122,7 +3475,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;
     }
@@ -3167,7 +3520,7 @@ var Indi = class extends Common {
         if (breakOnNext) {
           return void 0;
         }
-        pathCache(cacheKey, path2);
+        pathCache(this._gedcom, cacheKey, path2);
         return path2;
       }
       visited.append(indi);
@@ -3337,7 +3690,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;
     }
@@ -3345,6 +3698,7 @@ var Indi = class extends Common {
     const excludes = persons;
     if (!Math.abs(degree)) {
       return relativesOnDegreeCache(
+        this._gedcom,
         this.id,
         degree,
         persons.except(this)
@@ -3355,11 +3709,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;
     }
@@ -3370,7 +3724,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);
@@ -3381,7 +3735,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) {
@@ -3390,7 +3749,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) {
@@ -3429,7 +3793,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 };
@@ -3462,7 +3831,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 };

package/dist/factories/index.d.ts

@@ -1,6 +1,6 @@
-import { I as ICacheManager, P as PlaceParts } from '../place-parser-CM0TJFj8.js';
+import { I as ICacheManager, P as PlaceParts } from '../place-parser-CJ3EbFmb.js';
 import { Locale } from 'date-fns';
-import { a1 as IndiType, n as IndiKey, L as Language } from '../index-BPEVN_DY.js';
+import { af as IndiType, ac as IndiKey, ai as Language } from '../index-CzYZg44D.js';
 
 /**
  * Factory function type for creating cache manager instances.