@treeviz/gedcom-parser 1.0.1

package/dist/classes/list.js

@@ -0,0 +1,440 @@
+import differenceBy from "lodash/differenceBy";
+import get from "lodash/get";
+import intersectionBy from "lodash/intersectionBy";
+import set from "lodash/set";
+import unset from "lodash/unset";
+import { getValidTag } from "./common";
+export class List {
+    // length = 0;
+    constructor(items) {
+        this.items = {};
+        this.isListable = true;
+        this.marker = undefined;
+        if (items) {
+            this.concat(items);
+        }
+    }
+    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);
+            }
+        });
+        return propList;
+    }
+    keys() {
+        // const hasOwn = Object.prototype.hasOwnProperty;
+        // const keys: K[] = [];
+        // for (const k in this.items) {
+        // 	if (hasOwn.call(this.items, k)) {
+        // 		keys.push(k);
+        // 	}
+        // }
+        // return keys;
+        return Object.keys(this.items);
+    }
+    values() {
+        // const hasOwn = Object.prototype.hasOwnProperty;
+        // const values: Array<T | undefined> = [];
+        // for (const k in this.items) {
+        // 	if (hasOwn.call(this.items, k)) {
+        // 		values.push(this.items[k]);
+        // 	}
+        // }
+        // return values;
+        return Object.values(this.items);
+    }
+    entries() {
+        // const hasOwn = Object.prototype.hasOwnProperty;
+        // const entries: Array<[K, T | undefined]> = [];
+        // for (const k in this.items) {
+        // 	if (hasOwn.call(this.items, k)) {
+        // 		entries.push([k, this.items[k]]);
+        // 	}
+        // }
+        // return entries;
+        return Object.entries(this.items);
+    }
+    setLength(_type) {
+        // THIS IS TO SLOW
+        // if (!type) {
+        // 	this.length = this.keys().length;
+        // } else {
+        // 	this.length = this.length + (type === "increase" ? 1 : -1);
+        // }
+    }
+    first() {
+        return this.index(0);
+    }
+    last() {
+        return this.index(this.keys().length - 1);
+    }
+    index(index) {
+        const keys = this.keys();
+        const key = keys[index];
+        return key && this.items[key];
+    }
+    item(name, value) {
+        if (arguments.length > 1) {
+            set(this.items, name, value);
+            this.setLength();
+        }
+        return get(this.items, name);
+    }
+    removeItem(name) {
+        unset(this.items, name);
+        this.setLength();
+    }
+    exclude(excludedList) {
+        excludedList.keys().forEach((itemId) => {
+            delete this.items[itemId];
+        });
+        this.setLength();
+        return this;
+    }
+    concat(items) {
+        if (Array.isArray(items)) {
+            items.forEach((item) => {
+                this.append(item);
+            });
+        }
+        else {
+            Object.assign(this.items, items ?? {});
+        }
+        this.setLength();
+        return this;
+    }
+    merge(mergedList) {
+        this.concat(mergedList?.items);
+        return this;
+    }
+    intersection(mergedList) {
+        const inter = intersectionBy(this.values(), mergedList?.values() ?? [], "id");
+        return new List(inter);
+    }
+    difference(mergedList) {
+        const inter = differenceBy(this.values(), mergedList?.values() ?? [], "id");
+        return new List(inter);
+    }
+    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;
+    }
+    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");
+            }
+        }
+        return this;
+    }
+    delete(item) {
+        if (item.id && this.items[item.id]) {
+            delete this.items[item.id];
+            this.setLength("decrease");
+        }
+        return this;
+    }
+    copy(ClassName = (List)) {
+        const newList = new ClassName();
+        Object.assign(newList.items, this.items);
+        newList.setLength();
+        return newList;
+    }
+    except(item, ClassName = (List)) {
+        return this.copy(ClassName).delete(item);
+    }
+    forEach(iterate) {
+        this.entries().forEach(([key, item], index) => {
+            iterate(item, key, index);
+        });
+    }
+    map(iterate) {
+        return this.entries().map(([key, item], index) => {
+            return iterate(item, key, index);
+        });
+    }
+    reduce(iterate, initialValue) {
+        return this.entries().reduce((acc, [key, item], index) => {
+            return iterate(acc, item, key, index);
+        }, initialValue);
+    }
+    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") {
+                        // id is a special prop. it's always a string
+                        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 newList;
+    }
+    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;
+            }
+            if (!Object.keys(filters).length ||
+                Object.entries(filters).every(([key, value]) => {
+                    let itemValue;
+                    if (key === "id") {
+                        // id is a special prop. it's always a string
+                        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 foundItem;
+    }
+    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 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 sortValue = 0;
+            if (!valueA && valueA !== 0 && !valueB && valueB !== 0) {
+                sortValue = 0;
+            }
+            else if (!valueB && valueB !== 0) {
+                sortValue = 1;
+            }
+            else if (!valueA && valueA !== 0) {
+                sortValue = -1;
+            }
+            else if (valueA < valueB) {
+                sortValue = -1;
+            }
+            else if (valueA > valueB) {
+                sortValue = 1;
+            }
+            return sortValue * (direction === "DESC" ? -1 : 1);
+        });
+        sortedItems.forEach(([key, value]) => {
+            newList.item(key, value);
+        });
+        return newList;
+    }
+    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)
+                    ?.toList()
+                    .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;
+    }
+    findIndex(item) {
+        if (!item?.id) {
+            return -1;
+        }
+        return this.keys().findIndex((key) => key === item.id);
+    }
+    getItems() {
+        return this.items;
+    }
+    toJson(tag, options) {
+        const json = this.toObject(tag, options);
+        return JSON.stringify(json);
+    }
+    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;
+    }
+    toGedcom(tag, level = 0, options) {
+        const gedcom = this.toGedcomLines(tag, level, options);
+        return gedcom.join("\n");
+    }
+    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;
+    }
+    toValue() {
+        const propList = new List();
+        this.entries().forEach(([key, item]) => {
+            propList.item(key, item?.toValue());
+        });
+        return propList;
+    }
+    // @deprecated use get instead
+    toProp(tag) {
+        return this.get(tag);
+    }
+    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;
+    }
+}

package/dist/classes/name.d.ts

@@ -0,0 +1,20 @@
+import type { IdType } from "../types/types";
+import { Common } from "./common";
+import type { ProxyOriginal } from "./common";
+import { type GedComType } from "./gedcom";
+export declare class CommonName extends Common<string> {
+    NPFX?: Common;
+    GIVN?: Common;
+    NICK?: Common;
+    SPFX?: Common;
+    SURN?: Common;
+    NSFX?: Common;
+    DISPLAY?: Common;
+    _MARNM?: Common;
+    constructor(gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common);
+    set value(value: string | undefined);
+    get value(): string | undefined;
+    name(value: string | undefined): this;
+}
+export declare const createCommonName: (gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common) => ProxyOriginal<CommonName>;
+//# sourceMappingURL=name.d.ts.map

package/dist/classes/name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.d.ts","sourceRoot":"","sources":["../../src/classes/name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAA6B,MAAM,UAAU,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C,qBAAa,UAAW,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAGf,MAAM,CAAC,EAAE,UAAU,EACnB,EAAE,CAAC,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM;IAOhB,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAoClC;IAED,IAAI,KAAK,IAtCQ,MAAM,GAAG,SAAS,CA4ClC;IAED,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;CAK9B;AAED,eAAO,MAAM,gBAAgB,GAC5B,SAAS,UAAU,EACnB,KAAK,MAAM,EACX,OAAO,MAAM,EACb,SAAS,MAAM,KACb,aAAa,CAAC,UAAU,CAI1B,CAAC"}

package/dist/classes/name.js

@@ -0,0 +1,48 @@
+import { Common, createCommon, createProxy } from "./common";
+import { Indi } from "./indi";
+export class CommonName extends Common {
+    constructor(gedcom, id, main, parent) {
+        super(gedcom, id, main, parent);
+        delete this.id;
+    }
+    set value(value) {
+        if (value && this._main instanceof Indi) {
+            const nameParts = value.match(/(?<givenname>[^/]*)(\/(?<surname>[^/]*)\/)?(?<suffix>.*)$/)?.groups;
+            if (nameParts?.givenname?.trim()) {
+                this.GIVN =
+                    this.GIVN ||
+                        createCommon(this._gedcom, undefined, this.main);
+                this.GIVN.isListable = false;
+                this.GIVN.value = nameParts.givenname.trim();
+            }
+            if (nameParts?.surname?.trim()) {
+                this.SURN =
+                    this.SURN ||
+                        createCommon(this._gedcom, undefined, this.main);
+                this.SURN.value = nameParts.surname.trim();
+                this.SURN.isListable = false;
+            }
+            if (nameParts?.suffix?.trim()) {
+                this.NSFX =
+                    this.NSFX ||
+                        createCommon(this._gedcom, undefined, this.main);
+                this.NSFX.value = nameParts.suffix.trim();
+                this.NSFX.isListable = false;
+            }
+        }
+        this._value = value;
+    }
+    get value() {
+        if (this._value === undefined && this.DISPLAY?.value) {
+            return this.DISPLAY?.value;
+        }
+        return this._value;
+    }
+    name(value) {
+        this.value = value;
+        return this;
+    }
+}
+export const createCommonName = (gedcom, id, main, parent) => {
+    return createProxy(new CommonName(gedcom, id, main, parent));
+};

package/dist/classes/note.d.ts

@@ -0,0 +1,12 @@
+import type { IdType } from "../types/types";
+import { Common } from "./common";
+import type { ProxyOriginal } from "./common";
+import { type GedComType } from "./gedcom";
+export declare class CommonNote extends Common<string> {
+    constructor(gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common);
+    set value(value: string | undefined);
+    get value(): string | undefined;
+    exportValue(): string;
+}
+export declare const createCommonNote: (gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common) => ProxyOriginal<CommonNote>;
+//# sourceMappingURL=note.d.ts.map

package/dist/classes/note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"note.d.ts","sourceRoot":"","sources":["../../src/classes/note.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAA6B,MAAM,UAAU,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C,qBAAa,UAAW,SAAQ,MAAM,CAAC,MAAM,CAAC;gBAE5C,MAAM,CAAC,EAAE,UAAU,EACnB,EAAE,CAAC,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM;IAOhB,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EA4BlC;IAED,IAAI,KAAK,IA9BQ,MAAM,GAAG,SAAS,CAyClC;IAED,WAAW;CAGX;AAED,eAAO,MAAM,gBAAgB,GAC5B,SAAS,UAAU,EACnB,KAAK,MAAM,EACX,OAAO,MAAM,EACb,SAAS,MAAM,KACb,aAAa,CAAC,UAAU,CAI1B,CAAC"}

package/dist/classes/note.js

@@ -0,0 +1,46 @@
+import { Common, createCommon, createProxy } from "./common";
+import { List } from "./list";
+export class CommonNote extends Common {
+    constructor(gedcom, id, main, parent) {
+        super(gedcom, id, main, parent);
+        delete this.id;
+    }
+    set value(value) {
+        const [note, ...contents] = value?.split(/\r?\n/) ?? [];
+        this._value = note;
+        if (contents.length) {
+            const newContents = new List();
+            contents.forEach((c, i) => {
+                const newContent = createCommon(this._gedcom, undefined, this.main);
+                newContent.id = `@U${i}@`;
+                newContent.value = c;
+                newContents.append(newContent);
+            });
+            const firstItem = newContents.index(0);
+            if (firstItem) {
+                if (newContents.length === 1) {
+                    this.set("CONT", firstItem);
+                }
+                else {
+                    this.set("CONT", newContents);
+                }
+            }
+        }
+    }
+    get value() {
+        const contents = this.get("CONT")
+            ?.toList()
+            .map((content) => content.value)
+            .join("\n");
+        if (contents) {
+            return `${this._value}\n${contents}`;
+        }
+        return this._value;
+    }
+    exportValue() {
+        return this._value;
+    }
+}
+export const createCommonNote = (gedcom, id, main, parent) => {
+    return createProxy(new CommonNote(gedcom, id, main, parent));
+};

package/dist/classes/obje.d.ts

@@ -0,0 +1,12 @@
+import type IMultimediaLinkStructure from "../structures/multimedia-link";
+import { type ObjeKey } from "../types/types";
+import type IObje from "../interfaces/obje";
+import { Common } from "./common";
+import type { ProxyOriginal } from "./common";
+import { type GedComType } from "./gedcom";
+export declare class Obje extends Common<string, ObjeKey> implements IObje {
+    standardizeMedia(namespace?: string | number, override?: boolean, urlGetter?: (namespace?: string | number, imgId?: string) => string | undefined): this | ProxyOriginal<ObjeType>;
+}
+export type ObjeType = Obje & IMultimediaLinkStructure;
+export declare const createObje: (gedcom: GedComType, id?: ObjeKey, main?: Common, parent?: Common) => ProxyOriginal<ObjeType>;
+//# sourceMappingURL=obje.d.ts.map

package/dist/classes/obje.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obje.d.ts","sourceRoot":"","sources":["../../src/classes/obje.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,wBAAwB,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,KAAK,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,MAAM,EAA6B,MAAM,UAAU,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,qBAAa,IAAK,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,YAAW,KAAK;IACjE,gBAAgB,CACf,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAC3B,QAAQ,UAAO,EACf,SAAS,CAAC,EAAE,CACX,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAC3B,KAAK,CAAC,EAAE,MAAM,KACV,MAAM,GAAG,SAAS;CAsGxB;AAED,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG,wBAAwB,CAAC;AACvD,eAAO,MAAM,UAAU,GACtB,QAAQ,UAAU,EAClB,KAAK,OAAO,EACZ,OAAO,MAAM,EACb,SAAS,MAAM,KACb,aAAa,CAAC,QAAQ,CAIxB,CAAC"}

package/dist/classes/obje.js

@@ -0,0 +1,81 @@
+import { Common, createCommon, createProxy } from "./common";
+export class Obje extends Common {
+    standardizeMedia(namespace, override = true, urlGetter) {
+        if (!this._gedcom) {
+            return this;
+        }
+        const rin = this?.get("RIN")?.toValue();
+        const clone = this?.get("_CLON._OID")?.toValue();
+        const mser = this?.get("_MSER._LKID")?.toValue();
+        const title = this?.get("FILE.TITL")?.toValue() ??
+            this?.get("TITL")?.toValue() ??
+            "";
+        const note = this?.get("FILE.NOTE")?.toValue() ??
+            this?.get("NOTE")?.toValue() ??
+            "";
+        const form = this?.get("FILE.FORM")?.toValue();
+        const file = this?.get("FILE")?.toValue();
+        const imgId = rin || clone || mser;
+        const url = file || (namespace && urlGetter?.(namespace, imgId));
+        if (!url) {
+            return this;
+        }
+        const newObject = createObje(this._gedcom, this.id, this.main);
+        if (!override) {
+            Object.assign(newObject, this);
+        }
+        if (form) {
+            if (typeof form === "string") {
+                const newForm = createCommon(this._gedcom, undefined, this.main);
+                newForm.value = form;
+                newObject.set("FORM", newForm);
+            }
+            else {
+                newObject.set("FORM", form);
+            }
+        }
+        if (title) {
+            if (typeof title === "string") {
+                const newTitle = createCommon(this._gedcom, undefined, this.main);
+                newTitle.value = title;
+                newObject.set("TITL", newTitle);
+                if (!note) {
+                    newObject.set("NOTE", newTitle);
+                }
+            }
+            else {
+                newObject.set("TITL", title);
+                if (!note) {
+                    newObject.set("NOTE", title);
+                }
+            }
+        }
+        if (note) {
+            if (typeof note === "string") {
+                const newNote = createCommon(this._gedcom, undefined, this.main);
+                newNote.value = note;
+                newObject.set("NOTE", newNote);
+                if (!title) {
+                    newObject.set("TITL", newNote);
+                }
+            }
+            else {
+                newObject.set("NOTE", note);
+                if (!title) {
+                    newObject.set("TITL", note);
+                }
+            }
+        }
+        const newUrl = createCommon(this._gedcom, undefined, this.main);
+        newUrl.value = url;
+        newObject.set("FILE", newUrl);
+        if (override) {
+            Object.assign(this, newObject);
+            return this;
+        }
+        return newObject;
+    }
+}
+export const createObje = (gedcom, id, main, parent) => {
+    return createProxy(new Obje(gedcom, id, main, parent));
+};

package/dist/classes/objes.d.ts

@@ -0,0 +1,8 @@
+import { type ObjeKey } from "../types/types";
+import { List } from "./list";
+import { type ObjeType } from "./obje";
+export declare class Objects extends List<ObjeKey, ObjeType> {
+    copy(): Objects;
+    except(item: ObjeType): Objects;
+}
+//# sourceMappingURL=objes.d.ts.map

package/dist/classes/objes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objes.d.ts","sourceRoot":"","sources":["../../src/classes/objes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC,qBAAa,OAAQ,SAAQ,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC;IACnD,IAAI;IAUJ,MAAM,CAAC,IAAI,EAAE,QAAQ;CAGrB"}