@treeviz/gedcom-parser 1.0.1

package/dist/utils/logger.js

@@ -0,0 +1,11 @@
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const debugAll = false;
+const debugError = true;
+export const implemented = (type, ...args) => {
+    debugAll && console.info(`[Implemented] ${type}`, ...args);
+};
+export const notImplemented = (type, ...args) => {
+    (debugAll || debugError) &&
+        console.error(`[Not Implemented] ${type}`, ...args);
+};

package/dist/utils/name-formatter.d.ts

@@ -0,0 +1,10 @@
+import { type IndiType } from "../classes/indi";
+import type { Settings } from "../types/settings";
+export declare const nameFormatter: (indiName?: IndiType | string, settings?: Partial<Settings>, letterOnAll?: boolean, indi?: IndiType, debug?: 3) => {
+    suffix: string;
+    givenname: string;
+    surname: string;
+    inOrder: [string, string, string];
+    letter: string;
+};
+//# sourceMappingURL=name-formatter.d.ts.map

package/dist/utils/name-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-formatter.d.ts","sourceRoot":"","sources":["../../src/utils/name-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,eAAO,MAAM,aAAa,GACzB,WAAW,QAAQ,GAAG,MAAM,EAC5B,WAAW,OAAO,CAAC,QAAQ,CAAC,EAC5B,qBAAkB,EAClB,OAAO,QAAQ,EACf,QAAQ,CAAC;;;;;;CAyDT,CAAC"}

package/dist/utils/name-formatter.js

@@ -0,0 +1,45 @@
+import { Indi } from "../classes/indi";
+import { createCommonName } from "../classes/name";
+export const nameFormatter = (indiName, settings, letterOnAll = true, indi, debug) => {
+    const { nameOrder = "first-last", maxGivennames = 0, maxSurnames = 0, } = settings ?? {};
+    const rawName = indiName instanceof Indi
+        ? indiName?.NAME
+        : createCommonName(undefined, undefined, indi).name(indiName);
+    const name = rawName?.toList().index(0);
+    let givenname = name?.GIVN?.toValueList().first()?.value || "";
+    let surname = name?.SURN?.toValueList().first()?.value || "";
+    let suffix = name?.NSFX?.toValueList().first()?.value || "";
+    const displayedName = name?.DISPLAY?.toValueList().first()?.value || "";
+    if (!givenname && !surname) {
+        givenname = displayedName;
+    }
+    if (maxGivennames > 0) {
+        givenname = givenname.split(" ").slice(0, maxGivennames).join(" ");
+    }
+    if (maxSurnames > 0) {
+        surname = surname.split(" ").slice(0, maxSurnames).join(" ");
+    }
+    if (debug) {
+        suffix = suffix || "Dr";
+        for (let i = 1; i < debug; i++) {
+            givenname = `${givenname} ${givenname}`;
+            surname = `${surname} ${surname}`;
+        }
+    }
+    const inOrder = [
+        suffix,
+        ...(nameOrder === "last-first"
+            ? [surname, givenname]
+            : [givenname, surname]),
+    ];
+    const lName = (letterOnAll
+        ? [inOrder[1], inOrder[2]].filter(Boolean).join(" ")
+        : inOrder[1]).toLowerCase();
+    const firstLetter = lName.match(/^(dzs|cs|dz|gy|ly|ny|sz|ty|zs|\w)/i)?.[0] ??
+        lName.substring(0, 1) ??
+        "";
+    const validFirstLetter = `${firstLetter
+        .substring(0, 1)
+        .toUpperCase()}${firstLetter.substring(1)}`;
+    return { suffix, givenname, surname, inOrder, letter: validFirstLetter };
+};

package/dist/utils/nested-group.d.ts

@@ -0,0 +1,4 @@
+import type { Individuals } from "../classes/indis";
+import type { NestedGroup } from "../types/types";
+export declare const setNestedGroup: (obj: NestedGroup, key: string | string[], value: Individuals, uniqueCounting?: boolean) => void;
+//# sourceMappingURL=nested-group.d.ts.map

package/dist/utils/nested-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nested-group.d.ts","sourceRoot":"","sources":["../../src/utils/nested-group.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKlD,eAAO,MAAM,cAAc,GAC1B,KAAK,WAAW,EAChB,KAAK,MAAM,GAAG,MAAM,EAAE,EACtB,OAAO,WAAW,EAClB,wBAAqB,SAmCrB,CAAC"}

package/dist/utils/nested-group.js

@@ -0,0 +1,34 @@
+import get from "lodash/get";
+import set from "lodash/set";
+import { Individuals as IndividualsClass } from "../classes/indis";
+// Use a WeakMap to track unique items for each node without polluting the object
+const uniqueItemsCache = new WeakMap();
+export const setNestedGroup = (obj, key, value, uniqueCounting = true) => {
+    const parts = Array.isArray(key) ? key : key.split(/,\s*/);
+    // Set items only at the leaf level (deepest level of this path)
+    set(obj, [...parts, "items"], value);
+    // Update lengths at all parent levels by tracking unique items incrementally
+    parts.forEach((_, index) => {
+        if (!uniqueCounting) {
+            // If not unique counting, simply set the length to the number of items at this level
+            const key = [...parts.toSpliced(index + 1), "length"];
+            const length = get(obj, key);
+            set(obj, key, (length ?? 0) + value.length);
+            return;
+        }
+        const pathKey = [...parts.toSpliced(index + 1)];
+        const node = get(obj, pathKey);
+        if (node) {
+            // Get or create the unique items collection for this node
+            let uniqueItems = uniqueItemsCache.get(node);
+            if (!uniqueItems) {
+                uniqueItems = new IndividualsClass();
+                uniqueItemsCache.set(node, uniqueItems);
+            }
+            // Merge the new items to track unique individuals
+            uniqueItems.merge(value);
+            // Update the length to be the count of unique items
+            set(obj, [...pathKey, "length"], uniqueItems.length);
+        }
+    });
+};

package/dist/utils/ordinalize.d.ts

@@ -0,0 +1,3 @@
+export declare const ordinalize: (n: number) => string;
+export declare const hungarianOrdinalize: (n: number) => string;
+//# sourceMappingURL=ordinalize.d.ts.map

package/dist/utils/ordinalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordinalize.d.ts","sourceRoot":"","sources":["../../src/utils/ordinalize.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,GAAI,GAAG,MAAM,KAAG,MAsBtC,CAAC;AAeF,eAAO,MAAM,mBAAmB,GAAI,GAAG,MAAM,WAqF5C,CAAC"}

package/dist/utils/ordinalize.js

@@ -0,0 +1,104 @@
+export const ordinalize = (n) => {
+    const num = Math.round(n);
+    const numString = num.toString();
+    // If the ten's place is 1, the suffix is always "th"
+    // (10th, 11th, 12th, 13th, 14th, 111th, 112th, etc.)
+    if (Math.floor(num / 10) % 10 === 1) {
+        return numString + "th";
+    }
+    // Otherwise, the suffix depends on the one's place as follows
+    // (1st, 2nd, 3rd, 4th, 21st, 22nd, etc.)
+    switch (num % 10) {
+        case 1:
+            return numString + "st";
+        case 2:
+            return numString + "nd";
+        case 3:
+            return numString + "rd";
+        default:
+            return numString + "th";
+    }
+};
+export const hungarianOrdinalize = (n) => {
+    const numberPrefix = [
+        "",
+        "",
+        "két",
+        "három",
+        "négy",
+        "öt",
+        "hat",
+        "hét",
+        "nyolc",
+        "kilenc",
+    ];
+    const ordinals = [
+        [
+            "",
+            ["első", "egyed"],
+            ["másod", "ketted"],
+            "harmad",
+            "negyed",
+            "ötöd",
+            "hatod",
+            "heted",
+            "nyolcad",
+            "kilenced",
+        ],
+        [
+            "",
+            ["tized", "tizen"],
+            ["huszad", "huszon"],
+            "harmincad",
+            "negyvened",
+            "ötvened",
+            "hatvanad",
+            "hetvened",
+            "nyolcvanad",
+            "kilencvened",
+        ],
+        "század",
+        ["ezred", "ezer"],
+    ];
+    const parts = [];
+    let fractionIndex = 0;
+    let fractions = 1;
+    let nr = Math.abs(n);
+    let part;
+    do {
+        const nextFractions = fractions * 10;
+        const index = fractions > 1
+            ? (nr % nextFractions) / fractions
+            : nr % nextFractions;
+        const ordinalList = ordinals[fractionIndex++];
+        if (typeof ordinalList === "string") {
+            part = `${numberPrefix[index]}${ordinalList}`;
+        }
+        else if (ordinalList.length === 2) {
+            part = ordinalList;
+        }
+        else {
+            part = ordinalList?.[index];
+        }
+        if (Array.isArray(part)) {
+            if (fractions === 1) {
+                part = part[nr < 10 ? 0 : 1];
+            }
+            else {
+                part = part[n % 10 === 0 ? 0 : 1];
+            }
+        }
+        else if (fractions > 1 && n % 10 !== 0) {
+            part = part?.substring(0, part.length - 2);
+        }
+        if (part !== undefined) {
+            parts.unshift(part);
+        }
+        fractions = nextFractions;
+        nr = Math.floor(nr / nextFractions) * nextFractions;
+        if (nr < nextFractions) {
+            break;
+        }
+    } while (part !== undefined);
+    return parts.join("");
+};

package/dist/utils/parser.d.ts

@@ -0,0 +1,17 @@
+import { Common } from "../classes/common";
+import type { Settings } from "../types/settings";
+import { type MultiTag } from "../types/types";
+declare const GedcomTree: {
+    parse: (content: string, options?: {
+        settings?: Settings;
+    }) => any;
+    parseHierarchy: (content: string, options?: {
+        settings?: Settings;
+    }) => {
+        gedcom: import("../classes/gedcom").GedComType;
+        raw: string;
+    };
+    addToList: (id: string, type: MultiTag, common: Common, prev: Common) => void;
+};
+export default GedcomTree;
+//# sourceMappingURL=parser.d.ts.map

package/dist/utils/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/utils/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAoB,MAAM,mBAAmB,CAAC;AAgB7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAiC,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAuD9E,QAAA,MAAM,UAAU;qBACW,MAAM,YAAY;QAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;KAAE;8BAIzD,MAAM,YACL;QAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;KAAE;;;;oBAuQ7B,MAAM,QACJ,QAAQ,UACN,MAAM,QACR,MAAM;CAuBb,CAAC;AAOF,eAAe,UAAU,CAAC"}

package/dist/utils/parser.js

@@ -0,0 +1,322 @@
+import { Common, getListTag, isId } from "../classes/common";
+import { Families } from "../classes/fams";
+import { createGedCom } from "../classes/gedcom";
+import { Indi } from "../classes/indi";
+import { Individuals } from "../classes/indis";
+import { List } from "../classes/list";
+import { Objects } from "../classes/objes";
+import { Repositories } from "../classes/repos";
+import { Sources } from "../classes/sours";
+import { Submitters } from "../classes/subms";
+import { LINE_REG, MAX_FILE_SIZE_TO_SYNC, REF_LINE_REG, } from "../constants/constants";
+import { create } from "./common-creator";
+import { isDevelopment } from "./get-product-details";
+import { getRawSize } from "./get-raw-size";
+const isDev = isDevelopment();
+// let lastTime: number | undefined;
+// interface Props {
+// 	index:
+// 		| number
+// 		| `${number}.${number}`
+// 		| `${number}.${number}.${number}`
+// 		| `${number}.${number}.${number}.${number}`;
+// 	label?: string;
+// 	lastTime?: number;
+// }
+// const printTime = (
+// 	{
+// 		index,
+// 		label = "RunTimeTest",
+// 		lastTime: lastTimeProp,
+// 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// 	}: Props,
+// 	...args: any[]
+// ) => {
+// 	// if (!isDev) {
+// 	// 	return;
+// 	// }
+// 	if (lastTimeProp !== undefined) {
+// 		lastTime = lastTimeProp;
+// 	}
+// 	const date = Date.now();
+// 	const diff = lastTime === undefined ? "Not provided" : date - lastTime;
+// 	const func = (
+// 		diff === "Not provided" || diff <= 150
+// 			? console.log
+// 			: diff > 500
+// 				? console.error
+// 				: console.warn
+// 	).bind(console);
+// 	func(
+// 		label,
+// 		{
+// 			index,
+// 			date,
+// 			diff,
+// 		},
+// 		...args
+// 	);
+// 	lastTime = date;
+// };
+const GedcomTree = {
+    parse: function (content, options) {
+        return this.parseHierarchy(content, options);
+    },
+    parseHierarchy: function (content, options) {
+        // printTime{ index: 0, label: "[Debug]", lastTime: Date.now() });
+        const { settings } = options ?? {};
+        const { linkedPersons = "skip", linkingKey } = settings ?? {};
+        const gedcom = createGedCom();
+        gedcom.removeValue();
+        const reg = LINE_REG;
+        let key;
+        let type;
+        let idCheck;
+        let value;
+        let indent = 0;
+        let prevIndent = 0;
+        let curNode = gedcom;
+        let prevNode;
+        let mainNode;
+        const curPar = [];
+        // printTime{ index: 1, label: "[Debug]" });
+        let prevLineIndent = 0;
+        let prevRefLines;
+        let prevLines;
+        const refMatch = content.match(REF_LINE_REG);
+        // printTime{ index: 2, label: "[Debug]" });
+        const refs = refMatch && Array.isArray(refMatch)
+            ? refMatch.reduce((acc, curr) => {
+                const [_refIndent, refId, refType] = curr.split(" ");
+                if (refId && refType) {
+                    acc[refId] = refType.toUpperCase();
+                }
+                return acc;
+            }, {})
+            : {};
+        const links = new Individuals();
+        const tags = [];
+        // printTime{ index: 3, label: "[Debug]" });
+        let lines = `${content.replace(/\n0 TRLR(\r?\n)*$/, "")}\n0 TRLR\n`
+            .split(/\r?\n/)
+            .reduce((acc, line) => {
+            const lineMatch = line.match(LINE_REG);
+            if (lineMatch) {
+                const lineIndent = Number(lineMatch?.groups?.indent ?? 0);
+                const lineValue = lineMatch?.groups?.value ?? "";
+                if (lineIndent > 0 &&
+                    lineIndent > prevLineIndent &&
+                    lineValue &&
+                    isId(lineValue)) {
+                    const refLines = lineValue
+                        .split(/,\s*/)
+                        .map((id) => line.replace(lineValue, id));
+                    if (refLines.length > 1) {
+                        prevLineIndent = lineIndent;
+                        prevRefLines = refLines;
+                    }
+                    else {
+                        acc.push(line);
+                    }
+                }
+                else {
+                    if (prevRefLines) {
+                        if (lineIndent > prevLineIndent) {
+                            if (!prevLines) {
+                                prevLines = [];
+                            }
+                            prevLines.push(line);
+                        }
+                        else {
+                            prevRefLines.forEach((prevRefLine) => {
+                                acc.push(prevRefLine, ...(prevLines ?? []));
+                            });
+                            prevLineIndent = 0;
+                            prevRefLines = undefined;
+                            prevLines = undefined;
+                            acc.push(line);
+                        }
+                    }
+                    else {
+                        acc.push(line);
+                    }
+                }
+            }
+            else {
+                if (acc[acc.length - 1] !== undefined) {
+                    acc[acc.length - 1] = `${acc[acc.length - 1]}${line}`;
+                }
+            }
+            return acc;
+        }, []);
+        let linesJoined = lines.join("\n");
+        // printTime{ index: 4, label: "[Debug]" }, { lines: lines.join("\n") });
+        if (!linesJoined.includes("1 _IS_PURGED true") &&
+            getRawSize(linesJoined) > MAX_FILE_SIZE_TO_SYNC) {
+            linesJoined = linesJoined
+                .replace(/1\s(NOTE|OBJE|SOUR)([^\n]*\n)([23456789]\s.+\n)*/gm, "")
+                .replace(/0\s(@[^@]+@)(\sSOUR[^\n]*\n)([123456789]\s.+\n)*/, "")
+                .replace(/0 HEAD(.*)\n/, "0 HEAD$1\n1 _IS_PURGED true\n");
+            lines = linesJoined.split("\n");
+            // printTime{ index: 6, label: "[Debug]" }, { lines: lines.join("\n") });
+        }
+        lines.forEach((line, index) => {
+            if (line.length === 0) {
+                return; // skip empty
+            }
+            const match = reg.exec(line);
+            if (match?.[1] === undefined) {
+                throw new Error(`Can't parse line #${index}: ${line}`);
+            }
+            try {
+                indent = Number(match[1]);
+                if (indent > prevIndent + 1) {
+                    indent = prevIndent + 1;
+                }
+                if (match?.[2] !== undefined) {
+                    key = match?.[3] + match?.[2];
+                }
+                else {
+                    key = match?.[3];
+                }
+                value = match?.[4];
+                [type, idCheck] = (key?.split("@") ?? []);
+                type = type?.toUpperCase();
+                const id = idCheck ? `@${idCheck}@` : undefined;
+                if (indent > prevIndent) {
+                    curPar.push(curNode);
+                    curNode = prevNode;
+                }
+                else if (indent < prevIndent) {
+                    for (let i = 0; i < prevIndent - indent; ++i) {
+                        curNode = curPar.pop();
+                    }
+                }
+                const newCommon = create(gedcom, type, id, {
+                    mainNode,
+                    curNode,
+                    prevNode,
+                });
+                prevNode = newCommon.prevNode;
+                mainNode = newCommon.mainNode;
+                if (prevNode instanceof Common) {
+                    if (mainNode instanceof Indi && type === "_MTTAG") {
+                        tags.push(prevNode);
+                    }
+                    if (value) {
+                        prevNode.value = value;
+                        if (isId(value) && refs[value]) {
+                            prevNode.refType = refs[value];
+                            mainNode?.addRef(prevNode);
+                            if (linkingKey &&
+                                linkingKey === type &&
+                                curNode instanceof Indi &&
+                                curNode?.id) {
+                                links.item(curNode.id, curNode);
+                            }
+                        }
+                    }
+                    else {
+                        prevNode.removeValue();
+                    }
+                }
+                if (type && type !== "value") {
+                    const curCommon = curNode;
+                    if (id) {
+                        this.addToList(id, type, curCommon, prevNode);
+                    }
+                    else {
+                        curCommon.assign(type, prevNode);
+                    }
+                }
+                prevIndent = indent;
+            }
+            catch (err) {
+                console.log("ASDXX", err);
+                throw new Error(`Can't parse line #${index}: ${line}`, {
+                    cause: err,
+                });
+            }
+        });
+        if (tags.length) {
+            gedcom.tagMembers = tags.reduce((acc, tag) => {
+                const tagName = tag?.get("NAME")?.toValue();
+                if (!tagName ||
+                    !tag?.ref ||
+                    !tag?.main ||
+                    !(tag.main instanceof Indi)) {
+                    return acc;
+                }
+                if (!acc[tagName]) {
+                    acc[tagName] = {
+                        tag: tag.ref,
+                        indis: new Individuals(),
+                    };
+                }
+                acc[tagName].indis.append(tag.main);
+                return acc;
+            }, {});
+        }
+        try {
+            if ("@@INDI" in gedcom) {
+                gedcom["@@INDI"] = gedcom["@@INDI"]?.filter((item) => {
+                    return !item.isIgnoredMember();
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Malformed GEDCOM`, {
+                cause: err,
+            });
+        }
+        if (linkingKey) {
+            links.forEach((linkingIndi, _linkingId) => {
+                const linking = linkingIndi;
+                const linked = linking?.get(linkingKey)
+                    ?.ref;
+                if (!linking) {
+                    return;
+                }
+                if (linkedPersons === "merge") {
+                    gedcom.mergeIndis(linked, linking);
+                }
+                else if (linkedPersons === "clone") {
+                    gedcom.cloneIndis(linked, linking, ["FAMS"]);
+                }
+            });
+        }
+        return { gedcom, raw: linesJoined };
+    },
+    addToList: function (id, type, common, prev) {
+        const listTag = getListTag(type);
+        let curValue = common.get(listTag);
+        if (type === "INDI" || type === "_INDI") {
+            curValue = curValue || new Individuals();
+        }
+        else if (type === "FAM") {
+            curValue = curValue || new Families();
+        }
+        else if (type === "OBJE") {
+            curValue = curValue || new Objects();
+        }
+        else if (type === "REPO") {
+            curValue = curValue || new Repositories();
+        }
+        else if (type === "SUBM") {
+            curValue = curValue || new Submitters();
+        }
+        else if (type === "SOUR") {
+            curValue = curValue || new Sources();
+        }
+        else {
+            curValue = curValue || new List();
+        }
+        common.set(listTag, curValue);
+        curValue.item(id, prev);
+    },
+};
+if (isDev) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    globalThis.GedcomTree = GedcomTree;
+}
+export default GedcomTree;

package/dist/utils/place-parser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Minimal place parsing stub for gedcom-parser
+ * This is a simplified version - consumer apps can implement full place parsing if needed
+ */
+export interface PlaceParts {
+    leftParts?: string[];
+    town?: string;
+    county?: string;
+    country?: string;
+}
+/**
+ * Simple place parser - splits by commas
+ * Consumer apps can implement more sophisticated parsing if needed
+ */
+export declare const getPlaceParts: (place?: string | (string | undefined)[]) => PlaceParts[];
+//# sourceMappingURL=place-parser.d.ts.map

package/dist/utils/place-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-parser.d.ts","sourceRoot":"","sources":["../../src/utils/place-parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,UAAU;IAC1B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,GACzB,QAAO,MAAM,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,EAAO,KACzC,UAAU,EAwCZ,CAAC"}

package/dist/utils/place-parser.js

@@ -0,0 +1,46 @@
+/**
+ * Minimal place parsing stub for gedcom-parser
+ * This is a simplified version - consumer apps can implement full place parsing if needed
+ */
+/**
+ * Simple place parser - splits by commas
+ * Consumer apps can implement more sophisticated parsing if needed
+ */
+export const getPlaceParts = (place = []) => {
+    const partsString = Array.isArray(place)
+        ? place.filter(Boolean).join(", ")
+        : place;
+    if (!partsString) {
+        return [{}];
+    }
+    // Simple split by comma
+    const parts = partsString
+        .split(/,\s*/)
+        .map((p) => p.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return [{}];
+    }
+    // Simple heuristic: last part is country, second-to-last is county, rest is town/city
+    const result = {};
+    if (parts.length === 1) {
+        result.town = parts[0];
+    }
+    else if (parts.length === 2) {
+        result.town = parts[0];
+        result.country = parts[1];
+    }
+    else if (parts.length === 3) {
+        result.town = parts[0];
+        result.county = parts[1];
+        result.country = parts[2];
+    }
+    else {
+        // More than 3 parts - put extras in leftParts
+        result.leftParts = parts.slice(0, parts.length - 3);
+        result.town = parts[parts.length - 3];
+        result.county = parts[parts.length - 2];
+        result.country = parts[parts.length - 1];
+    }
+    return [result];
+};

package/dist/utils/place-translator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Place translator stub for gedcom-parser
+ * This is a minimal no-op implementation - consumer apps can implement translation if needed
+ */
+export declare const placeTranslator: (place: string | string[]) => string;
+//# sourceMappingURL=place-translator.d.ts.map

package/dist/utils/place-translator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-translator.d.ts","sourceRoot":"","sources":["../../src/utils/place-translator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,GAAG,MAAM,EAAE,KAAG,MAG1D,CAAC"}

package/dist/utils/place-translator.js

@@ -0,0 +1,8 @@
+/**
+ * Place translator stub for gedcom-parser
+ * This is a minimal no-op implementation - consumer apps can implement translation if needed
+ */
+export const placeTranslator = (place) => {
+    // No-op stub - return place as-is (join if array)
+    return Array.isArray(place) ? place.join(", ") : place;
+};