@treeviz/gedcom-parser 1.0.13 → 1.0.15

package/dist/classes/indi.js

@@ -1,2131 +0,0 @@
-import * as Filters from "../constants/filters.js";
-import { BIRTH_ASC, DATE_ASC, getMarriageAscAndChildBirth, } from "../constants/orders.js";
-import { getKinshipTranslatorClass } from "../factories/kinship-factory.js";
-import { RelationType, PartnerType } from "../types/types.js";
-import { pathCache, relativesCache } from "../utils/cache.js";
-import { dateFormatter } from "../utils/date-formatter.js";
-import { PlaceType, getPlaces } from "../utils/get-places.js";
-import { implemented } from "../utils/logger.js";
-import { Common, createCommon, createProxy } from "./common.js";
-import { Families } from "./fams.js";
-import { Individuals } from "./indis.js";
-import { List } from "./list.js";
-import { CommonName, createCommonName } from "./name.js";
-export var Existed;
-(function (Existed) {
-    Existed["SPOUSE"] = "spouse";
-    Existed["YES"] = "yes";
-})(Existed || (Existed = {}));
-export var CustomTags;
-(function (CustomTags) {
-    CustomTags["UnknownGivenname"] = "Unknown givenname";
-    CustomTags["UnknownSurname"] = "Unknown surname";
-    CustomTags["UnattachedMember"] = "Unattached member";
-    CustomTags["IgnoredMember"] = "Ignored member";
-    CustomTags["UnknownAncestor"] = "Unknown Ancestor";
-})(CustomTags || (CustomTags = {}));
-const ALLOWED_FACTS = [
-    "EVEN",
-    "OCCU",
-    "OCCUPATIONS",
-    "RESI",
-    "BAPT",
-    "CHRI",
-    "CHR",
-    "BURI",
-    "EDUC",
-    "GRAD",
-    "DIV",
-    "IMMI",
-    "RELI",
-    "_MILT",
-    "_MILTID",
-    "FACT",
-    "_ORIG",
-];
-const DISALLOWED_CUSTOM_FACTS = ["DNA Test", "Newspaper"];
-const CustomFactRenderers = {
-    AKA: (label, fact, indi) => {
-        const originalNameObj = indi?.NAME;
-        const note = fact.get("NOTE");
-        const factName = note?.toValue();
-        const name = createCommonName(fact.getGedcom(), undefined, 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);
-    },
-};
-const relativesOnLevelCache = relativesCache("relativesOnLevelCache");
-const relativesOnDegreeCache = relativesCache("relativesOnDegreeCache");
-export class Indi 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 !== undefined && maxLevel < level) ||
-            (minLevel !== undefined && minLevel > level)) {
-            return this;
-        }
-        // Only for debug
-        // if (level > 3) {
-        // 	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
-                ? undefined
-                : fam.getHusband().index(0);
-            let mother = isDescendantLevel ? undefined : fam.getWife().index(0);
-            const children = isMainDescendantLevel && famIndex > 0
-                ? this.getChildren()
-                : undefined;
-            if (father?.id &&
-                (gens.existed[father.id] === Existed.YES ||
-                    (!drawNonBiologicalAncestors &&
-                        this.getParentType(father.id) !==
-                            RelationType.BIOLOGICAL))) {
-                // console.info(
-                // 	"Father already in tree",
-                // 	father.toName(),
-                // 	father,
-                // 	gens.existed[father.id]
-                // );
-                father = undefined;
-            }
-            if (mother?.id &&
-                (gens.existed[mother.id] === Existed.YES ||
-                    (!drawNonBiologicalAncestors &&
-                        this.getParentType(mother.id) !==
-                            RelationType.BIOLOGICAL))) {
-                // console.info(
-                // 	"Mother already in tree",
-                // 	mother.toName(),
-                // 	mother,
-                // 	gens.existed[mother.id]
-                // );
-                mother = undefined;
-            }
-            if (!id &&
-                !father &&
-                !mother &&
-                (!children?.length || famIndex > 0)) {
-                return this;
-            }
-            let fatherSpouses;
-            if (father && ancestorSpouses) {
-                fatherSpouses = father
-                    .getCoParents()
-                    .orderBy(getMarriageAscAndChildBirth(father.id));
-                if (drawNonBiologicalAncestors) {
-                    fatherSpouses = fatherSpouses
-                        .copy()
-                        .exclude(familiesAllMember);
-                }
-                if (mother) {
-                    fatherSpouses = fatherSpouses.except(mother);
-                }
-            }
-            let motherSpouses;
-            if (mother && ancestorSpouses) {
-                motherSpouses = mother
-                    .getCoParents()
-                    .orderBy(getMarriageAscAndChildBirth(mother.id));
-                if (drawNonBiologicalAncestors) {
-                    motherSpouses = motherSpouses
-                        .copy()
-                        .exclude(familiesAllMember);
-                }
-                if (father) {
-                    motherSpouses = motherSpouses.except(father);
-                }
-            }
-            let childIndex = 0;
-            const amount = Math.pow(2, level - 1);
-            const half = Math.floor(amount / 2);
-            const closers = {
-                id: id || this.id,
-                index,
-                father: isDescendantLevel
-                    ? this.isMale()
-                        ? this
-                        : undefined
-                    : onlyDescendants
-                        ? undefined
-                        : father?.generateTree({
-                            generations: gens,
-                            level: level + 1,
-                            famIndex: famIndex * 2,
-                            index: index * 2,
-                            ancestorSpouses,
-                            ancestorSiblings,
-                            maxLevel,
-                            minLevel,
-                            drawNonBiologicalAncestors,
-                        }),
-                fatherSpouses: fatherSpouses &&
-                    (fatherSpouses.values() ?? []),
-                mother: isDescendantLevel
-                    ? this.isFemale()
-                        ? this
-                        : undefined
-                    : onlyDescendants
-                        ? undefined
-                        : mother?.generateTree({
-                            generations: gens,
-                            level: level + 1,
-                            famIndex: famIndex * 2,
-                            index: index * 2 + (famIndex > 0 ? 0 : 1),
-                            ancestorSpouses,
-                            ancestorSiblings,
-                            maxLevel,
-                            minLevel,
-                            drawNonBiologicalAncestors,
-                        }),
-                motherSpouses: motherSpouses &&
-                    (motherSpouses.values() ?? []),
-                children: children
-                    ?.map((descendant) => {
-                    const descendantTree = descendant.generateTree({
-                        generations: gens,
-                        level: level === 1 ? -1 : level - 1,
-                        famIndex: 0,
-                        index: childIndex++,
-                        showDescendants: true,
-                        offspringSpouses,
-                        maxLevel,
-                        minLevel,
-                    });
-                    if (offspringSpouses) {
-                        const spousesTrees = descendant
-                            .getCoParents()
-                            .orderBy(getMarriageAscAndChildBirth(descendant.id))
-                            .map((spouse) => {
-                            return spouse.generateTree({
-                                generations: gens,
-                                level: level === 1 ? -1 : level - 1,
-                                famIndex: 0,
-                                index: childIndex++,
-                                showDescendants: true,
-                                offspringSpouses,
-                                maxLevel,
-                                minLevel,
-                            });
-                        });
-                        return [descendantTree, ...spousesTrees];
-                    }
-                    return [descendantTree];
-                })
-                    .flat(),
-            };
-            if (!gens.tree[level]) {
-                gens.tree[level] = [];
-            }
-            if (level < 0) {
-                gens.tree[level].push(closers);
-            }
-            else {
-                if (index >= half && gens.halves[level] === undefined) {
-                    gens.halves[level] = gens.tree[level].length;
-                }
-                gens.tree[level].push(closers);
-                gens.lastItems[level] = closers;
-            }
-            if (father?.id) {
-                gens.existed[father.id] = Existed.YES;
-            }
-            if (mother?.id) {
-                gens.existed[mother.id] = Existed.YES;
-            }
-            closers.children?.forEach(({ id }) => {
-                if (id) {
-                    gens.existed[id] = Existed.YES;
-                }
-            });
-            [
-                ...(closers.fatherSpouses ?? []),
-                ...(closers.motherSpouses ?? []),
-            ]?.forEach(({ id }) => {
-                if (id) {
-                    gens.existed[id] = Existed.SPOUSE;
-                }
-            });
-        });
-        return this;
-    }
-    getPlaces(type = [PlaceType.All], maxLevel = 1) {
-        if (!this._gedcom || !this.id) {
-            return [];
-        }
-        const cacheKey = JSON.stringify(type);
-        if (this._places?.[cacheKey]) {
-            return this._places[cacheKey];
-        }
-        let marriages;
-        if (type?.includes(PlaceType.Marriage) ||
-            type?.includes(PlaceType.All)) {
-            const families = this.getFamilies("FAMS");
-            // if (families.length === 1) {
-            // 	marriages = families.index(0);
-            // } else
-            if (families.length >= 1) {
-                marriages = new List();
-                families.forEach((fam) => {
-                    if (fam.MARR) {
-                        const newMarr = createCommon(this._gedcom, undefined, this);
-                        Object.assign(newMarr, fam.MARR);
-                        newMarr.id = fam.id;
-                        marriages.append(newMarr);
-                    }
-                });
-            }
-        }
-        let usedIndi;
-        // let usedMaxLevel = maxLevel;
-        if (marriages) {
-            usedIndi = createIndi(this._gedcom, this.id);
-            Object.assign(usedIndi, this, {
-                MARR: marriages,
-            });
-            // usedMaxLevel = usedMaxLevel === 1 ? 2 : usedMaxLevel;
-        }
-        const places = getPlaces(usedIndi || this, type, maxLevel);
-        return places;
-    }
-    getTree(props) {
-        const { descendants, offspringSpouses, ancestorSpouses, onlyDescendants, maxGen, minGen, drawNonBiologicalAncestors, ancestorSiblings, } = props ?? {};
-        const newGenerations = {
-            existed: {},
-            tree: {},
-            halves: {},
-            lastItems: {},
-        };
-        this.generateTree({
-            generations: newGenerations,
-            level: 1,
-            famIndex: 0,
-            index: 0,
-            showDescendants: descendants,
-            offspringSpouses,
-            ancestorSpouses,
-            onlyDescendants,
-            maxLevel: maxGen,
-            minLevel: minGen,
-            drawNonBiologicalAncestors,
-            ancestorSiblings,
-        });
-        return Object.keys(newGenerations.tree)
-            .toSorted((a, b) => Number(a) - Number(b))
-            .map((key) => {
-            const gen = Number(key);
-            return {
-                gen,
-                indis: newGenerations.tree[gen],
-                half: newGenerations.halves[gen],
-            };
-        });
-    }
-    getGenealogy(onlyStraight = false, showDescendants = false) {
-        const id = this.get("FAMC")?.toList().index(0)?.toValue();
-        if (!id) {
-            return;
-        }
-        const own = this.isMale()
-            ? {
-                father: this,
-                mother: !onlyStraight
-                    ? this.getCoParents().index(0)
-                    : undefined,
-            }
-            : {
-                mother: this,
-                father: !onlyStraight
-                    ? this.getCoParents().index(0)
-                    : undefined,
-            };
-        const newGenerations = {
-            existed: {
-                [this.id]: Existed.YES,
-            },
-            tree: {
-                0: [
-                    {
-                        id,
-                        index: 0,
-                        ...own,
-                    },
-                ],
-            },
-            halves: { 0: 0 },
-            lastItems: {},
-        };
-        this.generateTree({
-            generations: newGenerations,
-            level: 1,
-            famIndex: 0,
-            index: 0,
-            showDescendants,
-        });
-        const gens = Object.keys(newGenerations.tree).toSorted((a, b) => Number(b) - Number(a));
-        const genealogyGenerations = {};
-        const genealogyResult = {};
-        gens.forEach((genIndex) => {
-            const gen = Number(genIndex);
-            const generation = newGenerations.tree[gen].flat();
-            if (!genealogyGenerations[gen]) {
-                genealogyGenerations[gen] = {
-                    left: [],
-                    main: { left: [], right: [] },
-                    right: [],
-                };
-            }
-            else {
-                if (!genealogyGenerations[gen].left) {
-                    genealogyGenerations[gen].left = [];
-                }
-                if (!genealogyGenerations[gen].main) {
-                    genealogyGenerations[gen].main = { left: [], right: [] };
-                }
-                if (!genealogyGenerations[gen].right) {
-                    genealogyGenerations[gen].right = [];
-                }
-            }
-            generation.forEach((pack, index) => {
-                const members = { left: [], right: [] };
-                ["father", "mother"].forEach((type, mIndex) => {
-                    const key = type;
-                    const typedPack = pack?.[key];
-                    const validIndex = index * 2 + mIndex;
-                    const side = validIndex >= generation.length ? "right" : "left";
-                    if (typedPack) {
-                        members[side].push(typedPack);
-                    }
-                });
-                if (!onlyStraight) {
-                    ["father", "mother"].forEach((type, mIndex) => {
-                        const key = type;
-                        const typedPack = pack?.[key];
-                        const validIndex = index * 2 + mIndex;
-                        const side = validIndex >= generation.length ? "right" : "left";
-                        const spouse = key === "father" ? pack?.mother : pack?.father;
-                        const spouses = (typedPack?.getCoParents().values() ?? []).filter((item) => {
-                            if (item?.id === spouse?.id) {
-                                return false;
-                            }
-                            if (item.id && !newGenerations.existed[item.id]) {
-                                newGenerations.existed[item.id] = Existed.YES;
-                                return true;
-                            }
-                            return false;
-                        });
-                        const rawSiblings = typedPack
-                            ?.getSiblings()
-                            .orderBy(BIRTH_ASC)
-                            .values() ?? [];
-                        const siblings = rawSiblings.reduce((acc, item, index) => {
-                            if (item.id && !newGenerations.existed[item.id]) {
-                                newGenerations.existed[item.id] = Existed.YES;
-                                const siblingSpouses = (item?.getCoParents().values() ?? []).filter((siblingSpouse) => {
-                                    if (siblingSpouse.id &&
-                                        !newGenerations.existed[siblingSpouse.id]) {
-                                        newGenerations.existed[siblingSpouse.id] = Existed.YES;
-                                        return true;
-                                    }
-                                    return false;
-                                });
-                                if (siblingSpouses.length) {
-                                    const newValue = item?.isMale()
-                                        ? [item, ...siblingSpouses]
-                                        : [...siblingSpouses, item];
-                                    return [
-                                        ...acc,
-                                        ...(index > 0 &&
-                                            newValue.length > 1 &&
-                                            acc[acc.length - 1] !== undefined
-                                            ? [undefined]
-                                            : []),
-                                        ...newValue,
-                                        ...(index < rawSiblings.length - 1 &&
-                                            newValue.length > 1
-                                            ? [undefined]
-                                            : []),
-                                    ];
-                                }
-                                return [...acc, item];
-                            }
-                            return acc;
-                        }, []);
-                        const spouseMethod = key === "father" ? "unshift" : "push";
-                        const siblingMethod = side === "left" ? "unshift" : "push";
-                        members[side][spouseMethod](...spouses);
-                        if (siblings.length) {
-                            if ((key === "father" && pack?.mother) ||
-                                (key === "mother" && pack?.father)) {
-                                members[side][siblingMethod](undefined);
-                            }
-                            members[side][siblingMethod](...siblings);
-                        }
-                    });
-                }
-                genealogyGenerations[gen].main.left.push(members.left.length ? members.left : undefined);
-                genealogyGenerations[gen].main.right.push(members.right.length ? members.right : undefined);
-            });
-        });
-        gens.forEach((genIndex) => {
-            const gen = Number(genIndex);
-            const prevGen = gen - 1;
-            if (!genealogyGenerations[prevGen]) {
-                genealogyGenerations[prevGen] = {
-                    left: [],
-                    main: { left: [], right: [] },
-                    right: [],
-                };
-            }
-            ["left", "right"].forEach((s) => {
-                const side = s;
-                if (!onlyStraight) {
-                    genealogyGenerations[gen].main[side].forEach((pack) => {
-                        if (!pack) {
-                            return;
-                        }
-                        const toRight = side === "right";
-                        const orderedPack = pack;
-                        orderedPack.forEach((indi) => {
-                            if (!indi) {
-                                return;
-                            }
-                            const rawChildren = indi
-                                ?.getChildren()
-                                .orderBy(BIRTH_ASC)
-                                .values() ?? [];
-                            const children = rawChildren.reduce((acc, item, index) => {
-                                if (item.id &&
-                                    !newGenerations.existed[item.id]) {
-                                    newGenerations.existed[item.id] =
-                                        Existed.YES;
-                                    const childSpouses = (item?.getCoParents().values() ?? []).filter((childSpouse) => {
-                                        if (childSpouse.id &&
-                                            !newGenerations.existed[childSpouse.id]) {
-                                            newGenerations.existed[childSpouse.id] = Existed.YES;
-                                            return true;
-                                        }
-                                        return false;
-                                    });
-                                    if (childSpouses.length) {
-                                        const newValue = item?.isMale()
-                                            ? [item, ...childSpouses]
-                                            : [...childSpouses, item];
-                                        return [
-                                            ...acc,
-                                            ...(index > 0 &&
-                                                newValue.length > 1 &&
-                                                acc[acc.length - 1] !== undefined
-                                                ? [undefined]
-                                                : []),
-                                            ...newValue,
-                                            ...(index <
-                                                rawChildren.length - 1 &&
-                                                newValue.length > 1
-                                                ? [undefined]
-                                                : []),
-                                        ];
-                                    }
-                                    return [...acc, item];
-                                }
-                                return acc;
-                            }, []);
-                            const childMethod = "push";
-                            const members = [];
-                            if (children.length) {
-                                members[childMethod](children);
-                            }
-                            if (toRight) {
-                                genealogyGenerations[prevGen].right.push(...members);
-                            }
-                            else {
-                                genealogyGenerations[prevGen].left.push(...members);
-                            }
-                        });
-                    });
-                }
-                if (genealogyGenerations[prevGen]) {
-                    genealogyGenerations[prevGen] = {
-                        left: [],
-                        main: {
-                            left: [
-                                ...(genealogyGenerations[prevGen]?.left ?? []),
-                                ...(genealogyGenerations[prevGen]?.main.left ??
-                                    []),
-                            ],
-                            right: [
-                                ...(genealogyGenerations[prevGen]?.main.right ??
-                                    []),
-                                ...(genealogyGenerations[prevGen]?.right ?? []),
-                            ],
-                        },
-                        right: [],
-                    };
-                }
-                genealogyResult[gen] = {
-                    left: [
-                        ...(genealogyGenerations[gen]?.left ?? []),
-                        ...(genealogyGenerations[gen]?.main.left ?? []),
-                    ],
-                    right: [
-                        ...(genealogyGenerations[gen]?.main.right ?? []),
-                        ...(genealogyGenerations[gen]?.right ?? []),
-                    ],
-                };
-            });
-        });
-        const result = [];
-        gens.forEach((genIndex) => {
-            result.unshift({
-                gen: Number(genIndex),
-                ...genealogyResult[Number(genIndex)],
-            });
-        });
-        return result;
-    }
-    ancestryLink() {
-        const www = 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(/@|I/g, "")}/facts`;
-        }
-    }
-    async ancestryMedia(namespace) {
-        const list = {};
-        const objIds = this.get("OBJE")?.toValueList().keys() ?? [];
-        const www = this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
-        const tree = this.getAncestryTreeId();
-        await Promise.all(objIds.map(async (objId) => {
-            const key = objId;
-            const obje = this._gedcom
-                ?.obje(key)
-                ?.standardizeMedia(namespace, true, (ns, iId) => {
-                return ns && iId
-                    ? `https://mediasvc.ancestry.com/v2/image/namespaces/${ns}/media/${iId}?client=trees-mediaservice&imageQuality=hq`
-                    : undefined;
-            });
-            const media = obje?.RIN?.value;
-            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) {
-                return;
-            }
-            if (!namespace && !url) {
-                try {
-                    const mediaDetailsResponse = await fetch(`https://www.ancestry.com/api/media/viewer/v2/trees/${tree}/media?id=${media}`);
-                    const mediaDetails = (await mediaDetailsResponse.json());
-                    if (mediaDetails.url) {
-                        url = `${mediaDetails.url}&imageQuality=hq`;
-                    }
-                }
-                catch (_e) {
-                    //
-                }
-                url =
-                    url ||
-                        `https://${www}/mediaui-viewer/tree/${tree}/media/${media}`;
-            }
-            if (url && imgId) {
-                const id = `${tree}-${this.id}-${imgId}`;
-                list[id] = {
-                    key,
-                    id,
-                    tree,
-                    imgId,
-                    person: this.id,
-                    title: title,
-                    url,
-                    contentType: type,
-                    downloadName: `${this.id.replaceAll("@", "")}_${this.toNaturalName().replaceAll(" ", "-") || ""}_${(title ||
-                        key.replaceAll("@", "").toString()).replaceAll(" ", "-")}`,
-                };
-            }
-        }));
-        return list;
-    }
-    myheritageLink(poolId = 0) {
-        const www = 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, "-");
-        if (normalizedFile && this.id) {
-            const id = Number(this.id.replace(/@|I/g, "")) + poolId;
-            return `https://www.${www}/site-family-tree-${site}/${normalizedFile}#!profile-${id}-info`;
-        }
-    }
-    myheritageMedia() {
-        const list = {};
-        const tree = this.getMyHeritageTreeId();
-        if (!tree) {
-            return;
-        }
-        const birthObj = this.get("BIRT.OBJE")?.toList().values();
-        const deathObj = this.get("DEAT.OBJE")?.toValueList().values();
-        const familiesObj = (this.get("FAMS")?.toValueList().values() ?? [])
-            .concat(this.get("FAMC")?.toValueList().values() ?? [])
-            .map((fam) => {
-            return fam?.get("MARR.OBJE");
-        });
-        (birthObj ?? [])
-            .concat(deathObj ?? [])
-            .concat(familiesObj ?? [])
-            .forEach((o, index) => {
-            if (!o) {
-                return;
-            }
-            const obje = o;
-            const key = `@O${index}@`;
-            obje.standardizeMedia();
-            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();
-            if (url && imgId) {
-                const id = `${tree}-${this.id}-${imgId}`;
-                list[id] = {
-                    key,
-                    id,
-                    tree,
-                    imgId,
-                    person: this.id,
-                    title: title,
-                    url,
-                    contentType: type,
-                    downloadName: `${this.id.replaceAll("@", "")}_${this.toNaturalName().replaceAll(" ", "-") || ""}_${(title ||
-                        key.replaceAll("@", "").toString()).replaceAll(" ", "-")}`,
-                };
-            }
-        });
-        return list;
-    }
-    familySearchLink() {
-        // Get the _FS_LINK custom tag value and return it as-is
-        return this.get("_FS_LINK")?.toValue();
-    }
-    hasFamilySearchMatches() {
-        // Check if this individual has any _FS_MATCH tags
-        return this.get("_FS_MATCH") !== undefined;
-    }
-    getFamilySearchMatches() {
-        // Get all _FS_MATCH tags for this individual
-        const matchTags = this.get("_FS_MATCH")?.toList();
-        if (!matchTags?.length) {
-            return [];
-        }
-        return matchTags.map((matchTag) => {
-            const id = matchTag.toValue();
-            // Extract all sub-tags using get() method
-            const title = matchTag.get("TITL")?.toValue();
-            const type = matchTag.get("TYPE")?.toValue();
-            const ref = matchTag.get("REF")?.toValue();
-            const scoreStr = matchTag.get("SCORE")?.toValue();
-            const text = matchTag.get("TEXT")?.toValue();
-            const www = matchTag.get("WWW")?.toValue();
-            // Extract NOTE tags (there can be multiple)
-            const noteTags = matchTag.get("NOTE")?.toList() || [];
-            const notes = noteTags
-                .map((note) => note.toValue())
-                .filter(Boolean);
-            return {
-                id,
-                title,
-                type,
-                ref,
-                score: scoreStr ? parseFloat(scoreStr) : undefined,
-                text,
-                www,
-                notes,
-            };
-        });
-    }
-    hasFamilySearchSources() {
-        // Check if this individual has any _FS_SOUR tags
-        return this.get("_FS_SOUR") !== undefined;
-    }
-    getFamilySearchSources() {
-        // Get all _FS_SOUR tags for this individual
-        const sourceTags = this.get("_FS_SOUR")?.toList();
-        if (!sourceTags?.length) {
-            return [];
-        }
-        return sourceTags.map((sourceTag) => {
-            const id = sourceTag.toValue();
-            // Extract all sub-tags using get() method
-            const title = sourceTag.get("TITL")?.toValue();
-            const text = sourceTag.get("TEXT")?.toValue();
-            const www = sourceTag.get("WWW")?.toValue();
-            // Extract NOTE tags (there can be multiple)
-            const noteTags = sourceTag.get("NOTE")?.toList() || [];
-            const notes = noteTags
-                .map((note) => note.toValue())
-                .filter(Boolean);
-            return {
-                id,
-                title,
-                text,
-                www,
-                notes,
-            };
-        });
-    }
-    async multimedia(namespace) {
-        if (this?.isAncestry()) {
-            return await this.ancestryMedia(namespace);
-        }
-        if (this?.isMyHeritage()) {
-            return this.myheritageMedia();
-        }
-        return undefined;
-    }
-    link(poolId) {
-        if (this?.isAncestry()) {
-            return this.ancestryLink();
-        }
-        if (this?.isMyHeritage()) {
-            return this.myheritageLink(poolId);
-        }
-        if (this?.isFamilySearch()) {
-            return this.familySearchLink();
-        }
-        return undefined;
-    }
-    toFamilies(list) {
-        const families = new Families();
-        list?.forEach((fam, famId) => {
-            const family = fam?.ref;
-            if (family) {
-                families.item(famId, family);
-            }
-        });
-        return families;
-    }
-    getFamilies(type) {
-        return this.toFamilies(this.get(type)?.toValueList());
-    }
-    getFamiliesBiologicalFirst(type) {
-        const families = this.toFamilies(this.get(type)?.toValueList());
-        return families.orderBy((famB, _famBKey, famA) => {
-            const husbA = famA.getHusband().index(0);
-            const wifeA = famA.getWife().index(0);
-            const husbAType = husbA && this.getParentType(husbA);
-            const wifeAType = wifeA && this.getParentType(wifeA);
-            const husbB = famB.getHusband().index(0);
-            const wifeB = famB.getWife().index(0);
-            const husbBType = husbB && this.getParentType(husbB);
-            const wifeBType = wifeB && this.getParentType(wifeB);
-            if (husbAType === RelationType.BIOLOGICAL &&
-                wifeAType === RelationType.BIOLOGICAL) {
-                if (husbBType === RelationType.BIOLOGICAL &&
-                    wifeBType === RelationType.BIOLOGICAL) {
-                    return 0;
-                }
-                return 1;
-            }
-            else if (husbAType === RelationType.BIOLOGICAL) {
-                if (husbBType === RelationType.BIOLOGICAL &&
-                    wifeBType === RelationType.BIOLOGICAL) {
-                    return -1;
-                }
-                else if (husbBType === RelationType.BIOLOGICAL) {
-                    return 0;
-                }
-                return 1;
-            }
-            else if (wifeAType === RelationType.BIOLOGICAL) {
-                if (husbBType === RelationType.BIOLOGICAL &&
-                    wifeBType === RelationType.BIOLOGICAL) {
-                    return -1;
-                }
-                else if (husbBType === RelationType.BIOLOGICAL) {
-                    return -1;
-                }
-                return 0;
-            }
-            if (husbBType === RelationType.BIOLOGICAL ||
-                wifeBType === RelationType.BIOLOGICAL) {
-                return -1;
-            }
-            return 0;
-        });
-    }
-    getBirthDate(showDays = false, shortNote = true, showNote = true) {
-        const dates = dateFormatter(this, false, showDays, false, shortNote, showNote);
-        return dates.birth || undefined;
-    }
-    getDeathDate(showDays = false, shortNote = true, showNote = true) {
-        const dates = dateFormatter(this, false, showDays, false, shortNote, showNote);
-        return dates.death || undefined;
-    }
-    getBirthPlace() {
-        const birthEvent = this.get("BIRT")?.toList().index(0);
-        return birthEvent?.PLAC?.value;
-    }
-    getDeathPlace() {
-        const deathEvent = this.get("DEAT")?.toList().index(0);
-        return deathEvent?.PLAC?.value;
-    }
-    isDead() {
-        return (this.get("DEAT.DATE")?.toValue() !== undefined ||
-            this.get("DEAT.PLAC")?.toValue() !== undefined);
-    }
-    isEmpty() {
-        if (this._isEmpty !== undefined) {
-            return this._isEmpty;
-        }
-        const keysLength = Object.keys(this).filter((key) => {
-            return (!key.startsWith("_") &&
-                !["gedcom", "isListable", "refType"].includes(key));
-        }).length;
-        this._isEmpty = !keysLength;
-        return this._isEmpty;
-    }
-    isUnknownAncestor() {
-        if (this._isUnknownAncestor !== undefined) {
-            return this._isUnknownAncestor;
-        }
-        this._isUnknownAncestor = !!this.get("_MTTAG")
-            ?.toList()
-            ?.values()
-            .find((tag) => tag?.get("NAME")?.toValue() === CustomTags.UnknownAncestor);
-        return this._isUnknownAncestor;
-    }
-    isIgnoredMember() {
-        if (this._isIgnoredPerson !== undefined) {
-            return this._isIgnoredPerson;
-        }
-        this._isIgnoredPerson = !!this.get("_MTTAG")
-            ?.toList()
-            ?.values()
-            .find((tag) => tag?.get("NAME")?.toValue() === CustomTags.IgnoredMember);
-        return this._isIgnoredPerson;
-    }
-    isUnattachedMember() {
-        if (this._isUnattachedMember !== undefined) {
-            return this._isUnattachedMember;
-        }
-        this._isUnattachedMember = !!this.get("_MTTAG")
-            ?.toList()
-            ?.values()
-            .find((tag) => tag?.get("NAME")?.toValue() === CustomTags.UnattachedMember);
-        return this._isUnattachedMember;
-    }
-    isOrphanFamilyMember() {
-        if (this._isOrphanFamilyMember !== undefined) {
-            return this._isOrphanFamilyMember;
-        }
-        // Check if any of the person's families (FAMC or FAMS) has the _IS_ORPHAN_FAMILY tag
-        const famcFamilies = this.getFamilies("FAMC");
-        const famsFamilies = this.getFamilies("FAMS");
-        this._isOrphanFamilyMember = false;
-        // Check FAMC families
-        famcFamilies.forEach((fam) => {
-            if (fam._IS_ORPHAN_FAMILY?.value === "Y") {
-                this._isOrphanFamilyMember = true;
-            }
-        });
-        // Check FAMS families if not already found
-        if (!this._isOrphanFamilyMember) {
-            famsFamilies.forEach((fam) => {
-                if (fam._IS_ORPHAN_FAMILY?.value === "Y") {
-                    this._isOrphanFamilyMember = true;
-                }
-            });
-        }
-        return this._isOrphanFamilyMember;
-    }
-    isUnknownGivenname() {
-        if (this._isUnknownGivenname !== undefined) {
-            return this._isUnknownGivenname;
-        }
-        this._isUnknownGivenname = !!this.get("_MTTAG")
-            ?.toList()
-            ?.values()
-            .find((tag) => tag?.get("NAME")?.toValue() === CustomTags.UnknownGivenname);
-        return this._isUnknownGivenname;
-    }
-    isUnknownSurname() {
-        if (this._isUnknownSurname !== undefined) {
-            return this._isUnknownSurname;
-        }
-        this._isUnknownSurname = !!this.get("_MTTAG")
-            ?.toList()
-            ?.values()
-            .find((tag) => tag?.get("NAME")?.toValue() === CustomTags.UnknownSurname);
-        return this._isUnknownSurname;
-    }
-    isNonRelevantMember() {
-        return this.isUnknownAncestor() || this.isUnattachedMember();
-    }
-    isMale() {
-        return this.get("SEX")?.toValue() === "M";
-    }
-    isFemale() {
-        return this.get("SEX")?.toValue() === "F";
-    }
-    isUnknownSex() {
-        return !this.isMale() && !this.isFemale();
-    }
-    getParentType(id) {
-        let indi;
-        if (typeof id === "string" || typeof id === "number") {
-            indi = this._gedcom?.indi(id);
-        }
-        else {
-            indi = id;
-        }
-        if (!indi?.id || !this.id) {
-            return;
-        }
-        const parents = this.getParents();
-        let parent = parents.item(indi.id) ? indi : undefined;
-        let child = this._gedcom?.indi(this.id);
-        if (!parent?.id) {
-            const children = this.getChildren();
-            if (children.item(indi.id)) {
-                parent = this._gedcom?.indi(this.id);
-                child = indi;
-            }
-        }
-        const familiesOfChildren = child?.get("FAMC")?.toValueList();
-        if (!parent?.id || !child?.id || !familiesOfChildren) {
-            return;
-        }
-        const families = this.toFamilies(familiesOfChildren);
-        let childType = "";
-        families.forEach((family) => {
-            if (childType) {
-                return;
-            }
-            const fatherId = family.get("HUSB")?.toValue();
-            const motherId = family.get("WIFE")?.toValue();
-            const usedRel = parent?.id === fatherId
-                ? "_FREL"
-                : parent?.id === motherId
-                    ? "_MREL"
-                    : undefined;
-            if (!usedRel || !child?.id) {
-                return;
-            }
-            const famChild = this.id && family.CHIL?.toValueList().item(child.id);
-            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() ||
-                        RelationType.BIOLOGICAL;
-            }
-            else {
-                childType =
-                    famChild.get(usedRel)?.toValue() ||
-                        RelationType.BIOLOGICAL;
-            }
-        });
-        return (childType || RelationType.BIOLOGICAL).toLowerCase();
-    }
-    hasFacts() {
-        const dates = dateFormatter(this, true);
-        if (dates.inArray.length) {
-            return true;
-        }
-        const facts = this.getFacts(1);
-        return !!facts.length;
-    }
-    getLinks() {
-        return this.get("_WLNK")?.toList();
-    }
-    getAkas(limit) {
-        return this.getFacts(limit, "AKA");
-    }
-    getFacts(limit, filter) {
-        const filters = (Array.isArray(filter) ? filter : [filter]).filter(Boolean);
-        const facts = new List();
-        let id = 0;
-        ALLOWED_FACTS.forEach((fact) => {
-            const isCustom = ["EVEN", "FACT"].includes(fact);
-            if (filters.length && !filters.includes(fact) && !isCustom) {
-                return;
-            }
-            const factCommon = this.get(fact);
-            const factCommons = factCommon?.toList();
-            factCommons?.forEach((common, _, index) => {
-                if (limit !== undefined && index >= limit) {
-                    return;
-                }
-                if (!common) {
-                    return;
-                }
-                const newCommon = createCommon(this._gedcom, `${id}`, this);
-                Object.assign(newCommon, common, { id: id });
-                const type = (isCustom ? newCommon.get("TYPE")?.toValue() : fact);
-                if (!type || DISALLOWED_CUSTOM_FACTS.includes(type)) {
-                    return;
-                }
-                if (filters.length && !filters.includes(type) && isCustom) {
-                    return;
-                }
-                const label = createCommon(this._gedcom, undefined, this);
-                const customRenderer = CustomFactRenderers[type];
-                if (customRenderer) {
-                    customRenderer(label, newCommon, this);
-                }
-                else {
-                    label.value = type;
-                    newCommon.set("_LABEL", label);
-                }
-                // common.id = common.id || (`${id}` as IdType);
-                id++;
-                facts.append(newCommon);
-            });
-        });
-        return facts.orderBy(DATE_ASC);
-    }
-    commonAncestor(person, options) {
-        const path = this.path(person, options);
-        let wentUp = false;
-        const wentDown = false;
-        let lastItem;
-        let ancestor;
-        path?.forEach((item) => {
-            if (wentDown) {
-                return;
-            }
-            if (lastItem) {
-                if (item.level > lastItem.level) {
-                    wentUp = true;
-                }
-                if (item.level < lastItem.level) {
-                    wentUp = true;
-                    if (wentUp && !ancestor) {
-                        ancestor = lastItem.indi;
-                    }
-                }
-            }
-            lastItem = item;
-        });
-        return ancestor;
-    }
-    path(person, options) {
-        const { breakAfterSpouse = true, breakAfterNonBiological } = options ?? {};
-        const usedIndi = typeof person === "string" ? this._gedcom?.indi(person) : person;
-        if (!this.id || !usedIndi?.id) {
-            return;
-        }
-        const cacheKey = `${this.id}|${usedIndi.id}`;
-        const cache = pathCache(cacheKey);
-        if (cache) {
-            return cache;
-        }
-        const visited = new Individuals().append(this);
-        const mainItem = {
-            indi: this,
-            level: 0,
-            levelUp: 0,
-            levelDown: 0,
-            degree: 0,
-            kinship: "self",
-        };
-        const path = [mainItem];
-        if (this.id === usedIndi.id) {
-            return path;
-        }
-        const queue = [
-            {
-                ...mainItem,
-                path,
-            },
-        ];
-        // Breadth-first search to find the shortest path
-        let helper = 0;
-        while (queue.length > 0) {
-            if (helper++ > 1000000) {
-                break;
-            }
-            const { indi, path, kinship, relation, level, levelUp, levelDown, degree, breakOnNext, breakAfterNext, inLaw, } = queue.shift();
-            if (usedIndi.id === indi.id) {
-                if (breakOnNext) {
-                    return undefined;
-                }
-                pathCache(cacheKey, path);
-                return path;
-            }
-            visited.append(indi);
-            const additional = {};
-            if (breakOnNext || breakAfterNext) {
-                additional.breakOnNext = breakOnNext || breakAfterNext;
-            }
-            if (inLaw) {
-                additional.inLaw = inLaw;
-            }
-            if (kinship === "spouse" && breakAfterSpouse) {
-                if (path.length <= 2) {
-                    additional.inLaw = true;
-                }
-                else {
-                    additional.breakOnNext = true;
-                }
-            }
-            // Direct relatives: Parents and Children
-            if (kinship !== "child" || !breakAfterSpouse) {
-                indi.getBiologicalFathers()
-                    .copy()
-                    .merge(indi.getBiologicalMothers())
-                    .merge(indi.getFathers().copy().merge(indi.getMothers()))
-                    .forEach((relative) => {
-                    if (!visited.has(relative)) {
-                        const currentRelation = indi.getParentType(relative);
-                        if (breakAfterNonBiological &&
-                            currentRelation !== RelationType.BIOLOGICAL) {
-                            additional.breakAfterNext = true;
-                        }
-                        const newItem = {
-                            indi: relative,
-                            kinship: "parent",
-                            relation: currentRelation &&
-                                currentRelation !== RelationType.BIOLOGICAL
-                                ? currentRelation
-                                : relation,
-                            level: level + 1,
-                            levelUp: levelUp + 1,
-                            levelDown,
-                            degree,
-                            ...additional,
-                        };
-                        queue.push({
-                            ...newItem,
-                            path: [...path, newItem],
-                        });
-                    }
-                });
-            }
-            indi.getChildren().forEach((relative) => {
-                if (!visited.has(relative)) {
-                    const currentRelation = relative.getParentType(indi);
-                    if (breakAfterNonBiological &&
-                        currentRelation !== RelationType.BIOLOGICAL) {
-                        additional.breakAfterNext = true;
-                    }
-                    const newItem = {
-                        indi: relative,
-                        kinship: "child",
-                        relation: currentRelation &&
-                            currentRelation !== RelationType.BIOLOGICAL
-                            ? currentRelation
-                            : relation,
-                        level: level - 1,
-                        levelUp,
-                        levelDown: levelDown + 1,
-                        degree: levelUp
-                            ? level > 0
-                                ? levelUp - level + 1
-                                : levelDown - Math.abs(level)
-                            : 0,
-                        ...additional,
-                    };
-                    queue.push({
-                        ...newItem,
-                        path: [...path, newItem],
-                    });
-                }
-            });
-            // Spouses
-            indi.getCoParents().forEach((relative) => {
-                if (!visited.has(relative)) {
-                    const currentAddition = {};
-                    if (relation && relation !== RelationType.BIOLOGICAL) {
-                        currentAddition.relation = relation;
-                    }
-                    if (inLaw) {
-                        currentAddition.breakOnNext = true;
-                    }
-                    const newItem = {
-                        indi: relative,
-                        kinship: "spouse",
-                        level,
-                        levelUp,
-                        levelDown,
-                        degree,
-                        ...additional,
-                        ...currentAddition,
-                    };
-                    queue.push({
-                        ...newItem,
-                        path: [...path, newItem],
-                    });
-                }
-            });
-        }
-        return undefined;
-    }
-    kinship(other, showMainPerson, lang = "en", entirePath, displayName = "givenname") {
-        const KinshipTranslatorClass = getKinshipTranslatorClass();
-        const translator = new KinshipTranslatorClass(this, other, lang, entirePath, showMainPerson ? displayName : undefined);
-        return translator.translate(!!showMainPerson);
-    }
-    isRelativeOf(type, indi) {
-        const usedIndi = typeof indi === "string" ? this._gedcom?.indi(indi) : indi;
-        let getter;
-        if (type === "fullsibling") {
-            getter = "getFullSiblings";
-        }
-        if (type === "halfsibling") {
-            getter = "getHalfSiblings";
-        }
-        if (type === "sibling") {
-            getter = "getSiblings";
-        }
-        if (type === "parent") {
-            getter = "getParents";
-        }
-        if (type === "child") {
-            getter = "getChildren";
-        }
-        if (type === "spouse") {
-            getter = "getCoParents";
-        }
-        if (type === "siblingInLaw") {
-            getter = "getSiblingsInLaw";
-        }
-        if (type === "parentInLaw") {
-            getter = "getParentsInLaw";
-        }
-        if (type === "childInLaw") {
-            getter = "getChildrenInLaw";
-        }
-        if (!usedIndi || !getter) {
-            return false;
-        }
-        const relatives = usedIndi[getter]();
-        return Boolean(this.id && relatives.item(this.id)
-            ? relatives.index(0)?.id || true
-            : false);
-    }
-    isSiblingOf(indi) {
-        return this.isRelativeOf("sibling", indi);
-    }
-    isFullSiblingOf(indi) {
-        return this.isRelativeOf("fullsibling", indi);
-    }
-    isHalfSiblingOf(indi) {
-        return this.isRelativeOf("halfsibling", indi);
-    }
-    isSpouseOf(indi) {
-        return this.isRelativeOf("spouse", indi);
-    }
-    isParentOf(indi) {
-        return this.isRelativeOf("parent", indi);
-    }
-    isChildOf(indi) {
-        return this.isRelativeOf("child", indi);
-    }
-    isSiblingInLawOf(indi) {
-        return this.isRelativeOf("siblingInLaw", indi);
-    }
-    isParentInLawOf(indi) {
-        return this.isRelativeOf("parentInLaw", indi);
-    }
-    isChildInLawOf(indi) {
-        return this.isRelativeOf("childInLaw", indi);
-    }
-    getRelativesOnDegree(degree = 0) {
-        this.id = this.id || `@I${Math.random()}@`;
-        const cache = relativesOnDegreeCache(this.id, degree);
-        if (cache) {
-            return cache;
-        }
-        let persons = this.getRelativesOnLevel(1)
-            .getRelativesOnDegree(-1)
-            .copy();
-        const excludes = persons;
-        if (!Math.abs(degree)) {
-            return relativesOnDegreeCache(this.id, degree, persons.except(this));
-        }
-        for (let i = 1; i < Math.abs(degree) + 1; i++) {
-            const validDegree = i + 1;
-            excludes.merge(persons);
-            persons = this.getRelativesOnLevel(validDegree)
-                .getRelativesOnDegree(-validDegree)
-                .copy()
-                .exclude(excludes);
-        }
-        return relativesOnDegreeCache(this.id, degree, persons);
-    }
-    getRelativesOnLevel(level = 0, filter) {
-        this.id = this.id || `@I${Math.random()}@`;
-        const cache = relativesOnLevelCache(this.id, level);
-        if (cache) {
-            return cache;
-        }
-        let persons = new Individuals();
-        const config = {
-            isAscendant: level < 0,
-            direction: level < 0 ? -1 : 1,
-            key: level <= 0 ? "FAMS" : "FAMC",
-        };
-        let families = this.get(config.key)?.toValueList();
-        if (!families) {
-            return relativesOnLevelCache(this.id, level, persons);
-        }
-        if (filter) {
-            families = families.filter(filter);
-        }
-        if (config.isAscendant) {
-            persons = this.toFamilies(families).getChildren();
-        }
-        else {
-            persons = this.toFamilies(families).getParents();
-        }
-        if (level >= -1 && level <= 1) {
-            return relativesOnLevelCache(this.id, level, persons.except(this));
-        }
-        for (let i = 1; i < Math.abs(level); i++) {
-            if (config.isAscendant) {
-                persons = persons.getChildren();
-            }
-            else {
-                persons = persons.getParents();
-            }
-        }
-        return relativesOnLevelCache(this.id, level, persons.except(this));
-    }
-    getAscendants(level = 0, filter) {
-        if (!level) {
-            return new Individuals();
-        }
-        return this.getRelativesOnLevel(level, filter);
-    }
-    getDescendants(level = 0, filter) {
-        if (!level) {
-            return new Individuals();
-        }
-        return this.getRelativesOnLevel(-level, filter);
-    }
-    getAllDescendantsRaw(individuals, containDescendantsInLaw = false) {
-        this.id = this.id || `@I${Math.random()}@`;
-        let ownGeneration = new Individuals();
-        if (individuals) {
-            ownGeneration = individuals;
-            ownGeneration.merge(this.getCoParents());
-        }
-        ownGeneration.append(this);
-        const relatives = new Individuals();
-        relatives.merge(ownGeneration);
-        const generations = {
-            0: ownGeneration,
-        };
-        let currentGen = 0;
-        const maxGenCheck = 100;
-        while (currentGen < maxGenCheck) {
-            const descentants = generations[currentGen]?.getChildren().copy();
-            if (!descentants?.length) {
-                break;
-            }
-            if (containDescendantsInLaw) {
-                descentants?.merge(descentants?.getCoParents());
-            }
-            currentGen++;
-            generations[currentGen] = descentants;
-            relativesOnLevelCache(this.id, -currentGen, descentants);
-            descentants && relatives.merge(descentants);
-        }
-        return { relatives, generations };
-    }
-    getAllDescendants(individuals, containDescendantsInLaw = false) {
-        const raw = this.getAllDescendantsRaw(individuals, containDescendantsInLaw);
-        return raw.relatives;
-    }
-    getAllAscendantsRaw(individuals) {
-        this.id = this.id || `@I${Math.random()}@`;
-        let ownGeneration = new Individuals();
-        if (individuals) {
-            ownGeneration = individuals;
-        }
-        ownGeneration.append(this);
-        const relatives = new Individuals();
-        relatives.merge(ownGeneration);
-        const generations = {
-            0: ownGeneration,
-        };
-        let currentGen = 0;
-        const maxGenCheck = 100;
-        while (currentGen < maxGenCheck) {
-            const parents = generations[currentGen]?.getParents().copy();
-            if (!parents?.length) {
-                break;
-            }
-            currentGen++;
-            generations[currentGen] = parents;
-            relativesOnLevelCache(this.id, currentGen, parents);
-            parents && relatives.merge(parents);
-        }
-        return { relatives, generations };
-    }
-    getAllAscendants(individuals) {
-        const raw = this.getAllAscendantsRaw(individuals);
-        return raw.relatives;
-    }
-    getHalfSiblings() {
-        const siblings = this.getSiblings();
-        const ownParents = this.getBiologicalParents();
-        const halfSiblings = new Individuals();
-        siblings.forEach((sibling) => {
-            const siblingsParents = sibling.getBiologicalParents();
-            const inter = ownParents.intersection(siblingsParents);
-            if (inter.length < ownParents.length) {
-                halfSiblings.append(sibling);
-            }
-        });
-        return halfSiblings;
-    }
-    getFullSiblings() {
-        const siblings = this.getSiblings();
-        const ownParents = this.getBiologicalParents();
-        const fullSiblings = new Individuals();
-        siblings.forEach((sibling) => {
-            const siblingsParents = sibling.getBiologicalParents();
-            const inter = ownParents.intersection(siblingsParents);
-            if (inter.length === ownParents.length) {
-                fullSiblings.append(sibling);
-            }
-        });
-        return fullSiblings;
-    }
-    getSiblings() {
-        implemented("getSiblings");
-        return this.getRelativesOnDegree(0);
-    }
-    getBrothers() {
-        implemented("getBrothers");
-        return this.getSiblings().filter(Filters.MALE);
-    }
-    getSisters() {
-        implemented("getSisters");
-        return this.getSiblings().filter(Filters.MALE);
-    }
-    getChildren(filter) {
-        implemented("getChildren");
-        return this.getDescendants(1, filter);
-    }
-    getChildrenFilteredByPedigree(filter) {
-        const children = new Individuals();
-        const familiesOfChildrens = this.get("FAMS")?.toValueList();
-        if (!familiesOfChildrens || !this.id) {
-            return children;
-        }
-        const families = this.toFamilies(familiesOfChildrens);
-        families.forEach((family) => {
-            const fatherId = family.get("HUSB")?.toValue();
-            const motherId = family.get("WIFE")?.toValue();
-            const usedRel = this.id === fatherId
-                ? "_FREL"
-                : this.id === motherId
-                    ? "_MREL"
-                    : undefined;
-            if (!usedRel) {
-                return;
-            }
-            const famChildren = this.id && family.CHIL?.toValueList();
-            famChildren?.forEach((child) => {
-                const childType = child.get(usedRel)?.toValue();
-                if ((!childType && filter.PEDI === RelationType.BIOLOGICAL) ||
-                    childType?.toLowerCase() === filter.PEDI.toLowerCase()) {
-                    const childId = child?.toValue();
-                    const childIndi = childId && this._gedcom?.indi(childId);
-                    if (childIndi) {
-                        children.append(childIndi);
-                    }
-                }
-            });
-            if (!famChildren?.length) {
-                this.getChildren().forEach((child) => {
-                    if (!child) {
-                        return;
-                    }
-                    const childState = child
-                        ?.get("FAMC")
-                        ?.toList()
-                        ?.filter((item) => item.value === family.id)
-                        .index(0);
-                    const childType = childState?.get("PEDI")?.toValue() ||
-                        RelationType.BIOLOGICAL;
-                    if ((!childType &&
-                        filter.PEDI === RelationType.BIOLOGICAL) ||
-                        childType?.toLowerCase() === filter.PEDI.toLowerCase()) {
-                        children.append(child);
-                    }
-                });
-            }
-        });
-        return children;
-    }
-    getBiologicalChildren() {
-        implemented("getBiologicalChildren");
-        return this.getChildrenFilteredByPedigree(Filters.BIOLOGICAL);
-    }
-    getAdoptedChildren() {
-        implemented("getAdoptedChildren");
-        return this.getChildrenFilteredByPedigree(Filters.ADOPTED);
-    }
-    getBirthChildren() {
-        implemented("getBirthChildren");
-        return this.getChildrenFilteredByPedigree(Filters.BIRTH);
-    }
-    getFosterChildren() {
-        implemented("getFosterChildren");
-        return this.getChildrenFilteredByPedigree(Filters.FOSTER);
-    }
-    getSealingChildren() {
-        implemented("getSealingChildren");
-        return this.getChildrenFilteredByPedigree(Filters.SEALING);
-    }
-    getStepChildren() {
-        implemented("getStepChildren");
-        return this.getChildrenFilteredByPedigree(Filters.STEP);
-    }
-    getSons() {
-        implemented("getSons");
-        return this.getChildren().filter(Filters.MALE);
-    }
-    getBiologicalSons() {
-        implemented("getBiologicalSons");
-        return this.getChildrenFilteredByPedigree(Filters.BIOLOGICAL).filter(Filters.MALE);
-    }
-    getAdoptedSons() {
-        implemented("getAdoptedSons");
-        return this.getAdoptedChildren().filter(Filters.MALE);
-    }
-    getBirthSons() {
-        implemented("getBirthSons");
-        return this.getBirthChildren().filter(Filters.MALE);
-    }
-    getFosterSons() {
-        implemented("getFosterSons");
-        return this.getFosterChildren().filter(Filters.MALE);
-    }
-    getSealingSons() {
-        implemented("getSealingSons");
-        return this.getSealingChildren().filter(Filters.MALE);
-    }
-    getStepSons() {
-        implemented("getStepSons");
-        return this.getStepChildren().filter(Filters.MALE);
-    }
-    getDaughters() {
-        implemented("getDaughters");
-        return this.getChildren().filter(Filters.FEMALE);
-    }
-    getBiologicalDaugthers() {
-        implemented("getBiologicalDaugthers");
-        return this.getChildrenFilteredByPedigree(Filters.BIOLOGICAL).filter(Filters.FEMALE);
-    }
-    getAdoptedDaughters() {
-        implemented("getAdoptedDaughters");
-        return this.getAdoptedChildren().filter(Filters.FEMALE);
-    }
-    getBirthDaughters() {
-        implemented("getBirthDaughters");
-        return this.getBirthChildren().filter(Filters.FEMALE);
-    }
-    getFosterDaughters() {
-        implemented("getFosterDaughters");
-        return this.getFosterChildren().filter(Filters.FEMALE);
-    }
-    getSealingDaughters() {
-        implemented("getSealingDaughters");
-        return this.getSealingChildren().filter(Filters.FEMALE);
-    }
-    getStepDaughters() {
-        implemented("getStepDaughters");
-        return this.getStepChildren().filter(Filters.FEMALE);
-    }
-    getParents(filter) {
-        implemented("getParents");
-        return this.getAscendants(1, filter);
-    }
-    getParentsFilteredByPedigree(filter) {
-        const parents = new Individuals();
-        const familiesOfParents = this.get("FAMC")?.toValueList();
-        if (!familiesOfParents || !this.id) {
-            return parents;
-        }
-        const families = this.toFamilies(familiesOfParents);
-        families.forEach((family) => {
-            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() ||
-                    RelationType.BIOLOGICAL;
-                if ((!parentType && filter.PEDI === RelationType.BIOLOGICAL) ||
-                    parentType?.toLowerCase() === filter.PEDI.toLowerCase()) {
-                    parents.merge(family.getParents());
-                }
-                return;
-            }
-            const fatherType = child.get("_FREL")?.toValue();
-            const motherType = child.get("_MREL")?.toValue();
-            if ((!fatherType && filter.PEDI === RelationType.BIOLOGICAL) ||
-                fatherType?.toLowerCase() === filter.PEDI.toLowerCase()) {
-                const fatherId = family.get("HUSB")?.toValue();
-                const father = fatherId && this._gedcom?.indi(fatherId);
-                if (father) {
-                    parents.append(father);
-                }
-            }
-            if ((!motherType && filter.PEDI === RelationType.BIOLOGICAL) ||
-                motherType?.toLowerCase() === filter.PEDI.toLowerCase()) {
-                const motherId = family.get("WIFE")?.toValue();
-                const mother = motherId && this._gedcom?.indi(motherId);
-                if (mother) {
-                    parents.append(mother);
-                }
-            }
-        });
-        return parents;
-    }
-    getSpousesFilteredByPartner(filter) {
-        const spouses = new Individuals();
-        const familiesOfSpouses = this.get("FAMS")?.toValueList();
-        if (!familiesOfSpouses || !this.id) {
-            return spouses;
-        }
-        const families = this.toFamilies(familiesOfSpouses);
-        families.forEach((family) => {
-            const spouseType = family.get("_SREL")?.toValue();
-            if ((!spouseType && filter.PART === PartnerType.SPOUSE) ||
-                spouseType?.toLowerCase() === filter.PART.toLowerCase()) {
-                const spouse = family.getParents().copy().except(this).index(0);
-                if (spouse) {
-                    spouses.append(spouse);
-                }
-            }
-        });
-        return spouses;
-    }
-    getBiologicalParents() {
-        implemented("getBiologicalParents");
-        return this.getParentsFilteredByPedigree(Filters.BIOLOGICAL);
-    }
-    getAdoptedParents() {
-        implemented("getAdoptedParents");
-        return this.getParentsFilteredByPedigree(Filters.ADOPTED);
-    }
-    getBirthParents() {
-        implemented("getBirthParents");
-        return this.getParentsFilteredByPedigree(Filters.BIRTH);
-    }
-    getFosterParents() {
-        implemented("getFosterParents");
-        return this.getParentsFilteredByPedigree(Filters.FOSTER);
-    }
-    getSealingParents() {
-        implemented("getSealingParents");
-        return this.getParentsFilteredByPedigree(Filters.SEALING);
-    }
-    getStepParents() {
-        implemented("getStepParents");
-        return this.getParentsFilteredByPedigree(Filters.STEP);
-    }
-    getFathers() {
-        implemented("getFathers");
-        return this.getParents().filter(Filters.MALE);
-    }
-    getBiologicalFathers() {
-        implemented("getBiologicalFathers");
-        return this.getParentsFilteredByPedigree(Filters.BIOLOGICAL).filter(Filters.MALE);
-    }
-    getAdoptedFathers() {
-        implemented("getAdoptedFathers");
-        return this.getParentsFilteredByPedigree(Filters.ADOPTED).filter(Filters.MALE);
-    }
-    getBirthFathers() {
-        implemented("getBirthFathers");
-        return this.getParentsFilteredByPedigree(Filters.BIRTH).filter(Filters.MALE);
-    }
-    getFosterFathers() {
-        implemented("getFosterFathers");
-        return this.getParentsFilteredByPedigree(Filters.FOSTER).filter(Filters.MALE);
-    }
-    getSealingFathers() {
-        implemented("getSealingFathers");
-        return this.getParentsFilteredByPedigree(Filters.SEALING).filter(Filters.MALE);
-    }
-    getStepFathers() {
-        implemented("getStepFathers");
-        return this.getParentsFilteredByPedigree(Filters.STEP).filter(Filters.MALE);
-    }
-    getMothers() {
-        implemented("getMothers");
-        return this.getParents().filter(Filters.FEMALE);
-    }
-    getBiologicalMothers() {
-        implemented("getBiologicalMothers");
-        return this.getParentsFilteredByPedigree(Filters.BIOLOGICAL).filter(Filters.FEMALE);
-    }
-    getAdoptedMothers() {
-        implemented("getAdoptedMothers");
-        return this.getParentsFilteredByPedigree(Filters.ADOPTED).filter(Filters.FEMALE);
-    }
-    getBirthMothers() {
-        implemented("getBirthMothers");
-        return this.getParentsFilteredByPedigree(Filters.BIRTH).filter(Filters.FEMALE);
-    }
-    getFosterMothers() {
-        implemented("getFosterMothers");
-        return this.getParentsFilteredByPedigree(Filters.FOSTER).filter(Filters.FEMALE);
-    }
-    getSealingMothers() {
-        implemented("getSealingMothers");
-        return this.getParentsFilteredByPedigree(Filters.SEALING).filter(Filters.FEMALE);
-    }
-    getStepMothers() {
-        implemented("getStepMothers");
-        return this.getParentsFilteredByPedigree(Filters.STEP).filter(Filters.FEMALE);
-    }
-    getCoParents() {
-        implemented("getCoParents");
-        return this.getRelativesOnLevel(0);
-    }
-    getSpouses() {
-        implemented("getCertifiedSpouses");
-        return this.getSpousesFilteredByPartner(Filters.SPOUSE);
-    }
-    getPartners() {
-        implemented("getPartners");
-        return this.getSpousesFilteredByPartner(Filters.PARTNER);
-    }
-    getFriends() {
-        implemented("getFriends");
-        return this.getSpousesFilteredByPartner(Filters.FRIEND);
-    }
-    getWives() {
-        implemented("getWives");
-        return this.getCoParents().filter(Filters.FEMALE);
-    }
-    getHusbands() {
-        implemented("getHusbands");
-        return this.getCoParents().filter(Filters.MALE);
-    }
-    getCousins() {
-        implemented("getCousins");
-        return this.getRelativesOnDegree(1);
-    }
-    getGrandParents() {
-        implemented("getGrandParents");
-        return this.getAscendants(2);
-    }
-    getGrandFathers() {
-        implemented("getGrandFathers");
-        return this.getGrandParents().filter(Filters.MALE);
-    }
-    getGrandMothers() {
-        implemented("getGrandMothers");
-        return this.getGrandParents().filter(Filters.FEMALE);
-    }
-    getGrandChildren() {
-        implemented("getGrandChildren");
-        return this.getDescendants(2);
-    }
-    getGrandSons() {
-        implemented("getGrandSons");
-        return this.getGrandChildren().filter(Filters.MALE);
-    }
-    getGrandDaughters() {
-        implemented("getGrandDaughters");
-        return this.getGrandChildren().filter(Filters.FEMALE);
-    }
-    getGreatGrandParents() {
-        implemented("getGreatGrandParents");
-        return this.getAscendants(3);
-    }
-    getGreatGrandFathers() {
-        implemented("getGreatGrandFathers");
-        return this.getGreatGrandParents().filter(Filters.MALE);
-    }
-    getGreatGrandMothers() {
-        implemented("getGreatGrandMothers");
-        return this.getGreatGrandParents().filter(Filters.FEMALE);
-    }
-    getGreatGrandChildren() {
-        implemented("getGreatGrandChildren");
-        return this.getDescendants(3);
-    }
-    getGreatGrandSons() {
-        implemented("getGreatGrandSons");
-        return this.getGreatGrandChildren().filter(Filters.MALE);
-    }
-    getGreatGrandDaughters() {
-        implemented("getGreatGrandDaughters");
-        return this.getGreatGrandChildren().filter(Filters.FEMALE);
-    }
-    getAuncles() {
-        implemented("getAuncles");
-        return this.getParents().getSiblings();
-    }
-    getAunts() {
-        implemented("getAunts");
-        return this.getAuncles().filter(Filters.FEMALE);
-    }
-    getUncles() {
-        implemented("getUncles");
-        return this.getAuncles().filter(Filters.MALE);
-    }
-    getNiblings() {
-        implemented("getNiblings");
-        return this.getSiblings().getChildren();
-    }
-    getNieces() {
-        implemented("getNieces");
-        return this.getNiblings().filter(Filters.FEMALE);
-    }
-    getNephews() {
-        implemented("getNephews");
-        return this.getNiblings().filter(Filters.MALE);
-    }
-    getParentsInLaw() {
-        implemented("getParentsInLaw");
-        return this.getCoParents().getParents();
-    }
-    getFathersInLaw() {
-        implemented("getFathersInLaw");
-        return this.getParentsInLaw().filter(Filters.MALE);
-    }
-    getMothersInLaw() {
-        implemented("getMothersInLaw");
-        return this.getParentsInLaw().filter(Filters.FEMALE);
-    }
-    getSiblingsInLaw() {
-        implemented("getSiblingsInLaw");
-        return this.getCoParents()
-            .copy()
-            .getSiblings()
-            .copy()
-            .merge(this.getSiblings().getCoParents());
-    }
-    getBrothersInLaw() {
-        implemented("getBrothersInLaw");
-        return this.getSiblingsInLaw().filter(Filters.MALE);
-    }
-    getSistersInLaw() {
-        implemented("getSistersInLaw");
-        return this.getSiblingsInLaw().filter(Filters.FEMALE);
-    }
-    getChildrenInLaw() {
-        implemented("getChildrenInLaw");
-        return this.getChildren().getCoParents();
-    }
-    getSonsInLaw() {
-        implemented("getSonsInLaw");
-        return this.getChildrenInLaw().filter(Filters.MALE);
-    }
-    getDaughtersInLaw() {
-        implemented("getDaughtersInLaw");
-        return this.getChildrenInLaw().filter(Filters.FEMALE);
-    }
-    // These are generated automatically
-    get2ndCousins() {
-        return new Individuals();
-    }
-    get2ndGreatGrandParents() {
-        return new Individuals();
-    }
-    get2ndGreatGrandChildren() {
-        return new Individuals();
-    }
-    get3rdCousins() {
-        return new Individuals();
-    }
-    get3rdGreatGrandParents() {
-        return new Individuals();
-    }
-    get3rdGreatGrandChildren() {
-        return new Individuals();
-    }
-    get4thCousins() {
-        return new Individuals();
-    }
-    get4thGreatGrandParents() {
-        return new Individuals();
-    }
-    get4thGreatGrandChildren() {
-        return new Individuals();
-    }
-    get5thCousins() {
-        return new Individuals();
-    }
-    get5thGreatGrandParents() {
-        return new Individuals();
-    }
-    get5thGreatGrandChildren() {
-        return new Individuals();
-    }
-    get6thCousins() {
-        return new Individuals();
-    }
-    get6thGreatGrandParents() {
-        return new Individuals();
-    }
-    get6thGreatGrandChildren() {
-        return new Individuals();
-    }
-    get7thCousins() {
-        return new Individuals();
-    }
-    get7thGreatGrandParents() {
-        return new Individuals();
-    }
-    get7thGreatGrandChildren() {
-        return new Individuals();
-    }
-    get8thCousins() {
-        return new Individuals();
-    }
-    get8thGreatGrandParents() {
-        return new Individuals();
-    }
-    get8thGreatGrandChildren() {
-        return new Individuals();
-    }
-    get9thCousins() {
-        return new Individuals();
-    }
-    get9thGreatGrandParents() {
-        return new Individuals();
-    }
-    get9thGreatGrandChildren() {
-        return new Individuals();
-    }
-}
-const generateFunctions = () => {
-    const levels = [2, 3, 4, 5, 6, 7, 8, 9];
-    const types = [
-        ["Cousins", 0, "degree"],
-        ["GreatGrandParents", 2, "level"],
-        ["GreatGrandChildren", -2, "level"],
-    ];
-    levels.forEach((level) => {
-        types.forEach(([type, starting, direction]) => {
-            let validLevel;
-            if (level === 2) {
-                validLevel = "2nd";
-            }
-            else if (level === 3) {
-                validLevel = "3rd";
-            }
-            else {
-                validLevel = `${level}th`;
-            }
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            Indi.prototype[`get${validLevel}${type}`] = function (filter) {
-                if (direction === "level" && starting < 0) {
-                    return this.getRelativesOnLevel(-level + starting, filter);
-                }
-                else if (direction === "level" && starting > 0) {
-                    return this.getRelativesOnLevel(level + starting, filter);
-                }
-                return this.getRelativesOnDegree(level + starting);
-            };
-        });
-    });
-};
-generateFunctions();
-export const createIndi = (gedcom, id, main, parent) => {
-    return createProxy(new Indi(gedcom, id, main, parent));
-};