@treeviz/gedcom-parser 2.0.9 → 2.0.12

package/dist/constants/index.js

@@ -8,11 +8,13 @@ var __export = (target, all) => {
 };
 
 // src/constants/constants.ts
+var APP_BRANDING = "TreeViz - The Family Tree Visualiser & Editor";
 var REF_LINE_REG = /^0 (?:(@[_a-zA-Z0-9]*@) )?(?<type>_[_A-Z][_a-zA-Z]{2,}|_?[A-Z][a-zA-Z]{2,}) ?(?<value>.*)/gm;
 var LINE_REG = /(?<indent>^[0-9]) (?:(@[_a-zA-Z0-9]*@) )?(?<type>_[_A-Z][_a-zA-Z]{2,}|_?[A-Z][a-zA-Z]{2,}) ?(?<value>.*)/;
 var ID_REG = /^@[_a-zA-Z0-9]+@/;
 var ID_GETTER_REG = /^(?<at>@)?(?<letter>[A-Z])?/i;
 var ID_SPLIT_REG = /^@[_a-zA-Z0-9]+@:/;
+var ORIG_HEAD_TAG = "_ORIGHEAD";
 var MAX_FILE_SIZE_TO_SYNC = 1024 * 1024 * 20;
 
 // src/constants/filters.ts
@@ -95,7 +97,8 @@ __export(translators_exports, {
   en: () => KinshipTranslatorEn,
   es: () => KinshipTranslatorEs,
   fr: () => KinshipTranslatorFr,
-  hu: () => KinshipTranslatorHU
+  hu: () => KinshipTranslatorHU,
+  ru: () => KinshipTranslatorRu
 });
 var getGedcomId = (gedcom) => {
   if (!gedcom) {
@@ -542,1050 +545,1317 @@ var dateFormatter = (indi, showMarriages = false, showDays = false, showPlaces =
     } : {}
   };
 };
-var Common = class _Common {
-  constructor(gedcom, id, main, parent) {
+
+// src/utils/gedcom-trailer.ts
+var GEDCOM_TRAILER_TAG = "TRLR";
+var isGedcomTrailerTag = (tag) => tag === GEDCOM_TRAILER_TAG;
+var List = class _List {
+  // length = 0;
+  constructor(items) {
+    this.items = {};
     this.isListable = true;
-    this._gedcom = gedcom;
-    this._main = main;
-    this._parent = parent;
-    this.initUniqueId();
-    if (id) {
-      this._id = id;
-    } else {
-      delete this._id;
+    this.marker = void 0;
+    if (items) {
+      this.concat(items);
     }
   }
-  set type(type) {
-    if (type) {
-      this.uniqueId = this.uniqueId?.replace(/^[^:]+/, `~${type}`);
-    }
-    this._type = type;
+  get length() {
+    return this.values().length;
   }
-  get type() {
-    return this._type;
+  has(indi) {
+    return !!this.item(
+      typeof indi === "string" ? indi : indi?.id ?? ""
+    );
   }
-  initUniqueId() {
-    if (this._gedcom) {
-      this.uniqueId = `~Common:${this._gedcom.refcount++}`;
-    }
+  get(name) {
+    const propList = new _List();
+    this.entries().forEach(([key, item]) => {
+      propList.item(key, item.get(name));
+    });
+    return propList;
   }
-  set uniqueId(id) {
-    const currentId = this._uniqueId;
-    if (this._gedcom?.reflist && id) {
-      this._uniqueId = id;
-      if (currentId && this._gedcom.reflist[currentId]) {
-        delete this._gedcom.reflist[currentId];
+  getIf(name, condition, name2) {
+    const propList = new _List();
+    this.entries().forEach(([key, item]) => {
+      const passedItem = item.getIf(name, condition, name2);
+      if (passedItem) {
+        propList.item(key, passedItem);
       }
-      this._gedcom.reflist[id] = this;
-    }
+    });
+    return propList;
   }
-  get uniqueId() {
-    return this._uniqueId;
+  keys() {
+    return Object.keys(this.items);
   }
-  set id(id) {
-    this._id = idGetter(id);
+  values() {
+    return Object.values(this.items);
   }
-  get id() {
-    return idGetter(this._id);
+  entries() {
+    return Object.entries(this.items);
   }
-  set value(value) {
-    this._value = value;
+  setLength(_type) {
   }
-  get value() {
-    return this._value;
+  first() {
+    return this.index(0);
   }
-  /**
-   * Set the gedcom reference for this object
-   * @param gedcom - The GedComType to set as the gedcom reference
-   */
-  setGedcom(gedcom) {
-    this._gedcom = gedcom;
+  last() {
+    return this.index(this.keys().length - 1);
   }
-  // avoid to override
-  get originalValue() {
-    return this._value;
+  index(index) {
+    const keys = this.keys();
+    const key = keys[index];
+    return key && this.items[key];
   }
-  get ref() {
-    if (typeof this.value === "string" && isId(this.value) && this.refType) {
-      return this._gedcom?.[getListTag(this.refType)]?.item(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.value
-      );
+  item(name, value) {
+    if (arguments.length > 1) {
+      set(this.items, name, value);
+      this.setLength();
     }
-    return this;
+    return get(this.items, name);
   }
-  get main() {
-    return this._main;
+  removeItem(name) {
+    unset(this.items, name);
+    this.setLength();
   }
-  get parent() {
-    return this._parent;
+  exclude(excludedList) {
+    excludedList.keys().forEach((itemId) => {
+      delete this.items[itemId];
+    });
+    this.setLength();
+    return this;
   }
-  addRef(refNode) {
-    if (typeof refNode.value === "string" && isId(refNode.value) && refNode.refType) {
-      if (!this._refs) {
-        this._refs = new List();
-      }
-      this._refs.item(refNode.value, refNode);
+  concat(items) {
+    if (Array.isArray(items)) {
+      items.forEach((item) => {
+        this.append(item);
+      });
+    } else {
+      Object.assign(this.items, items ?? {});
     }
+    this.setLength();
+    return this;
   }
-  getRefs() {
-    return this._refs;
-  }
-  exportValue() {
-    return this.value;
+  merge(mergedList) {
+    this.concat(mergedList?.items);
+    return this;
   }
-  removeValue() {
-    delete this._value;
+  intersection(mergedList) {
+    const inter = intersectionBy(
+      this.values(),
+      mergedList?.values() ?? [],
+      "id"
+    );
+    return new _List(inter);
   }
-  set(name, value) {
-    if (typeof value === "string") {
-      const usedValue = createCommon(this._gedcom, void 0, this.main);
-      usedValue.value = value;
-      set(this, name, usedValue);
-    } else {
-      set(this, name, value);
-    }
-    return get(this, name);
+  difference(mergedList) {
+    const inter = differenceBy(
+      this.values(),
+      mergedList?.values() ?? [],
+      "id"
+    );
+    return new _List(inter);
   }
-  assign(name, value, unique = false) {
-    let curValue = this.get(name);
-    if (curValue?.isListable) {
-      if (curValue instanceof _Common) {
-        curValue = new List().concat({ ...[curValue] });
-        this.set(name, curValue);
+  prepend(item) {
+    if (item.id) {
+      let increase = true;
+      if (this.items[item.id]) {
+        delete this.items[item.id];
+        increase = false;
+      }
+      this.items = Object.assign(
+        {
+          [item.id]: item
+        },
+        this.items
+      );
+      if (increase) {
+        this.setLength("increase");
       }
-      const values = [
-        ...curValue.values(),
-        ...value instanceof List ? value.values() : [value]
-      ];
-      curValue.concat({
-        ...!unique ? values : uniqBy(
-          values,
-          (value2) => value2 instanceof _Common ? value2?.value : void 0
-        )
-      });
-    } else {
-      this.set(name, value);
     }
-    return get(this, name);
+    return this;
   }
-  get(name) {
-    if (!name.includes(".")) {
-      return get(this, name);
-    }
-    const nameParts = name.split(".");
-    let last = this;
-    for (const part of nameParts) {
-      const indexPart = Number(part);
-      const itemIndex = part.match(/items\[(?<itemIndex>\d+)\]/)?.groups?.itemIndex;
-      const itemId = part.match(/items\[(?<itemId>@[A-Z]+\d+@)\]/)?.groups?.itemId;
-      const usedPart = itemId || itemIndex;
-      if (last instanceof List) {
-        if (!isNaN(indexPart)) {
-          last = last.index(indexPart);
-        } else {
-          if (usedPart) {
-            last = last.item(usedPart);
-          } else {
-            last = last?.index(0)?.get(part);
-          }
-        }
-      } else {
-        const usedIndex = Number(itemIndex ?? indexPart);
-        if (!isNaN(usedIndex)) {
-          last = last?.toList().index(usedIndex);
-        } else {
-          last = last?.get(itemId ?? part);
-        }
+  append(item) {
+    if (item.id) {
+      let increase = true;
+      if (this.items[item.id]) {
+        delete this.items[item.id];
+        increase = false;
       }
-      if (!last) {
-        break;
+      this.items[item.id] = item;
+      if (increase) {
+        this.setLength("increase");
       }
     }
-    return last;
+    return this;
   }
-  remove(name) {
-    unset(this, name);
+  delete(item) {
+    if (item.id && this.items[item.id]) {
+      delete this.items[item.id];
+      this.setLength("decrease");
+    }
+    return this;
   }
-  getGedcom() {
-    return this._gedcom;
+  copy(ClassName = _List) {
+    const newList = new ClassName();
+    Object.assign(newList.items, this.items);
+    newList.setLength();
+    return newList;
   }
-  getIf(name, condition, name2) {
-    const nameParts = name.split(".");
-    const name2Parts = name2.split(".");
-    if (nameParts.length !== name2Parts.length) {
-      throw new Error("Tag pathes must be of the same depth");
-    }
-    if (nameParts.length > 1 && nameParts[0] !== name2Parts[0]) {
-      throw new Error("Final tags must be siblings");
-    }
-    const valueCommon = this.get(name);
-    if (valueCommon instanceof _Common) {
-      return valueCommon?.toValue() !== condition ? void 0 : this.get(name2);
-    }
-    const valueCommon2 = this.get(name2)?.toList();
-    const ifList = new List();
-    valueCommon?.forEach((item, key) => {
-      const pair = valueCommon2?.item(key);
-      ifList.item(key, item?.toValue() !== condition ? void 0 : pair);
-    });
-    return ifList;
-  }
-  toString() {
-    return this.value?.toString() || "";
-  }
-  toValue() {
-    return this.value;
-  }
-  toProp(tag) {
-    const prop = this.get(tag);
-    return prop;
-  }
-  toList() {
-    return new List().concat(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      this.id ? { [this.id]: this } : { ...[this] }
-    );
-  }
-  index(i) {
-    return this.toList()?.index(i);
+  except(item, ClassName = _List) {
+    return this.copy(ClassName).delete(item);
   }
-  toValueList() {
-    return new List().concat(
-      this.value ? { [this.value]: this } : (
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        { ...[this] }
-      )
-    );
+  forEach(iterate) {
+    this.entries().forEach(([key, item], index) => {
+      iterate(item, key, index);
+    });
   }
-  standardizeObject(tag, options) {
-    if (tag === "OBJE" && !options?.original && options?.obje?.standardize && options?.obje?.namespace && "standardizeMedia" in this) {
-      const standardize = this.standardizeMedia;
-      return standardize.call(
-        this,
-        options.obje.namespace,
-        options.obje.override
-      );
-    }
+  map(iterate) {
+    return this.entries().map(([key, item], index) => {
+      return iterate(item, key, index);
+    });
   }
-  toJson(tag, options) {
-    const json = this.toObject(tag, options);
-    return JSON.stringify(json);
+  reduce(iterate, initialValue) {
+    return this.entries().reduce((acc, [key, item], index) => {
+      return iterate(acc, item, key, index);
+    }, initialValue);
   }
-  toObject(tag, options) {
-    this.standardizeObject(tag, options);
-    const validKeys = getValidKeys(this);
-    let json = {};
-    validKeys.forEach((key) => {
-      if (key === "id" && this.id !== void 0) {
-        json.id = this.id;
-      } else if (key === "_id" && this._id !== void 0) {
-        json.id = this._id;
-      } else if (key === "value" && this.value !== void 0) {
-        json.value = this.value;
-      } else if (key === "_value" && this._value !== void 0) {
-        json.value = this._value;
-      } else {
-        const validKey = key;
-        const prop = this.get(validKey);
-        if (typeof prop?.toObject === "function") {
-          if (prop instanceof _Common) {
-            json[validKey] = prop.toObject(validKey, options);
-          } else {
-            json = {
-              ...json,
-              ...prop.toObject(validKey, options)
-            };
-          }
+  filter(filters, ClassName = _List) {
+    const newList = new ClassName();
+    const isIterator = typeof filters === "function";
+    this.entries().forEach(([itemId, item], index) => {
+      if (isIterator) {
+        filters(item, itemId, index) && newList.item(itemId, item);
+        return;
+      }
+      if (!Object.keys(filters).length || Object.entries(filters).every(([key, value]) => {
+        let itemValue;
+        if (key === "id") {
+          itemValue = item.toProp("id");
+        } else {
+          itemValue = item.toProp(key)?.toValue();
+        }
+        if (Array.isArray(value)) {
+          return value.includes(itemValue);
         }
+        return itemValue === value;
+      })) {
+        newList.item(itemId, item);
       }
     });
-    return json;
+    return newList;
   }
-  merge(other, override = false, avoidKeys = []) {
-    if (!other) {
-      return this;
-    }
-    const validKeys = getValidKeys(other);
-    validKeys.forEach((validKey) => {
-      if (avoidKeys.includes(validKey)) {
-        return;
+  find(filters, _ClassName = _List) {
+    let foundItem;
+    const isIterator = typeof filters === "function";
+    this.entries().find(([itemId, item], index) => {
+      if (isIterator) {
+        if (filters(item, itemId, index)) {
+          foundItem = item;
+          return true;
+        }
+        return false;
       }
-      const current = this.get(validKey);
-      const mergeValue = other.get(validKey);
-      if (mergeValue) {
-        if (current instanceof _Common || current instanceof List) {
-          this.assign(validKey, mergeValue, true);
-        } else if (!current || override && validKey !== "id" && validKey !== "_id") {
-          this.set(validKey, mergeValue);
+      if (!Object.keys(filters).length || Object.entries(filters).every(([key, value]) => {
+        let itemValue;
+        if (key === "id") {
+          itemValue = item.toProp("id");
+        } else {
+          itemValue = item.toProp(key)?.toValue();
+        }
+        if (Array.isArray(value)) {
+          return value.includes(itemValue);
         }
+        return itemValue === value;
+      })) {
+        foundItem = item;
+        return true;
       }
+      return false;
     });
-    return this;
+    return foundItem;
   }
-  clone(newId = false, avoidKeys = []) {
-    const ctor = this.constructor;
-    const instance = new ctor(
-      this._gedcom,
-      this._id,
-      this._main,
-      this._parent
-    );
-    if (newId && this._id) {
-      instance.id = `IFT${this._id.replace(/[^0-9]/g, "")}`;
+  orderBy(orders, ClassName = _List) {
+    const newList = new ClassName();
+    const isIterator = typeof orders === "function";
+    if (!isIterator && (!orders || !Object.keys(orders).length)) {
+      return newList.merge(this);
     }
-    const cloned = createProxy(instance);
-    cloned.merge(this, true, avoidKeys);
-    return cloned;
-  }
-  // fromGedcom<T = typeof this>(value: string) {
-  fromGedcom(_value) {
-  }
-  toGedcom(tag, level = 0, options) {
-    const gedcom = this.toGedcomLines(tag, level, options);
-    return gedcom.join("\n");
-  }
-  toGedcomLines(tag, level = 0, options) {
-    this.standardizeObject(tag, options);
-    const validKeys = getValidKeys(this);
-    const gedcom = [];
-    validKeys.forEach((key) => {
-      const validKey = key;
-      const prop = this.get(validKey);
-      if (typeof prop?.toGedcomLines === "function") {
-        if (prop instanceof _Common) {
-          const value = prop.exportValue();
-          gedcom.push(
-            `${level} ${validKey}${value ? ` ${value}` : ""}`
-          );
-          gedcom.push(
-            ...prop.toGedcomLines(validKey, level + 1, options)
-          );
-        } else {
-          gedcom.push(
-            ...prop.toGedcomLines(validKey, level, options)
-          );
+    const sortedItems = this.entries().toSorted(
+      ([itemAId, itemA], [itemBId, itemB]) => {
+        if (isIterator) {
+          return orders(itemA, itemAId, itemB, itemBId);
+        }
+        const [key, { direction, getter }] = Object.entries(
+          typeof orders === "string" ? { [orders]: { direction: "ASC" } } : orders
+        )[0];
+        const rawA = itemA.get(key);
+        const rawB = itemB.get(key);
+        let valueA = rawA?.toValue();
+        let valueB = rawB?.toValue();
+        if (getter && typeof getter === "function") {
+          valueA = getter(valueA, rawA);
+          valueB = getter(valueB, rawB);
+        }
+        let sortValue2 = 0;
+        if (!valueA && valueA !== 0 && !valueB && valueB !== 0) {
+          sortValue2 = 0;
+        } else if (!valueB && valueB !== 0) {
+          sortValue2 = 1;
+        } else if (!valueA && valueA !== 0) {
+          sortValue2 = -1;
+        } else if (valueA < valueB) {
+          sortValue2 = -1;
+        } else if (valueA > valueB) {
+          sortValue2 = 1;
         }
+        return sortValue2 * (direction === "DESC" ? -1 : 1);
       }
+    );
+    sortedItems.forEach(([key, value]) => {
+      newList.item(key, value);
     });
-    return gedcom;
-  }
-  isGenoPro() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("genopro");
-  }
-  isAhnenblatt() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("ahnenblatt");
-  }
-  isGeni() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("geni");
-  }
-  isAncestry() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("ancestry");
-  }
-  isMyHeritage() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return !!sour?.toLowerCase()?.startsWith("myheritage");
+    return newList;
   }
-  /**
-   * 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;
+  groupBy(groups, sort, minOccurance = -1, lessOccuranceLabel = "Appearing less than 5 times", ClassName = _List) {
+    const groupped = {};
+    const isIterator = typeof groups === "function";
+    if (!isIterator && (!groups || !Object.keys(groups).length)) {
+      groupped.Unknown = new ClassName().merge(this);
+      groupped.Unknown.marker = "Unknown";
+      return groupped;
+    }
+    this.forEach((item, itemId) => {
+      const group = [];
+      if (isIterator) {
+        const newGroups = groups(item, itemId);
+        group.push(
+          ...Array.isArray(newGroups) ? newGroups : [newGroups]
+        );
+      } else {
+        const [key, { getter }] = Object.entries(
+          typeof groups === "string" ? { [groups]: {} } : groups
+        )[0];
+        const raw = item.get(key)?.index(0);
+        let value = raw?.toValue();
+        if (getter && typeof getter === "function") {
+          value = getter(value, raw);
+        }
+        if (value) {
+          group.push(value);
+        }
+      }
+      if (!group.length) {
+        group.push("Unknown");
+      }
+      group.forEach((g) => {
+        const newGroup = typeof g === "string" ? { group: g } : g;
+        if (!groupped[newGroup.group]) {
+          groupped[newGroup.group] = new ClassName();
+          groupped[newGroup.group].marker = newGroup.marker ?? newGroup.group;
+        }
+        groupped[newGroup.group]?.append(item);
+      });
+    });
+    if (sort) {
+      return Object.entries(groupped).toSorted(([ak, a], [bk, b]) => {
+        if (typeof sort === "function") {
+          return sort(a, ak, b, bk);
+        }
+        if (ak === "Unknown") {
+          return 1;
+        }
+        if (bk === "Unknown") {
+          return -1;
+        }
+        if (sort === "group") {
+          return ak.localeCompare(bk);
+        }
+        return (b?.length ?? 0) - (a?.length ?? 0);
+      }).reduce((acc, [key, value]) => {
+        if (minOccurance > -1 && (value?.length ?? 0) < minOccurance) {
+          const otherKey = lessOccuranceLabel;
+          acc[otherKey] = acc[otherKey] && value ? acc[otherKey].merge(value) : value;
+        } else {
+          acc[key] = value;
+        }
+        return acc;
+      }, {});
+    }
+    return groupped;
   }
-  isFamilySearch() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sourName = get(head, "SOUR.NAME.value");
-    return sourName === "FamilySearch API";
+  findIndex(item) {
+    if (!item?.id) {
+      return -1;
+    }
+    return this.keys().findIndex((key) => key === item.id);
   }
-  isGNO2GED() {
-    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
-    const sour = get(head, "SOUR.value");
-    return sour === "GNO2GED";
+  getItems() {
+    return this.items;
   }
-  getAncestryTreeId() {
-    const path = "HEAD.SOUR._TREE.RIN.value";
-    return get(this, path) || get(this.getGedcom(), path);
+  toJson(tag, options) {
+    const json = this.toObject(tag, options);
+    return JSON.stringify(json);
   }
-  getMyHeritageTreeId() {
-    const path = "HEAD._EXPORTED_FROM_SITE_ID.value";
-    return get(this, path) || get(this.getGedcom(), path);
+  toObject(tag, options) {
+    const json = {};
+    this.entries().forEach(([_, item]) => {
+      const validTag = getValidTag(tag);
+      if (json[validTag]) {
+        if (!Array.isArray(json[validTag])) {
+          json[validTag] = [json[validTag]];
+        }
+        json[validTag].push(
+          item.toObject(validTag, options)
+        );
+      } else {
+        json[validTag] = item.toObject(
+          validTag,
+          options
+        );
+      }
+    });
+    return json;
   }
-  getTreeId() {
-    if (this?.isAncestry()) {
-      const id = this.getAncestryTreeId();
-      if (id !== void 0) return id;
-    }
-    if (this?.isMyHeritage()) {
-      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();
+  toGedcom(tag, level = 0, options) {
+    const gedcom = this.toGedcomLines(tag, level, options);
+    return gedcom.join("\n");
   }
-  getAncestryTreeName() {
-    const path = "HEAD.SOUR._TREE.value";
-    return get(this, path) || get(this.getGedcom(), path);
+  toGedcomLines(tag, level = 0, options) {
+    const gedcom = [];
+    this.entries().forEach(([_, item]) => {
+      const validTag = getValidTag(tag);
+      const validKey = item.id;
+      const validValue = validKey ? validTag : item.exportValue();
+      gedcom.push(
+        `${level} ${validKey || validTag}${validValue ? ` ${validValue}` : ""}`
+      );
+      gedcom.push(
+        ...item.toGedcomLines(
+          validTag,
+          level + 1,
+          options
+        )
+      );
+    });
+    return gedcom;
   }
-  getMyHeritageTreeName() {
-    const path = "HEAD.FILE.value";
-    const treeDetails = get(this, path) || get(this.getGedcom(), path);
-    return treeDetails?.match(
-      /Exported by MyHeritage.com from (?<tree>.+) in.+$/
-    )?.groups?.tree;
+  toValue() {
+    const propList = new _List();
+    this.entries().forEach(([key, item]) => {
+      propList.item(key, item?.toValue());
+    });
+    return propList;
   }
-  getFamilySearchTreeId() {
-    const rin = get(this, "HEAD.SOUR._TREE.RIN.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.RIN.value");
-    if (rin) {
-      return rin;
-    }
-    return "familysearch";
+  // @deprecated use get instead
+  toProp(tag) {
+    return this.get(tag);
   }
-  getFamilySearchTreeName() {
-    const treeName = get(this, "HEAD.SOUR._TREE.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.value");
-    if (treeName) {
-      return treeName;
+  toList() {
+    return new _List().concat(this.items);
+  }
+  toValueList() {
+    const newList = new _List();
+    this.values().forEach((value) => {
+      value.value && newList.item(value.value, value);
+    });
+    return newList;
+  }
+};
+
+// src/classes/common.ts
+var Common = class _Common {
+  constructor(gedcom, id, main, parent) {
+    this.isListable = true;
+    this._gedcom = gedcom;
+    this._main = main;
+    this._parent = parent;
+    this.initUniqueId();
+    if (id) {
+      this._id = id;
+    } else {
+      delete this._id;
     }
-    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];
-      }
+  set type(type) {
+    if (type) {
+      this.uniqueId = this.uniqueId?.replace(/^[^:]+/, `~${type}`);
     }
-    return void 0;
+    this._type = type;
   }
-  getAhnenblattTreeName() {
-    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
-    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  get type() {
+    return this._type;
   }
-  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];
-      }
+  initUniqueId() {
+    if (this._gedcom) {
+      this.uniqueId = `~Common:${this._gedcom.refcount++}`;
     }
-    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];
+  set uniqueId(id) {
+    const currentId = this._uniqueId;
+    if (this._gedcom?.reflist && id) {
+      this._uniqueId = id;
+      if (currentId && this._gedcom.reflist[currentId]) {
+        delete this._gedcom.reflist[currentId];
       }
+      this._gedcom.reflist[id] = this;
     }
-    return void 0;
   }
-  getGenoProTreeName() {
-    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
-    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  get uniqueId() {
+    return this._uniqueId;
   }
-  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"}`;
+  set id(id) {
+    this._id = idGetter(id);
   }
-  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";
+  get id() {
+    return idGetter(this._id);
   }
-  /**
-   * 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"}`;
+  set value(value) {
+    this._value = value;
+  }
+  get value() {
+    return this._value;
   }
   /**
-   * Universal tree name getter for unknown/unrecognized GEDCOM sources
-   * Tries to extract a name from various common locations
+   * Set the gedcom reference for this object
+   * @param gedcom - The GedComType to set as the gedcom reference
    */
-  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`;
+  setGedcom(gedcom) {
+    this._gedcom = gedcom;
   }
-  getTreeName() {
-    if (this?.isAncestry()) {
-      const name = this.getAncestryTreeName();
-      if (name) return name;
-    }
-    if (this?.isMyHeritage()) {
-      const name = this.getMyHeritageTreeName();
-      if (name) return name;
+  // avoid to override
+  get originalValue() {
+    return this._value;
+  }
+  get ref() {
+    if (typeof this.value === "string" && isId(this.value) && this.refType) {
+      return this._gedcom?.[getListTag(this.refType)]?.item(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.value
+      );
     }
-    if (this?.isFamilySearch()) {
-      const name = this.getFamilySearchTreeName();
-      if (name) return name;
+    return this;
+  }
+  get main() {
+    return this._main;
+  }
+  get parent() {
+    return this._parent;
+  }
+  addRef(refNode) {
+    if (typeof refNode.value === "string" && isId(refNode.value) && refNode.refType) {
+      if (!this._refs) {
+        this._refs = new List();
+      }
+      this._refs.item(refNode.value, refNode);
     }
-    if (this?.isGNO2GED()) {
-      const name = this.getGNO2GEDTreeName();
-      if (name) return name;
+  }
+  getRefs() {
+    return this._refs;
+  }
+  exportValue() {
+    return this.value;
+  }
+  removeValue() {
+    delete this._value;
+  }
+  set(name, value) {
+    if (isGedcomTrailerTag(name)) {
+      return void 0;
     }
-    if (this?.isAhnenblatt()) {
-      const name = this.getAhnenblattTreeName();
-      if (name) return name;
+    if (typeof value === "string") {
+      const usedValue = createCommon(this._gedcom, void 0, this.main);
+      usedValue.value = value;
+      set(this, name, usedValue);
+    } else {
+      set(this, name, value);
     }
-    if (this?.isGeni()) {
-      const name = this.getGeniTreeName();
-      if (name) return name;
+    return get(this, name);
+  }
+  assign(name, value, unique = false) {
+    if (isGedcomTrailerTag(name)) {
+      return void 0;
     }
-    if (this?.isGenoPro()) {
-      const name = this.getGenoProTreeName();
-      if (name) return name;
+    let curValue = this.get(name);
+    if (curValue?.isListable) {
+      if (curValue instanceof _Common) {
+        curValue = new List().concat({ ...[curValue] });
+        this.set(name, curValue);
+      }
+      const values = [
+        ...curValue.values(),
+        ...value instanceof List ? value.values() : [value]
+      ];
+      curValue.concat({
+        ...!unique ? values : uniqBy(
+          values,
+          (value2) => value2 instanceof _Common ? value2?.value : void 0
+        )
+      });
+    } else {
+      this.set(name, value);
     }
-    return this.getUniversalTreeName();
+    return get(this, name);
   }
-};
-var createProxy = (target) => {
-  return new Proxy(target, {
-    get(t, prop, receiver) {
-      if (prop === "unwrapped") {
-        return target;
-      }
-      if (prop in t) {
-        return Reflect.get(t, prop, receiver);
-      }
-      if (!isOnlyMainProp(prop)) {
-        const ref = t.ref;
-        if (ref && prop in ref) {
-          return Reflect.get(ref, prop, receiver);
+  get(name) {
+    if (!name.includes(".")) {
+      return get(this, name);
+    }
+    const nameParts = name.split(".");
+    let last = this;
+    for (const part of nameParts) {
+      const indexPart = Number(part);
+      const itemIndex = part.match(/items\[(?<itemIndex>\d+)\]/)?.groups?.itemIndex;
+      const itemId = part.match(/items\[(?<itemId>@[A-Z]+\d+@)\]/)?.groups?.itemId;
+      const usedPart = itemId || itemIndex;
+      if (last instanceof List) {
+        if (!isNaN(indexPart)) {
+          last = last.index(indexPart);
+        } else {
+          if (usedPart) {
+            last = last.item(usedPart);
+          } else {
+            last = last?.index(0)?.get(part);
+          }
+        }
+      } else {
+        const usedIndex = Number(itemIndex ?? indexPart);
+        if (!isNaN(usedIndex)) {
+          last = last?.toList().index(usedIndex);
+        } else {
+          last = last?.get(itemId ?? part);
         }
       }
+      if (!last) {
+        break;
+      }
     }
-  });
-};
-var createCommon = (gedcom, id, main, parent) => {
-  return createProxy(
-    new Common(gedcom, id, main, parent)
-  );
-};
-var isOnlyMainProp = (key) => {
-  return key === "_gedcom" || key === "_main" || key === "_parent" || key === "_uniqueId" || key === "_type" || key === "_refs" || key === "id" || key === "_id";
-};
-var isValidKey = (common, key) => {
-  const prop = get(common, key);
-  return key !== "_gedcom" && key !== "_main" && key !== "_parent" && key !== "_uniqueId" && key !== "_refs" && key !== "_type" && (key === "id" || key === "_id" || key === "value" || key === "_value" || prop instanceof Common || prop instanceof List);
-};
-var getValidKeys = (common) => {
-  return Object.keys(common).filter((key) => {
-    return isValidKey(common, key);
-  });
-};
-var getValidTag = (tag) => {
-  return tag.replace(/^@@/, "");
-};
-var getListTag = (tag) => {
-  return `@@${tag}`;
-};
-var isId = (string) => {
-  return ID_REG.test(string);
-};
-var idGetter = (id) => {
-  if (id === void 0) {
-    return void 0;
+    return last;
   }
-  let newId = `${id}`;
-  const parts = newId?.match(ID_GETTER_REG)?.groups;
-  if (!parts?.at && !parts?.letter) {
-    newId = `@U${newId}`;
-  } else if (!parts.at) {
-    newId = `@${newId}`;
-  } else if (!parts.letter) {
-    newId = newId.replace(/^@/, "@U");
+  remove(name) {
+    unset(this, name);
   }
-  if (!newId.endsWith("@")) {
-    newId = `${newId}@`;
+  getGedcom() {
+    return this._gedcom;
   }
-  return newId;
-};
-
-// src/classes/list.ts
-var List = class _List {
-  // length = 0;
-  constructor(items) {
-    this.items = {};
-    this.isListable = true;
-    this.marker = void 0;
-    if (items) {
-      this.concat(items);
+  getIf(name, condition, name2) {
+    const nameParts = name.split(".");
+    const name2Parts = name2.split(".");
+    if (nameParts.length !== name2Parts.length) {
+      throw new Error("Tag pathes must be of the same depth");
     }
-  }
-  get length() {
-    return this.values().length;
-  }
-  has(indi) {
-    return !!this.item(
-      typeof indi === "string" ? indi : indi?.id ?? ""
-    );
-  }
-  get(name) {
-    const propList = new _List();
-    this.entries().forEach(([key, item]) => {
-      propList.item(key, item.get(name));
-    });
-    return propList;
-  }
-  getIf(name, condition, name2) {
-    const propList = new _List();
-    this.entries().forEach(([key, item]) => {
-      const passedItem = item.getIf(name, condition, name2);
-      if (passedItem) {
-        propList.item(key, passedItem);
-      }
+    if (nameParts.length > 1 && nameParts[0] !== name2Parts[0]) {
+      throw new Error("Final tags must be siblings");
+    }
+    const valueCommon = this.get(name);
+    if (valueCommon instanceof _Common) {
+      return valueCommon?.toValue() !== condition ? void 0 : this.get(name2);
+    }
+    const valueCommon2 = this.get(name2)?.toList();
+    const ifList = new List();
+    valueCommon?.forEach((item, key) => {
+      const pair = valueCommon2?.item(key);
+      ifList.item(key, item?.toValue() !== condition ? void 0 : pair);
     });
-    return propList;
-  }
-  keys() {
-    return Object.keys(this.items);
+    return ifList;
   }
-  values() {
-    return Object.values(this.items);
+  toString() {
+    return this.value?.toString() || "";
   }
-  entries() {
-    return Object.entries(this.items);
+  toValue() {
+    return this.value;
   }
-  setLength(_type) {
+  toProp(tag) {
+    const prop = this.get(tag);
+    return prop;
   }
-  first() {
-    return this.index(0);
+  toList() {
+    return new List().concat(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.id ? { [this.id]: this } : { ...[this] }
+    );
   }
-  last() {
-    return this.index(this.keys().length - 1);
+  index(i) {
+    return this.toList()?.index(i);
   }
-  index(index) {
-    const keys = this.keys();
-    const key = keys[index];
-    return key && this.items[key];
+  toValueList() {
+    return new List().concat(
+      this.value ? { [this.value]: this } : (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        { ...[this] }
+      )
+    );
   }
-  item(name, value) {
-    if (arguments.length > 1) {
-      set(this.items, name, value);
-      this.setLength();
+  standardizeObject(tag, options) {
+    if (tag === "OBJE" && !options?.original && options?.obje?.standardize && options?.obje?.namespace && "standardizeMedia" in this) {
+      const standardize = this.standardizeMedia;
+      return standardize.call(
+        this,
+        options.obje.namespace,
+        options.obje.override
+      );
     }
-    return get(this.items, name);
   }
-  removeItem(name) {
-    unset(this.items, name);
-    this.setLength();
+  toJson(tag, options) {
+    const json = this.toObject(tag, options);
+    return JSON.stringify(json);
   }
-  exclude(excludedList) {
-    excludedList.keys().forEach((itemId) => {
-      delete this.items[itemId];
+  toObject(tag, options) {
+    this.standardizeObject(tag, options);
+    const validKeys = getValidKeys(this);
+    let json = {};
+    validKeys.forEach((key) => {
+      if (key === "id" && this.id !== void 0) {
+        json.id = this.id;
+      } else if (key === "_id" && this._id !== void 0) {
+        json.id = this._id;
+      } else if (key === "value" && this.value !== void 0) {
+        json.value = this.value;
+      } else if (key === "_value" && this._value !== void 0) {
+        json.value = this._value;
+      } else {
+        const validKey = key;
+        const prop = this.get(validKey);
+        if (typeof prop?.toObject === "function") {
+          if (prop instanceof _Common) {
+            json[validKey] = prop.toObject(validKey, options);
+          } else {
+            json = {
+              ...json,
+              ...prop.toObject(validKey, options)
+            };
+          }
+        }
+      }
     });
-    this.setLength();
-    return this;
+    return json;
   }
-  concat(items) {
-    if (Array.isArray(items)) {
-      items.forEach((item) => {
-        this.append(item);
-      });
-    } else {
-      Object.assign(this.items, items ?? {});
+  merge(other, override = false, avoidKeys = []) {
+    if (!other) {
+      return this;
     }
-    this.setLength();
-    return this;
-  }
-  merge(mergedList) {
-    this.concat(mergedList?.items);
+    const validKeys = getValidKeys(other);
+    validKeys.forEach((validKey) => {
+      if (avoidKeys.includes(validKey)) {
+        return;
+      }
+      const current = this.get(validKey);
+      const mergeValue = other.get(validKey);
+      if (mergeValue) {
+        if (current instanceof _Common || current instanceof List) {
+          this.assign(validKey, mergeValue, true);
+        } else if (!current || override && validKey !== "id" && validKey !== "_id") {
+          this.set(validKey, mergeValue);
+        }
+      }
+    });
     return this;
   }
-  intersection(mergedList) {
-    const inter = intersectionBy(
-      this.values(),
-      mergedList?.values() ?? [],
-      "id"
+  clone(newId = false, avoidKeys = []) {
+    const ctor = this.constructor;
+    const instance = new ctor(
+      this._gedcom,
+      this._id,
+      this._main,
+      this._parent
     );
-    return new _List(inter);
+    if (newId && this._id) {
+      instance.id = `IFT${this._id.replace(/[^0-9]/g, "")}`;
+    }
+    const cloned = createProxy(instance);
+    cloned.merge(this, true, avoidKeys);
+    return cloned;
   }
-  difference(mergedList) {
-    const inter = differenceBy(
-      this.values(),
-      mergedList?.values() ?? [],
-      "id"
-    );
-    return new _List(inter);
+  // fromGedcom<T = typeof this>(value: string) {
+  fromGedcom(_value) {
   }
-  prepend(item) {
-    if (item.id) {
-      let increase = true;
-      if (this.items[item.id]) {
-        delete this.items[item.id];
-        increase = false;
-      }
-      this.items = Object.assign(
-        {
-          [item.id]: item
-        },
-        this.items
-      );
-      if (increase) {
-        this.setLength("increase");
-      }
-    }
-    return this;
+  toGedcom(tag, level = 0, options) {
+    const gedcom = this.toGedcomLines(tag, level, options);
+    return gedcom.join("\n");
   }
-  append(item) {
-    if (item.id) {
-      let increase = true;
-      if (this.items[item.id]) {
-        delete this.items[item.id];
-        increase = false;
-      }
-      this.items[item.id] = item;
-      if (increase) {
-        this.setLength("increase");
+  toGedcomLines(tag, level = 0, options) {
+    this.standardizeObject(tag, options);
+    const validKeys = getValidKeys(this);
+    const gedcom = [];
+    validKeys.forEach((key) => {
+      const validKey = key;
+      const prop = this.get(validKey);
+      if (typeof prop?.toGedcomLines === "function") {
+        if (prop instanceof _Common) {
+          const value = prop.exportValue();
+          gedcom.push(
+            `${level} ${validKey}${value ? ` ${value}` : ""}`
+          );
+          gedcom.push(
+            ...prop.toGedcomLines(validKey, level + 1, options)
+          );
+        } else {
+          gedcom.push(
+            ...prop.toGedcomLines(validKey, level, options)
+          );
+        }
       }
-    }
-    return this;
+    });
+    return gedcom;
   }
-  delete(item) {
-    if (item.id && this.items[item.id]) {
-      delete this.items[item.id];
-      this.setLength("decrease");
-    }
-    return this;
+  getHeadRecord() {
+    return get(this, "HEAD") || get(this.getGedcom(), "HEAD");
   }
-  copy(ClassName = _List) {
-    const newList = new ClassName();
-    Object.assign(newList.items, this.items);
-    newList.setLength();
-    return newList;
+  getOriginalHeadRecord() {
+    return get(this, ORIG_HEAD_TAG) || get(this.getGedcom(), ORIG_HEAD_TAG) || get(this.getHeadRecord(), ORIG_HEAD_TAG);
   }
-  except(item, ClassName = _List) {
-    return this.copy(ClassName).delete(item);
+  getSourceHeads() {
+    const heads = [this.getOriginalHeadRecord(), this.getHeadRecord()];
+    return heads.filter((head, index) => {
+      return Boolean(head && heads.indexOf(head) === index);
+    });
   }
-  forEach(iterate) {
-    this.entries().forEach(([key, item], index) => {
-      iterate(item, key, index);
+  getFromSourceHeads(path) {
+    for (const head of this.getSourceHeads()) {
+      const value = get(head, path);
+      if (value !== void 0 && value !== null && value !== "") {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  sourStartsWith(prefix) {
+    return this.getSourceHeads().some((head) => {
+      const sour = get(head, "SOUR.value");
+      return !!sour?.toLowerCase()?.startsWith(prefix);
     });
   }
-  map(iterate) {
-    return this.entries().map(([key, item], index) => {
-      return iterate(item, key, index);
+  isGenoPro() {
+    return this.sourStartsWith("genopro");
+  }
+  isAhnenblatt() {
+    return this.sourStartsWith("ahnenblatt");
+  }
+  isGeni() {
+    return this.sourStartsWith("geni");
+  }
+  isAncestry() {
+    return this.sourStartsWith("ancestry");
+  }
+  isMyHeritage() {
+    return this.sourStartsWith("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() {
+    return this.getSourceHeads().some((head) => {
+      const sourName = get(head, "SOUR.NAME.value");
+      return sourName === "FamilySearch API";
     });
   }
-  reduce(iterate, initialValue) {
-    return this.entries().reduce((acc, [key, item], index) => {
-      return iterate(acc, item, key, index);
-    }, initialValue);
+  isGNO2GED() {
+    return this.getSourceHeads().some((head) => {
+      const sour = get(head, "SOUR.value");
+      return sour === "GNO2GED";
+    });
   }
-  filter(filters, ClassName = _List) {
-    const newList = new ClassName();
-    const isIterator = typeof filters === "function";
-    this.entries().forEach(([itemId, item], index) => {
-      if (isIterator) {
-        filters(item, itemId, index) && newList.item(itemId, item);
-        return;
-      }
-      if (!Object.keys(filters).length || Object.entries(filters).every(([key, value]) => {
-        let itemValue;
-        if (key === "id") {
-          itemValue = item.toProp("id");
-        } else {
-          itemValue = item.toProp(key)?.toValue();
-        }
-        if (Array.isArray(value)) {
-          return value.includes(itemValue);
-        }
-        return itemValue === value;
-      })) {
-        newList.item(itemId, item);
+  getAncestryTreeId() {
+    return this.getFromSourceHeads("SOUR._TREE.RIN.value") || (get(this, "HEAD.SOUR._TREE.RIN.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.RIN.value"));
+  }
+  getMyHeritageTreeId() {
+    return this.getFromSourceHeads("_EXPORTED_FROM_SITE_ID.value") || (get(this, "HEAD._EXPORTED_FROM_SITE_ID.value") || get(this.getGedcom(), "HEAD._EXPORTED_FROM_SITE_ID.value"));
+  }
+  getTreeId() {
+    if (this?.isAncestry()) {
+      const id = this.getAncestryTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isMyHeritage()) {
+      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() {
+    return this.getFromSourceHeads("SOUR._TREE.value") || (get(this, "HEAD.SOUR._TREE.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.value"));
+  }
+  getMyHeritageTreeName() {
+    const path = "HEAD.FILE.value";
+    const treeDetails = get(this, path) || get(this.getGedcom(), path);
+    return treeDetails?.match(
+      /Exported by MyHeritage.com from (?<tree>.+) in.+$/
+    )?.groups?.tree;
+  }
+  getFamilySearchTreeId() {
+    const rin = this.getFromSourceHeads("SOUR._TREE.RIN.value") || get(this, "HEAD.SOUR._TREE.RIN.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.RIN.value");
+    if (rin) {
+      return rin;
+    }
+    return "familysearch";
+  }
+  getFamilySearchTreeName() {
+    const treeName = this.getFromSourceHeads("SOUR._TREE.value") || 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 newList;
+    }
+    return void 0;
   }
-  find(filters, _ClassName = _List) {
-    let foundItem;
-    const isIterator = typeof filters === "function";
-    this.entries().find(([itemId, item], index) => {
-      if (isIterator) {
-        if (filters(item, itemId, index)) {
-          foundItem = item;
-          return true;
-        }
-        return false;
+  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];
       }
-      if (!Object.keys(filters).length || Object.entries(filters).every(([key, value]) => {
-        let itemValue;
-        if (key === "id") {
-          itemValue = item.toProp("id");
-        } else {
-          itemValue = item.toProp(key)?.toValue();
-        }
-        if (Array.isArray(value)) {
-          return value.includes(itemValue);
-        }
-        return itemValue === value;
-      })) {
-        foundItem = item;
-        return true;
+    }
+    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 false;
-    });
-    return foundItem;
+    }
+    return void 0;
   }
-  orderBy(orders, ClassName = _List) {
-    const newList = new ClassName();
-    const isIterator = typeof orders === "function";
-    if (!isIterator && (!orders || !Object.keys(orders).length)) {
-      return newList.merge(this);
+  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;
     }
-    const sortedItems = this.entries().toSorted(
-      ([itemAId, itemA], [itemBId, itemB]) => {
-        if (isIterator) {
-          return orders(itemA, itemAId, itemB, itemBId);
-        }
-        const [key, { direction, getter }] = Object.entries(
-          typeof orders === "string" ? { [orders]: { direction: "ASC" } } : orders
-        )[0];
-        const rawA = itemA.get(key);
-        const rawB = itemB.get(key);
-        let valueA = rawA?.toValue();
-        let valueB = rawB?.toValue();
-        if (getter && typeof getter === "function") {
-          valueA = getter(valueA, rawA);
-          valueB = getter(valueB, rawB);
-        }
-        let sortValue2 = 0;
-        if (!valueA && valueA !== 0 && !valueB && valueB !== 0) {
-          sortValue2 = 0;
-        } else if (!valueB && valueB !== 0) {
-          sortValue2 = 1;
-        } else if (!valueA && valueA !== 0) {
-          sortValue2 = -1;
-        } else if (valueA < valueB) {
-          sortValue2 = -1;
-        } else if (valueA > valueB) {
-          sortValue2 = 1;
-        }
-        return sortValue2 * (direction === "DESC" ? -1 : 1);
+    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]}`;
       }
-    );
-    sortedItems.forEach(([key, value]) => {
-      newList.item(key, value);
-    });
-    return newList;
+    }
+    return `${prefix}_${this._gedcom?.refcount || "unknown"}`;
   }
-  groupBy(groups, sort, minOccurance = -1, lessOccuranceLabel = "Appearing less than 5 times", ClassName = _List) {
-    const groupped = {};
-    const isIterator = typeof groups === "function";
-    if (!isIterator && (!groups || !Object.keys(groups).length)) {
-      groupped.Unknown = new ClassName().merge(this);
-      groupped.Unknown.marker = "Unknown";
-      return groupped;
+  /**
+   * 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}`;
     }
-    this.forEach((item, itemId) => {
-      const group = [];
-      if (isIterator) {
-        const newGroups = groups(item, itemId);
-        group.push(
-          ...Array.isArray(newGroups) ? newGroups : [newGroups]
-        );
-      } else {
-        const [key, { getter }] = Object.entries(
-          typeof groups === "string" ? { [groups]: {} } : groups
-        )[0];
-        const raw = item.get(key)?.index(0);
-        let value = raw?.toValue();
-        if (getter && typeof getter === "function") {
-          value = getter(value, raw);
-        }
-        if (value) {
-          group.push(value);
-        }
+    const sourName = this.getFromSourceHeads("SOUR.NAME.value") || get(this, "HEAD.SOUR.NAME.value") || get(this.getGedcom(), "HEAD.SOUR.NAME.value");
+    if (sourName) {
+      return `${prefix}${sourName}`;
+    }
+    const sourValue = this.getFromSourceHeads("SOUR.value") || get(this, "HEAD.SOUR.value") || get(this.getGedcom(), "HEAD.SOUR.value");
+    if (sourValue) {
+      return `${prefix}${sourValue}`;
+    }
+    return `${prefix}Unknown Tree`;
+  }
+  getTreeName() {
+    if (this?.isAncestry()) {
+      const name = this.getAncestryTreeName();
+      if (name) return name;
+    }
+    if (this?.isMyHeritage()) {
+      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) => {
+  return new Proxy(target, {
+    get(t, prop, receiver) {
+      if (prop === "unwrapped") {
+        return target;
       }
-      if (!group.length) {
-        group.push("Unknown");
+      if (prop in t) {
+        return Reflect.get(t, prop, receiver);
       }
-      group.forEach((g) => {
-        const newGroup = typeof g === "string" ? { group: g } : g;
-        if (!groupped[newGroup.group]) {
-          groupped[newGroup.group] = new ClassName();
-          groupped[newGroup.group].marker = newGroup.marker ?? newGroup.group;
-        }
-        groupped[newGroup.group]?.append(item);
-      });
-    });
-    if (sort) {
-      return Object.entries(groupped).toSorted(([ak, a], [bk, b]) => {
-        if (typeof sort === "function") {
-          return sort(a, ak, b, bk);
-        }
-        if (ak === "Unknown") {
-          return 1;
-        }
-        if (bk === "Unknown") {
-          return -1;
-        }
-        if (sort === "group") {
-          return ak.localeCompare(bk);
-        }
-        return (b?.length ?? 0) - (a?.length ?? 0);
-      }).reduce((acc, [key, value]) => {
-        if (minOccurance > -1 && (value?.length ?? 0) < minOccurance) {
-          const otherKey = lessOccuranceLabel;
-          acc[otherKey] = acc[otherKey] && value ? acc[otherKey].merge(value) : value;
-        } else {
-          acc[key] = value;
+      if (!isOnlyMainProp(prop)) {
+        const ref = t.ref;
+        if (ref && prop in ref) {
+          return Reflect.get(ref, prop, receiver);
         }
-        return acc;
-      }, {});
+      }
     }
-    return groupped;
+  });
+};
+var createCommon = (gedcom, id, main, parent) => {
+  return createProxy(
+    new Common(gedcom, id, main, parent)
+  );
+};
+var isOnlyMainProp = (key) => {
+  return key === "_gedcom" || key === "_main" || key === "_parent" || key === "_uniqueId" || key === "_type" || key === "_refs" || key === "id" || key === "_id";
+};
+var isValidKey = (common, key) => {
+  const prop = get(common, key);
+  return key !== "_gedcom" && key !== "_main" && key !== "_parent" && key !== "_uniqueId" && key !== "_refs" && key !== "_type" && !(typeof key === "string" && isGedcomTrailerTag(key)) && (key === "id" || key === "_id" || key === "value" || key === "_value" || prop instanceof Common || prop instanceof List);
+};
+var getValidKeys = (common) => {
+  return Object.keys(common).filter((key) => {
+    return isValidKey(common, key);
+  });
+};
+var getValidTag = (tag) => {
+  return tag.replace(/^@@/, "");
+};
+var getListTag = (tag) => {
+  return `@@${tag}`;
+};
+var isId = (string) => {
+  return ID_REG.test(string);
+};
+var idGetter = (id) => {
+  if (id === void 0) {
+    return void 0;
+  }
+  let newId = `${id}`;
+  const parts = newId?.match(ID_GETTER_REG)?.groups;
+  if (!parts?.at && !parts?.letter) {
+    newId = `@U${newId}`;
+  } else if (!parts.at) {
+    newId = `@${newId}`;
+  } else if (!parts.letter) {
+    newId = newId.replace(/^@/, "@U");
+  }
+  if (!newId.endsWith("@")) {
+    newId = `${newId}@`;
+  }
+  return newId;
+};
+
+// src/utils/fact-edit.ts
+var SINGLETON_TAGS = /* @__PURE__ */ new Set(["BIRT", "DEAT", "SSN", "SEX", "DSCR"]);
+var firstRecord = (node) => {
+  if (!node) {
+    return void 0;
+  }
+  if (node instanceof List) {
+    return node.index(0);
+  }
+  return node.index(0) ?? node;
+};
+var setDateOn = (gedcom, owner, parent, date) => {
+  const trimmed = date.trim();
+  if (!trimmed) {
+    return;
+  }
+  let dateNode = parent.get("DATE");
+  if (!dateNode || dateNode instanceof List) {
+    dateNode = createCommonDate(gedcom, void 0, owner, parent);
+    dateNode.type = "DATE";
+    parent.set("DATE", dateNode);
+  }
+  dateNode.value = trimmed;
+};
+var fillFact = (gedcom, owner, event, input) => {
+  if (input.value?.trim()) {
+    event.value = input.value.trim();
+  }
+  if (input.type?.trim()) {
+    event.set("TYPE", input.type.trim());
+  }
+  if (input.date) {
+    setDateOn(gedcom, owner, event, input.date);
+  }
+  if (input.place?.trim()) {
+    event.set("PLAC", input.place.trim());
+  }
+  if (input.note?.trim()) {
+    event.set("NOTE", input.note.trim());
+  }
+};
+var addIndividualFact = (indi, input) => {
+  const gedcom = indi.getGedcom();
+  if (!gedcom) {
+    return void 0;
+  }
+  const tag = input.tag;
+  let event = SINGLETON_TAGS.has(tag) ? firstRecord(indi.get(tag)) : void 0;
+  if (!event) {
+    event = createCommon(gedcom, void 0, indi);
+    event.type = tag;
+    if (SINGLETON_TAGS.has(tag)) {
+      indi.set(tag, event);
+    } else {
+      indi.assign(tag, event);
+    }
+  }
+  fillFact(gedcom, indi, event, input);
+  return event;
+};
+var addFamilyFact = (fam, input) => {
+  const gedcom = fam.getGedcom();
+  if (!gedcom) {
+    return void 0;
+  }
+  const event = createCommon(gedcom, void 0, fam);
+  event.type = input.tag;
+  fam.assign(input.tag, event);
+  fillFact(gedcom, fam, event, input);
+  return event;
+};
+
+// src/utils/family-edit.ts
+var PEDIGREE_VALUES = [
+  "birth" /* BIRTH */,
+  "adopted" /* ADOPTED */,
+  "foster" /* FOSTER */,
+  "step" /* STEP */,
+  "sealing" /* SEALING */
+];
+var toGedcomPedigree = (value) => {
+  const normalized = String(value || "birth" /* BIRTH */).toLowerCase();
+  if (normalized === "biological" /* BIOLOGICAL */ || normalized === "birth" /* BIRTH */) {
+    return "birth" /* BIRTH */;
+  }
+  const match = PEDIGREE_VALUES.find((item) => item === normalized);
+  return match ?? "birth" /* BIRTH */;
+};
+var pointerIds = (tag) => {
+  if (!tag) {
+    return [];
+  }
+  if (tag instanceof List) {
+    return tag.values().map((item) => item?.toValue?.()).filter((value2) => !!value2);
+  }
+  const value = tag.toValue?.();
+  return value ? [String(value)] : [];
+};
+var firstPointerId = (tag) => pointerIds(tag)[0];
+var makePointer = (gedcom, parent, value, refType) => {
+  const pointer = createCommon(gedcom, void 0, parent);
+  pointer.value = value;
+  pointer.refType = refType;
+  return pointer;
+};
+var familyHasParent = (fam, indiId) => pointerIds(fam.get("HUSB")).includes(indiId) || pointerIds(fam.get("WIFE")).includes(indiId);
+var familyHasChild = (fam, indiId) => pointerIds(fam.get("CHIL")).includes(indiId);
+var spouseTagFor = (indi, fam) => {
+  const husbId = firstPointerId(fam.get("HUSB"));
+  const wifeId = firstPointerId(fam.get("WIFE"));
+  if (husbId === indi.id) {
+    return "HUSB";
+  }
+  if (wifeId === indi.id) {
+    return "WIFE";
+  }
+  if (indi.isFemale()) {
+    return wifeId && wifeId !== indi.id ? "HUSB" : "WIFE";
+  }
+  if (indi.isMale()) {
+    return husbId && husbId !== indi.id ? "WIFE" : "HUSB";
+  }
+  return husbId ? "WIFE" : "HUSB";
+};
+var canAttachAsSpouse = (fam, indi) => {
+  if (!indi.id) {
+    return false;
+  }
+  if (familyHasParent(fam, indi.id)) {
+    return true;
+  }
+  const tag = spouseTagFor(indi, fam);
+  const occupied = firstPointerId(fam.get(tag));
+  return !occupied || occupied === indi.id;
+};
+var pointerByValue = (tag, id) => {
+  if (!tag) {
+    return void 0;
+  }
+  const fromValues = tag.toValueList?.().item(id);
+  if (fromValues) {
+    return fromValues;
+  }
+  return tag.toList()?.values().find((item) => item?.toValue?.() === id);
+};
+var setChildPedigree = (fam, child, pedigree, parent) => {
+  if (!fam.id || !child.id) {
+    return;
+  }
+  const pedi = toGedcomPedigree(pedigree);
+  const famc = pointerByValue(child.get("FAMC"), fam.id);
+  if (famc) {
+    famc.set("PEDI", pedi);
+  }
+  const chil = pointerByValue(fam.get("CHIL"), child.id);
+  if (!chil) {
+    return;
+  }
+  const setFather = !parent || parent.isMale() || parent.isUnknownSex();
+  const setMother = !parent || parent.isFemale() || parent.isUnknownSex();
+  if (setFather) {
+    chil.set("_FREL", pedi);
+  }
+  if (setMother) {
+    chil.set("_MREL", pedi);
   }
-  findIndex(item) {
-    if (!item?.id) {
-      return -1;
-    }
-    return this.keys().findIndex((key) => key === item.id);
+};
+var attachSpouseToFamily = (fam, indi) => {
+  const gedcom = fam.getGedcom() ?? indi.getGedcom();
+  if (!indi.id || !fam.id || !gedcom) {
+    return false;
   }
-  getItems() {
-    return this.items;
+  if (!canAttachAsSpouse(fam, indi)) {
+    return false;
   }
-  toJson(tag, options) {
-    const json = this.toObject(tag, options);
-    return JSON.stringify(json);
+  const tag = spouseTagFor(indi, fam);
+  if (firstPointerId(fam.get(tag)) !== indi.id) {
+    fam.set(tag, makePointer(gedcom, fam, indi.id, "INDI"));
   }
-  toObject(tag, options) {
-    const json = {};
-    this.entries().forEach(([_, item]) => {
-      const validTag = getValidTag(tag);
-      if (json[validTag]) {
-        if (!Array.isArray(json[validTag])) {
-          json[validTag] = [json[validTag]];
-        }
-        json[validTag].push(
-          item.toObject(validTag, options)
-        );
-      } else {
-        json[validTag] = item.toObject(
-          validTag,
-          options
-        );
-      }
-    });
-    return json;
+  indi.assign("FAMS", makePointer(gedcom, indi, fam.id, "FAM"), true);
+  return true;
+};
+var attachChildToFamily = (fam, child, pedigree, parent) => {
+  const gedcom = fam.getGedcom() ?? child.getGedcom();
+  if (!child.id || !fam.id || !gedcom) {
+    return false;
   }
-  toGedcom(tag, level = 0, options) {
-    const gedcom = this.toGedcomLines(tag, level, options);
-    return gedcom.join("\n");
+  if (!familyHasChild(fam, child.id)) {
+    fam.assign("CHIL", makePointer(gedcom, fam, child.id, "INDI"), true);
   }
-  toGedcomLines(tag, level = 0, options) {
-    const gedcom = [];
-    this.entries().forEach(([_, item]) => {
-      const validTag = getValidTag(tag);
-      const validKey = item.id;
-      const validValue = validKey ? validTag : item.exportValue();
-      gedcom.push(
-        `${level} ${validKey || validTag}${validValue ? ` ${validValue}` : ""}`
-      );
-      gedcom.push(
-        ...item.toGedcomLines(
-          validTag,
-          level + 1,
-          options
-        )
-      );
-    });
-    return gedcom;
+  const existingFamc = pointerByValue(child.get("FAMC"), fam.id);
+  if (!existingFamc) {
+    child.assign("FAMC", makePointer(gedcom, child, fam.id, "FAM"), true);
   }
-  toValue() {
-    const propList = new _List();
-    this.entries().forEach(([key, item]) => {
-      propList.item(key, item?.toValue());
-    });
-    return propList;
+  setChildPedigree(fam, child, pedigree, parent);
+  return true;
+};
+var findReusableParentChildFamily = (parent, child) => {
+  if (!parent.id || !child.id) {
+    return void 0;
   }
-  // @deprecated use get instead
-  toProp(tag) {
-    return this.get(tag);
+  let reusableFamc;
+  let already = false;
+  child.getFamilies("FAMC")?.forEach((fam) => {
+    if (!fam) {
+      return;
+    }
+    if (familyHasParent(fam, parent.id) && familyHasChild(fam, child.id)) {
+      already = true;
+      return;
+    }
+    if (!reusableFamc && canAttachAsSpouse(fam, parent)) {
+      reusableFamc = fam;
+    }
+  });
+  if (already) {
+    return "already";
   }
-  toList() {
-    return new _List().concat(this.items);
+  if (reusableFamc) {
+    return reusableFamc;
   }
-  toValueList() {
-    const newList = new _List();
-    this.values().forEach((value) => {
-      value.value && newList.item(value.value, value);
-    });
-    return newList;
+  const parentFams = [];
+  parent.getFamilies("FAMS")?.forEach((fam) => {
+    if (fam) {
+      parentFams.push(fam);
+    }
+  });
+  if (parentFams.length === 1) {
+    return parentFams[0];
   }
+  return void 0;
+};
+
+// src/utils/get-family-with.ts
+var getFamilyWith = (person1, person2, famType = "FAMS") => {
+  return person1?.get(famType)?.toValueList().find((fam) => {
+    const family = fam;
+    return famType === "FAMC" || family?.HUSB?.value === person2 || family?.WIFE?.value === person2;
+  });
 };
 
 // src/utils/get-places.ts
@@ -2218,6 +2488,31 @@ var Fam = class extends Common {
   getParents() {
     return this.getHusband().copy().merge(this.getWife());
   }
+  hasParent(indi) {
+    const indiId = typeof indi === "string" ? indi : indi?.id;
+    return !!indiId && familyHasParent(this, indiId);
+  }
+  hasChild(indi) {
+    const indiId = typeof indi === "string" ? indi : indi?.id;
+    return !!indiId && familyHasChild(this, indiId);
+  }
+  canAddSpouse(indi) {
+    return canAttachAsSpouse(this, indi);
+  }
+  addSpouse(indi) {
+    return attachSpouseToFamily(this, indi);
+  }
+  addChild(child, pedigree, parent) {
+    return attachChildToFamily(
+      this,
+      child,
+      pedigree,
+      parent
+    );
+  }
+  addFact(input) {
+    return addFamilyFact(this, input);
+  }
   toList() {
     return new Families().concat(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2318,19 +2613,51 @@ var ALLOWED_FACTS = [
   "OCCU",
   "OCCUPATIONS",
   "RESI",
+  "BIRT",
+  "DEAT",
   "BAPT",
+  "BAPM",
   "CHRI",
   "CHR",
+  "CHRA",
   "BURI",
-  "EDUC",
+  "CREM",
+  "ADOP",
+  "BARM",
+  "BASM",
+  "BLES",
+  "CONF",
+  "FCOM",
+  "ORDN",
+  "NATU",
+  "EMIG",
+  "IMMI",
+  "CENS",
+  "PROB",
+  "WILL",
   "GRAD",
+  "RETI",
+  "EDUC",
   "DIV",
-  "IMMI",
   "RELI",
+  "CAST",
+  "DSCR",
+  "NATI",
+  "PROP",
+  "SSN",
+  "TITL",
+  "ADDR",
+  "BAPL",
+  "CONL",
+  "ENDL",
+  "SLGC",
   "_MILT",
   "_MILTID",
   "FACT",
-  "_ORIG"
+  "_ORIG",
+  "_WLNK",
+  "WWW",
+  "URL"
 ];
 var DISALLOWED_CUSTOM_FACTS = ["DNA Test", "Newspaper"];
 var CustomFactRenderers = {
@@ -2874,7 +3201,7 @@ var Indi = class extends Common {
     return result;
   }
   ancestryLink() {
-    const www = this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
+    const www = this.getFromSourceHeads("SOUR.CORP.WWW.value") || this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
     const tree = this.getAncestryTreeId();
     if (this.id) {
       return `https://${www}/family-tree/person/tree/${tree}/person/${this.id.replace(
@@ -2886,7 +3213,7 @@ var Indi = class extends Common {
   async ancestryMedia(namespace) {
     const list = {};
     const objeList = this.get("OBJE")?.toList().copy();
-    const www = this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
+    const www = this.getFromSourceHeads("SOUR.CORP.WWW.value") || this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
     const tree = this.getAncestryTreeId();
     if (objeList) {
       await Promise.all(
@@ -2946,7 +3273,7 @@ var Indi = class extends Common {
     return list;
   }
   myheritageLink(poolId = 0) {
-    const www = this._gedcom?.HEAD?.SOUR?.CORP?.value?.toLowerCase().replace(/^www\./gi, "");
+    const www = (this.getFromSourceHeads("SOUR.CORP.value") || this._gedcom?.HEAD?.SOUR?.CORP?.value)?.toLowerCase().replace(/^www\./gi, "");
     const site = this.getMyHeritageTreeId();
     const file = this._gedcom?.HEAD?.get("FILE")?.toValue()?.match(/Exported by MyHeritage.com from .+ in (?<site>.+) on .+$/)?.groups?.site;
     const normalizedFile = file?.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-");
@@ -3467,6 +3794,57 @@ var Indi = class extends Common {
   isUnknownSex() {
     return !this.isMale() && !this.isFemale();
   }
+  addSpouse(other) {
+    if (!this.id || !other?.id || this.id === other.id || !this._gedcom) {
+      return void 0;
+    }
+    const existing = getFamilyWith(this, other.id);
+    if (existing) {
+      return existing;
+    }
+    const fam = this._gedcom.createFamily();
+    if (!fam.addSpouse(this) || !fam.addSpouse(other)) {
+      return void 0;
+    }
+    return fam;
+  }
+  addChild(child, pedigree) {
+    if (!this.id || !child?.id || this.id === child.id || !this._gedcom) {
+      return void 0;
+    }
+    const existing = findReusableParentChildFamily(
+      this,
+      child
+    );
+    if (existing === "already") {
+      const fam2 = child.getFamilies("FAMC")?.find(
+        (item) => !!item && item.hasParent(this.id) && item.hasChild(child.id)
+      );
+      if (fam2) {
+        setChildPedigree(
+          fam2,
+          child,
+          pedigree,
+          this
+        );
+      }
+      return fam2;
+    }
+    const fam = existing ?? this._gedcom.createFamily();
+    if (!fam.addSpouse(this)) {
+      return void 0;
+    }
+    if (!fam.addChild(child, pedigree, this)) {
+      return void 0;
+    }
+    return fam;
+  }
+  addParent(parent, pedigree) {
+    return parent.addChild(this, pedigree);
+  }
+  addFact(input) {
+    return addIndividualFact(this, input);
+  }
   getParentType(id) {
     let indi;
     if (typeof id === "string" || typeof id === "number") {
@@ -3667,7 +4045,9 @@ var Indi = class extends Common {
           }
         }
         if (kinship !== "child" || !breakAfterSpouse) {
-          indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(indi.getFathers().copy().merge(indi.getMothers())).forEach((relative) => {
+          indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(
+            indi.getFathers().copy().merge(indi.getMothers())
+          ).forEach((relative) => {
             if (!visited.has(relative)) {
               const currentRelation = indi.getParentType(relative);
               const isNonBiological = !!currentRelation && currentRelation !== "biological" /* BIOLOGICAL */;
@@ -5962,6 +6342,249 @@ var KinshipTranslatorEs = class extends KinshipTranslatorBasic {
   }
 };
 
+// src/kinship-translator/patterns.ru.ts
+var InLawsRu = {
+  "\u0441\u0443\u043F\u0440\u0443\u0433(?:\u0430)? (\u0440\u0435\u0431\u0451\u043D\u043A\u0430|\u0434\u043E\u0447\u0435\u0440\u0438|\u0441\u044B\u043D\u0430)": "\u0437\u044F\u0442\u044C/\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "\u0436\u0435\u043D\u0430 (\u0440\u0435\u0431\u0451\u043D\u043A\u0430|\u0434\u043E\u0447\u0435\u0440\u0438|\u0441\u044B\u043D\u0430)": "\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "\u043C\u0443\u0436 (\u0440\u0435\u0431\u0451\u043D\u043A\u0430|\u0434\u043E\u0447\u0435\u0440\u0438|\u0441\u044B\u043D\u0430)": "\u0437\u044F\u0442\u044C",
+  "\u043C\u0430\u0442\u044C (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0442\u0451\u0449\u0430",
+  "\u043E\u0442\u0435\u0446 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0442\u0435\u0441\u0442\u044C",
+  "\u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044C (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0442\u0435\u0441\u0442\u044C/\u0442\u0451\u0449\u0430",
+  "\u0436\u0435\u043D\u0430 (\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?(\u0431\u0440\u0430\u0442\u0430|\u0441\u0435\u0441\u0442\u0440\u044B|\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430)": "\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "\u043C\u0443\u0436 (\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?(\u0431\u0440\u0430\u0442\u0430|\u0441\u0435\u0441\u0442\u0440\u044B|\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430)": "\u0437\u044F\u0442\u044C",
+  "\u0441\u0443\u043F\u0440\u0443\u0433(?:\u0430)? (\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?(\u0431\u0440\u0430\u0442\u0430|\u0441\u0435\u0441\u0442\u0440\u044B|\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430)": "\u0437\u044F\u0442\u044C/\u043D\u0435\u0432\u0435\u0441\u0442\u043A\u0430",
+  "(\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?\u0441\u0435\u0441\u0442\u0440\u0430 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0437\u043E\u043B\u043E\u0432\u043A\u0430",
+  "(\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?\u0431\u0440\u0430\u0442 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0448\u0443\u0440\u0438\u043D",
+  "(\u0441\u0432\u043E\u0434\u043D(?:\u044B\u0439|\u0430\u044F) )?\u0441\u0438\u0431\u043B\u0438\u043D\u0433 (\u0441\u0443\u043F\u0440\u0443\u0433\u0430|\u0436\u0435\u043D\u044B|\u043C\u0443\u0436\u0430)": "\u0448\u0443\u0440\u0438\u043D/\u0437\u043E\u043B\u043E\u0432\u043A\u0430"
+};
+
+// src/kinship-translator/kinship-translator.ru.ts
+var GENITIVE = {
+  \u0441\u044B\u043D: "\u0441\u044B\u043D\u0430",
+  \u0434\u043E\u0447\u044C: "\u0434\u043E\u0447\u0435\u0440\u0438",
+  \u0440\u0435\u0431\u0451\u043D\u043E\u043A: "\u0440\u0435\u0431\u0451\u043D\u043A\u0430",
+  \u0431\u0440\u0430\u0442: "\u0431\u0440\u0430\u0442\u0430",
+  \u0441\u0435\u0441\u0442\u0440\u0430: "\u0441\u0435\u0441\u0442\u0440\u044B",
+  \u0441\u0438\u0431\u043B\u0438\u043D\u0433: "\u0441\u0438\u0431\u043B\u0438\u043D\u0433\u0430",
+  \u043E\u0442\u0435\u0446: "\u043E\u0442\u0446\u0430",
+  \u043C\u0430\u0442\u044C: "\u043C\u0430\u0442\u0435\u0440\u0438",
+  \u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044C: "\u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044F",
+  \u043C\u0443\u0436: "\u043C\u0443\u0436\u0430",
+  \u0436\u0435\u043D\u0430: "\u0436\u0435\u043D\u044B",
+  \u0441\u0443\u043F\u0440\u0443\u0433: "\u0441\u0443\u043F\u0440\u0443\u0433\u0430",
+  \u0441\u0443\u043F\u0440\u0443\u0433\u0430: "\u0441\u0443\u043F\u0440\u0443\u0433\u0438"
+};
+var toGenitive = (word) => GENITIVE[word] ?? word;
+var cousinWord = (degree, sex) => {
+  const stem = degree <= 1 ? "\u0434\u0432\u043E\u044E\u0440\u043E\u0434\u043D" : degree === 2 ? "\u0442\u0440\u043E\u044E\u0440\u043E\u0434\u043D" : degree === 3 ? "\u0447\u0435\u0442\u0432\u0435\u0440\u043E\u044E\u0440\u043E\u0434\u043D" : `${degree + 1}-\u044E\u0440\u043E\u0434\u043D`;
+  if (sex === "m") {
+    return `${stem}\u044B\u0439 \u0431\u0440\u0430\u0442`;
+  }
+  if (sex === "f") {
+    return `${stem}\u0430\u044F \u0441\u0435\u0441\u0442\u0440\u0430`;
+  }
+  return `${stem}\u044B\u0439 \u0431\u0440\u0430\u0442/\u0441\u0435\u0441\u0442\u0440\u0430`;
+};
+var praRepeat = (count) => count > 0 ? "\u043F\u0440\u0430".repeat(count) : "";
+var sexOf = (person) => {
+  if (person?.isMale?.()) {
+    return "m";
+  }
+  if (person?.isFemale?.()) {
+    return "f";
+  }
+  return "n";
+};
+var KinshipTranslatorRu = class extends KinshipTranslatorBasic {
+  indirect() {
+    let degree = Math.abs(this.pathN?.degree ?? 0);
+    if (degree > 0) {
+      degree = degree - 1;
+    }
+    return cousinWord(degree, sexOf(this.personN));
+  }
+  removal() {
+    const level = this.pathN?.level ?? 0;
+    let degree = Math.abs(this.pathN?.degree ?? 0);
+    if (degree > 0) {
+      degree = degree - 1;
+    }
+    if (!degree) {
+      return level < 0 ? this.nibling() : this.auncle();
+    }
+    const removed = Math.abs(level);
+    return `${cousinWord(degree, sexOf(this.personN))} (${removed}\xD7 \u0447\u0435\u0440\u0435\u0437 \u043F\u043E\u043A\u043E\u043B\u0435\u043D\u0438\u0435)`;
+  }
+  auncle() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const pra = praRepeat(Math.max(0, level - 2));
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return `${pra}\u0434\u044F\u0434\u044F`;
+    }
+    if (sex === "f") {
+      return `${pra}\u0442\u0451\u0442\u044F`;
+    }
+    return `${pra}\u0434\u044F\u0434\u044F/\u0442\u0451\u0442\u044F`;
+  }
+  nibling() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const pra = praRepeat(Math.max(0, level - 2));
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return `${pra}\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u043A`;
+    }
+    if (sex === "f") {
+      return `${pra}\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u0446\u0430`;
+    }
+    return `${pra}\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u043A/\u043F\u043B\u0435\u043C\u044F\u043D\u043D\u0438\u0446\u0430`;
+  }
+  parent() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const sex = sexOf(this.personN);
+    if (level <= 1) {
+      if (sex === "m") {
+        return "\u043E\u0442\u0435\u0446";
+      }
+      if (sex === "f") {
+        return "\u043C\u0430\u0442\u044C";
+      }
+      return "\u0440\u043E\u0434\u0438\u0442\u0435\u043B\u044C";
+    }
+    if (level === 2) {
+      if (sex === "m") {
+        return "\u0434\u0435\u0434";
+      }
+      if (sex === "f") {
+        return "\u0431\u0430\u0431\u0443\u0448\u043A\u0430";
+      }
+      return "\u0434\u0435\u0434/\u0431\u0430\u0431\u0443\u0448\u043A\u0430";
+    }
+    const pra = praRepeat(level - 2);
+    if (sex === "m") {
+      return `${pra}\u0434\u0435\u0434`;
+    }
+    if (sex === "f") {
+      return `${pra}\u0431\u0430\u0431\u0443\u0448\u043A\u0430`;
+    }
+    return `${pra}\u0434\u0435\u0434/\u0431\u0430\u0431\u0443\u0448\u043A\u0430`;
+  }
+  child() {
+    const level = Math.abs(this.pathN?.level ?? 0);
+    const sex = sexOf(this.personN);
+    if (level <= 1) {
+      if (sex === "m") {
+        return "\u0441\u044B\u043D";
+      }
+      if (sex === "f") {
+        return "\u0434\u043E\u0447\u044C";
+      }
+      return "\u0440\u0435\u0431\u0451\u043D\u043E\u043A";
+    }
+    if (level === 2) {
+      if (sex === "m") {
+        return "\u0432\u043D\u0443\u043A";
+      }
+      if (sex === "f") {
+        return "\u0432\u043D\u0443\u0447\u043A\u0430";
+      }
+      return "\u0432\u043D\u0443\u043A/\u0432\u043D\u0443\u0447\u043A\u0430";
+    }
+    const pra = praRepeat(level - 2);
+    if (sex === "m") {
+      return `${pra}\u0432\u043D\u0443\u043A`;
+    }
+    if (sex === "f") {
+      return `${pra}\u0432\u043D\u0443\u0447\u043A\u0430`;
+    }
+    return `${pra}\u0432\u043D\u0443\u043A/\u0432\u043D\u0443\u0447\u043A\u0430`;
+  }
+  sibling() {
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return "\u0431\u0440\u0430\u0442";
+    }
+    if (sex === "f") {
+      return "\u0441\u0435\u0441\u0442\u0440\u0430";
+    }
+    return "\u0441\u0438\u0431\u043B\u0438\u043D\u0433";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    if (/сестра|дочь|мать|тётя|бабушка|жена|племянница|внучка/.test(
+      relation
+    )) {
+      return `\u0441\u0432\u043E\u0434\u043D\u0430\u044F ${relation}`;
+    }
+    return `\u0441\u0432\u043E\u0434\u043D\u044B\u0439 ${relation}`;
+  }
+  spouse() {
+    const sex = sexOf(this.personN);
+    if (sex === "m") {
+      return "\u043C\u0443\u0436";
+    }
+    if (sex === "f") {
+      return "\u0436\u0435\u043D\u0430";
+    }
+    return "\u0441\u0443\u043F\u0440\u0443\u0433";
+  }
+  ofSpouse(relation) {
+    if (!relation) {
+      return "";
+    }
+    const spouse = this.path?.[1].indi;
+    const sex = sexOf(spouse);
+    const spouseType = sex === "m" ? "\u043C\u0443\u0436" : sex === "f" ? "\u0436\u0435\u043D\u0430" : "\u0441\u0443\u043F\u0440\u0443\u0433";
+    return `${relation} ${toGenitive(spouseType)}`;
+  }
+  spouseOf(relation) {
+    if (!relation) {
+      return "";
+    }
+    const spouse = this.path?.[this.path.length - 1].indi;
+    const sex = sexOf(spouse);
+    const spouseType = sex === "m" ? "\u043C\u0443\u0436" : sex === "f" ? "\u0436\u0435\u043D\u0430" : "\u0441\u0443\u043F\u0440\u0443\u0433";
+    return `${spouseType} ${toGenitive(relation)}`;
+  }
+  of(relation) {
+    const formattedName = nameFormatter(this.path?.[0]?.indi, {
+      nameOrder: "first-last"
+    });
+    let name = formattedName.inOrder.filter(Boolean).join(" ");
+    if (this.displayName === "none") {
+      name = "";
+    } else if (this.displayName === "givenname") {
+      name = formattedName.givenname;
+    } else if (this.displayName === "surname") {
+      name = `${formattedName.surname}`;
+    }
+    if (!name || !relation) {
+      return relation ?? "";
+    }
+    return `${name}: ${relation}`;
+  }
+  inLaw(relation) {
+    let inLawRelation = relation;
+    Object.keys(InLawsRu).find((pattern) => {
+      const regex = new RegExp(`^${pattern}$`);
+      if (relation?.match(regex)) {
+        inLawRelation = InLawsRu[pattern];
+        return true;
+      }
+      return false;
+    });
+    return inLawRelation ?? "";
+  }
+  relationType(relation) {
+    if (!relation || !this.pathN?.relation) {
+      return relation ?? "";
+    }
+    return `${this.pathN.relation} ${relation}`;
+  }
+};
+
 // src/kinship-translator/kinship-translator.ts
 var KinshipTranslator = class {
   constructor(person1, person2, lang = "en", entirePath, displayName = "givenname") {
@@ -6318,14 +6941,6 @@ var isCommonDate = (value) => {
   return !!value && value !== null && typeof value === "object" && "_date" in value;
 };
 
-// src/utils/get-family-with.ts
-var getFamilyWith = (person1, person2, famType = "FAMS") => {
-  return person1?.get(famType)?.toValueList().find((fam) => {
-    const family = fam;
-    return famType === "FAMC" || family?.HUSB?.value === person2 || family?.WIFE?.value === person2;
-  });
-};
-
 // src/constants/orders.ts
 var DEFAULT = {};
 var BIRTH_ASC = {
@@ -6565,4 +7180,4 @@ var getMarriageAscAndBirth = (person) => (itemA, keyA, itemB, keyB) => {
   return getBirthAsc(itemA, keyA, itemB);
 };
 
-export { ADOPTED, BIOLOGICAL, BIRTH, BIRTH_ASC, BIRTH_DESC, DATE_ASC, DATE_DESC, DEATH_ASC, DEATH_DESC, DEFAULT, EVERY, FEMALE, FOSTER, FRIEND, ID_GETTER_REG, ID_REG, ID_SPLIT_REG, LINE_REG, MALE, MAX_FILE_SIZE_TO_SYNC, OTHER, PARTNER, REF_LINE_REG, SEALING, SINGLE, SPOUSE, STEP, UNKOWN, getBirthAsc, getMarriageAsc, getMarriageAscAndBirth, getMarriageAscAndChildBirth, getNameAsc, getNameAscAndBirth, getNameDesc };
+export { ADOPTED, APP_BRANDING, BIOLOGICAL, BIRTH, BIRTH_ASC, BIRTH_DESC, DATE_ASC, DATE_DESC, DEATH_ASC, DEATH_DESC, DEFAULT, EVERY, FEMALE, FOSTER, FRIEND, ID_GETTER_REG, ID_REG, ID_SPLIT_REG, LINE_REG, MALE, MAX_FILE_SIZE_TO_SYNC, ORIG_HEAD_TAG, OTHER, PARTNER, REF_LINE_REG, SEALING, SINGLE, SPOUSE, STEP, UNKOWN, getBirthAsc, getMarriageAsc, getMarriageAscAndBirth, getMarriageAscAndChildBirth, getNameAsc, getNameAscAndBirth, getNameDesc };