@treeviz/gedcom-parser 1.0.1 → 1.0.2

package/dist/classes/list.js

@@ -1,9 +1,9 @@
-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";
+import differenceBy from "lodash-es/differenceBy.js";
+import get from "lodash-es/get.js";
+import intersectionBy from "lodash-es/intersectionBy.js";
+import set from "lodash-es/set.js";
+import unset from "lodash-es/unset.js";
+import { getValidTag } from "./common.js";
 export class List {
     // length = 0;
     constructor(items) {

package/dist/classes/name.js

@@ -1,5 +1,5 @@
-import { Common, createCommon, createProxy } from "./common";
-import { Indi } from "./indi";
+import { Common, createCommon, createProxy } from "./common.js";
+import { Indi } from "./indi.js";
 export class CommonName extends Common {
     constructor(gedcom, id, main, parent) {
         super(gedcom, id, main, parent);

package/dist/classes/note.js

@@ -1,5 +1,5 @@
-import { Common, createCommon, createProxy } from "./common";
-import { List } from "./list";
+import { Common, createCommon, createProxy } from "./common.js";
+import { List } from "./list.js";
 export class CommonNote extends Common {
     constructor(gedcom, id, main, parent) {
         super(gedcom, id, main, parent);

package/dist/classes/obje.js

@@ -1,4 +1,4 @@
-import { Common, createCommon, createProxy } from "./common";
+import { Common, createCommon, createProxy } from "./common.js";
 export class Obje extends Common {
     standardizeMedia(namespace, override = true, urlGetter) {
         if (!this._gedcom) {

package/dist/classes/objes.js

@@ -1,4 +1,4 @@
-import { List } from "./list";
+import { List } from "./list.js";
 export class Objects extends List {
     copy() {
         const newList = new Objects();

package/dist/classes/repo.js

@@ -1,4 +1,4 @@
-import { Common, createProxy } from "./common";
+import { Common, createProxy } from "./common.js";
 export class Repo extends Common {
 }
 export const createRepo = (gedcom, id, main, parent) => {

package/dist/classes/repos.js

@@ -1,4 +1,4 @@
-import { List } from "./list";
+import { List } from "./list.js";
 export class Repositories extends List {
     copy() {
         const newList = new Repositories();

package/dist/classes/sour.js

@@ -1,4 +1,4 @@
-import { Common, createProxy } from "./common";
+import { Common, createProxy } from "./common.js";
 export class Sour extends Common {
 }
 export const createSour = (gedcom, id, main, parent) => {

package/dist/classes/sours.js

@@ -1,4 +1,4 @@
-import { List } from "./list";
+import { List } from "./list.js";
 export class Sources extends List {
     copy() {
         const newList = new Sources();

package/dist/classes/subm.js

@@ -1,4 +1,4 @@
-import { Common, createProxy } from "./common";
+import { Common, createProxy } from "./common.js";
 export class Subm extends Common {
 }
 export const createSubm = (gedcom, id, main, parent) => {

package/dist/classes/subms.js

@@ -1,4 +1,4 @@
-import { List } from "./list";
+import { List } from "./list.js";
 export class Submitters extends List {
     copy() {
         const newList = new Submitters();

package/dist/cli/commands/convert.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerConvertCommand(program: Command): void;
+//# sourceMappingURL=convert.d.ts.map

package/dist/cli/commands/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/convert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiF7D"}

package/dist/cli/commands/convert.js

@@ -0,0 +1,83 @@
+import { writeFileSync } from 'fs';
+import GedcomTree from '../../utils/parser.js';
+import { formatSuccess, formatJson } from '../utils/formatters.js';
+import { readGedcomFile, handleError, cleanGedcomName } from '../utils/helpers.js';
+export function registerConvertCommand(program) {
+    program
+        .command('convert <file>')
+        .description('Convert GEDCOM to another format')
+        .requiredOption('-f, --format <format>', 'Output format: json, csv, markdown')
+        .option('-o, --output <file>', 'Output file path')
+        .action((file, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            const individuals = tree.indis();
+            let outputContent = '';
+            if (options.format === 'json') {
+                const jsonData = individuals.map(indi => ({
+                    id: indi.id,
+                    name: cleanGedcomName(indi.NAME?.toValue()),
+                    sex: indi.SEX?.value || null,
+                    birthDate: indi.BIRT?.DATE?.toValue() || null,
+                    birthPlace: indi.BIRT?.PLAC?.value || null,
+                    deathDate: indi.DEAT?.DATE?.toValue() || null,
+                    deathPlace: indi.DEAT?.PLAC?.value || null,
+                }));
+                outputContent = formatJson(jsonData);
+            }
+            else if (options.format === 'csv') {
+                const lines = [];
+                lines.push('ID,Name,Sex,Birth Date,Birth Place,Death Date,Death Place');
+                individuals.forEach(indi => {
+                    const csvEscape = (str) => {
+                        if (!str)
+                            return '';
+                        if (str.includes(',') || str.includes('"')) {
+                            return `"${str.replace(/"/g, '""')}"`;
+                        }
+                        return str;
+                    };
+                    lines.push([
+                        csvEscape(indi.id),
+                        csvEscape(cleanGedcomName(indi.NAME?.toValue())),
+                        csvEscape(indi.SEX?.value),
+                        csvEscape(indi.BIRT?.DATE?.toValue()),
+                        csvEscape(indi.BIRT?.PLAC?.value),
+                        csvEscape(indi.DEAT?.DATE?.toValue()),
+                        csvEscape(indi.DEAT?.PLAC?.value),
+                    ].join(','));
+                });
+                outputContent = lines.join('\n');
+            }
+            else if (options.format === 'markdown') {
+                const lines = [];
+                lines.push('# GEDCOM Individuals\n');
+                lines.push('| ID | Name | Sex | Birth | Death |');
+                lines.push('|----|------|-----|-------|-------|');
+                individuals.forEach(indi => {
+                    const name = cleanGedcomName(indi.NAME?.toValue()) || '?';
+                    const sex = indi.SEX?.value || '?';
+                    const birth = indi.BIRT?.DATE?.toValue() || '?';
+                    const death = indi.DEAT?.DATE?.toValue() || '?';
+                    lines.push(`| ${indi.id} | ${name} | ${sex} | ${birth} | ${death} |`);
+                });
+                outputContent = lines.join('\n');
+            }
+            else {
+                console.error(`Unsupported format: ${options.format}`);
+                process.exit(1);
+            }
+            if (options.output) {
+                writeFileSync(options.output, outputContent, 'utf-8');
+                console.log(formatSuccess(`Converted to ${options.format} and saved to ${options.output}`));
+            }
+            else {
+                console.log(outputContent);
+            }
+        }
+        catch (error) {
+            handleError(error, 'Failed to convert GEDCOM file');
+        }
+    });
+}

package/dist/cli/commands/extract.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerExtractCommand(program: Command): void;
+//# sourceMappingURL=extract.d.ts.map

package/dist/cli/commands/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/extract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAepC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA4F7D"}

package/dist/cli/commands/extract.js

@@ -0,0 +1,85 @@
+import { writeFileSync } from 'fs';
+import GedcomTree from '../../utils/parser.js';
+import { formatError, formatSuccess } from '../utils/formatters.js';
+import { readGedcomFile, handleError, cleanGedcomName } from '../utils/helpers.js';
+export function registerExtractCommand(program) {
+    program
+        .command('extract <file>')
+        .description('Extract a subset of individuals to a new GEDCOM file')
+        .requiredOption('-o, --output <file>', 'Output file path (required)')
+        .option('--surname <name>', 'Filter by surname')
+        .option('--birth-after <year>', 'Include individuals born after this year')
+        .option('--birth-before <year>', 'Include individuals born before this year')
+        .option('--death-after <year>', 'Include individuals who died after this year')
+        .option('--death-before <year>', 'Include individuals who died before this year')
+        .action((file, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            let individuals = tree.indis();
+            const results = [];
+            // Collect individuals that match all filters
+            individuals.forEach(indi => {
+                let matches = true;
+                // Filter by surname
+                if (options.surname && matches) {
+                    const searchSurname = options.surname.toLowerCase();
+                    const name = cleanGedcomName(indi.NAME?.toValue()).toLowerCase();
+                    matches = name.includes(searchSurname);
+                }
+                // Filter by birth year
+                if (options.birthAfter && matches) {
+                    const year = parseInt(options.birthAfter, 10);
+                    const birthDate = indi.BIRT?.DATE?.toValue();
+                    const match = birthDate?.match(/\d{4}/);
+                    matches = match && parseInt(match[0], 10) > year;
+                }
+                if (options.birthBefore && matches) {
+                    const year = parseInt(options.birthBefore, 10);
+                    const birthDate = indi.BIRT?.DATE?.toValue();
+                    const match = birthDate?.match(/\d{4}/);
+                    matches = match && parseInt(match[0], 10) < year;
+                }
+                // Filter by death year
+                if (options.deathAfter && matches) {
+                    const year = parseInt(options.deathAfter, 10);
+                    const deathDate = indi.DEAT?.DATE?.toValue();
+                    const match = deathDate?.match(/\d{4}/);
+                    matches = match && parseInt(match[0], 10) > year;
+                }
+                if (options.deathBefore && matches) {
+                    const year = parseInt(options.deathBefore, 10);
+                    const deathDate = indi.DEAT?.DATE?.toValue();
+                    const match = deathDate?.match(/\d{4}/);
+                    matches = match && parseInt(match[0], 10) < year;
+                }
+                if (matches) {
+                    results.push(indi);
+                }
+            });
+            if (results.length === 0) {
+                console.log(formatError('No individuals match the criteria'));
+                process.exit(1);
+            }
+            // Create subset GEDCOM
+            const lines = [];
+            lines.push('0 HEAD');
+            lines.push('1 SOUR gedcom-parser CLI');
+            lines.push('1 GEDC');
+            lines.push('2 VERS 5.5.1');
+            lines.push('1 CHAR UTF-8');
+            results.forEach(indi => {
+                const raw = indi.raw();
+                if (raw) {
+                    lines.push(...raw.split('\n').filter(line => line.trim()));
+                }
+            });
+            lines.push('0 TRLR');
+            writeFileSync(options.output, lines.join('\n'), 'utf-8');
+            console.log(formatSuccess(`Extracted ${results.length} individuals to ${options.output}`));
+        }
+        catch (error) {
+            handleError(error, 'Failed to extract individuals');
+        }
+    });
+}

package/dist/cli/commands/find.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerFindCommand(program: Command): void;
+//# sourceMappingURL=find.d.ts.map

package/dist/cli/commands/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/find.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0G1D"}

package/dist/cli/commands/find.js

@@ -0,0 +1,97 @@
+import GedcomTree from '../../utils/parser.js';
+import { formatHeader, formatListItem, formatJson, formatId, formatName, formatDate, formatWarning, } from '../utils/formatters.js';
+import { readGedcomFile, handleError, cleanGedcomName, formatLifespan } from '../utils/helpers.js';
+export function registerFindCommand(program) {
+    program
+        .command('find <file> [query]')
+        .description('Find individuals in a GEDCOM file')
+        .option('--id <id>', 'Find by GEDCOM ID')
+        .option('--name <name>', 'Find by name (substring search)')
+        .option('--birth-year <year>', 'Filter by birth year')
+        .option('--death-year <year>', 'Filter by death year')
+        .option('-j, --json', 'Output in JSON format')
+        .action((file, query, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            const individuals = tree.indis();
+            const results = [];
+            // Collect all individuals that match filters
+            individuals.forEach((indi) => {
+                let matches = true;
+                // Filter by ID
+                if (options.id && indi.id !== options.id) {
+                    matches = false;
+                }
+                // Filter by name (substring search, case insensitive)
+                if ((options.name || query) && matches) {
+                    const searchName = (options.name || query || '').toLowerCase();
+                    const name = cleanGedcomName(indi.NAME?.toValue()).toLowerCase();
+                    if (!name.includes(searchName)) {
+                        matches = false;
+                    }
+                }
+                // Filter by birth year
+                if (options.birthYear && matches) {
+                    const year = options.birthYear;
+                    const birthDate = indi.BIRT?.DATE?.toValue();
+                    if (!birthDate?.includes(String(year))) {
+                        matches = false;
+                    }
+                }
+                // Filter by death year
+                if (options.deathYear && matches) {
+                    const year = options.deathYear;
+                    const deathDate = indi.DEAT?.DATE?.toValue();
+                    if (!deathDate?.includes(String(year))) {
+                        matches = false;
+                    }
+                }
+                if (matches) {
+                    results.push(indi);
+                }
+            });
+            if (options.json) {
+                const jsonResults = results.map(indi => ({
+                    id: indi.id,
+                    name: cleanGedcomName(indi.NAME?.toValue()),
+                    birthDate: indi.BIRT?.DATE?.toValue() || null,
+                    birthPlace: indi.BIRT?.PLAC?.value || null,
+                    deathDate: indi.DEAT?.DATE?.toValue() || null,
+                    deathPlace: indi.DEAT?.PLAC?.value || null,
+                    sex: indi.SEX?.value || null,
+                }));
+                console.log(formatJson({ count: jsonResults.length, individuals: jsonResults }));
+            }
+            else {
+                if (results.length === 0) {
+                    console.log(formatWarning('No individuals found matching the criteria'));
+                }
+                else {
+                    console.log(formatHeader(`Found ${results.length} individual(s)\n`));
+                    results.forEach(indi => {
+                        const name = cleanGedcomName(indi.NAME?.toValue());
+                        const birthDate = indi.BIRT?.DATE?.toValue();
+                        const deathDate = indi.DEAT?.DATE?.toValue();
+                        const lifespan = formatLifespan(birthDate, deathDate);
+                        console.log(formatListItem(`${formatId(indi.id)} ${formatName(name)} ${lifespan}`));
+                        // Show birth place if available
+                        const birthPlace = indi.BIRT?.PLAC?.value;
+                        if (birthPlace) {
+                            console.log(formatListItem(`Birth: ${formatDate(birthDate)} in ${birthPlace}`, 1));
+                        }
+                        // Show death place if available
+                        const deathPlace = indi.DEAT?.PLAC?.value;
+                        if (deathPlace) {
+                            console.log(formatListItem(`Death: ${formatDate(deathDate)} in ${deathPlace}`, 1));
+                        }
+                        console.log();
+                    });
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, 'Failed to search GEDCOM file');
+        }
+    });
+}

package/dist/cli/commands/info.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerInfoCommand(program: Command): void;
+//# sourceMappingURL=info.d.ts.map

package/dist/cli/commands/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkF1D"}

package/dist/cli/commands/info.js

@@ -0,0 +1,80 @@
+import GedcomTree from '../../utils/parser.js';
+import { formatHeader, formatLabel, formatValue, formatCount, formatJson, formatSuccess, } from '../utils/formatters.js';
+import { readGedcomFile, handleError } from '../utils/helpers.js';
+export function registerInfoCommand(program) {
+    program
+        .command('info <file>')
+        .description('Display basic information about a GEDCOM file')
+        .option('-j, --json', 'Output in JSON format')
+        .option('-v, --verbose', 'Show detailed information')
+        .action((file, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            const individuals = tree.indis();
+            const families = tree.fams();
+            const sources = tree.sours();
+            const repos = tree.repos();
+            const objes = tree.objes();
+            const submitters = tree.subms();
+            // Get GEDCOM version from header
+            const header = tree.HEAD;
+            const version = header?.GEDC?.VERS?.value || 'Unknown';
+            const info = {
+                file,
+                version,
+                individuals: individuals?.length || 0,
+                families: families?.length || 0,
+                sources: sources?.length || 0,
+                repositories: repos?.length || 0,
+                mediaObjects: objes?.length || 0,
+                submitters: submitters?.length || 0,
+            };
+            if (options.json) {
+                console.log(formatJson(info));
+            }
+            else {
+                console.log(formatSuccess('GEDCOM file parsed successfully\n'));
+                console.log(formatHeader('File Information'));
+                console.log(`${formatLabel('File')} ${formatValue(file)}`);
+                console.log(`${formatLabel('GEDCOM Version')} ${formatValue(version)}`);
+                console.log();
+                console.log(formatHeader('Statistics'));
+                console.log(`${formatLabel('Individuals')} ${formatCount(individuals?.length || 0)}`);
+                console.log(`${formatLabel('Families')} ${formatCount(families?.length || 0)}`);
+                console.log(`${formatLabel('Sources')} ${formatCount(sources?.length || 0)}`);
+                console.log(`${formatLabel('Repositories')} ${formatCount(repos?.length || 0)}`);
+                console.log(`${formatLabel('Media Objects')} ${formatCount(objes?.length || 0)}`);
+                console.log(`${formatLabel('Submitters')} ${formatCount(submitters?.length || 0)}`);
+                if (options.verbose) {
+                    console.log();
+                    console.log(formatHeader('Additional Details'));
+                    // Most common surnames
+                    const surnames = new Map();
+                    individuals.forEach((indi) => {
+                        const name = indi.NAME?.toValue();
+                        if (name) {
+                            const match = name.match(/\/(.+?)\//);
+                            if (match) {
+                                const surname = match[1];
+                                surnames.set(surname, (surnames.get(surname) || 0) + 1);
+                            }
+                        }
+                    });
+                    const topSurnames = Array.from(surnames.entries())
+                        .sort((a, b) => b[1] - a[1])
+                        .slice(0, 5);
+                    if (topSurnames.length > 0) {
+                        console.log(`${formatLabel('Most Common Surnames')}`);
+                        topSurnames.forEach(([surname, count]) => {
+                            console.log(`  - ${surname}: ${formatCount(count)}`);
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, 'Failed to parse GEDCOM file');
+        }
+    });
+}

package/dist/cli/commands/merge.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerMergeCommand(program: Command): void;
+//# sourceMappingURL=merge.d.ts.map

package/dist/cli/commands/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgH3D"}

package/dist/cli/commands/merge.js

@@ -0,0 +1,93 @@
+import { writeFileSync } from 'fs';
+import GedcomTree from '../../utils/parser.js';
+import { formatSuccess } from '../utils/formatters.js';
+import { readGedcomFile, handleError } from '../utils/helpers.js';
+export function registerMergeCommand(program) {
+    program
+        .command('merge <files...>')
+        .description('Merge multiple GEDCOM files')
+        .requiredOption('-o, --output <file>', 'Output file path (required)')
+        .option('--dedupe', 'Attempt to detect and merge duplicates (basic implementation)')
+        .action((files, options) => {
+        try {
+            if (files.length < 2) {
+                console.error('At least 2 files are required for merging');
+                process.exit(1);
+            }
+            const allIndividuals = [];
+            const allFamilies = [];
+            const seenIds = new Set();
+            let idCounter = 1;
+            // Parse all files
+            files.forEach(file => {
+                const content = readGedcomFile(file);
+                const { gedcom: tree } = GedcomTree.parse(content);
+                const individuals = tree.indis();
+                const families = tree.fams();
+                // Add individuals with unique IDs
+                individuals.forEach(indi => {
+                    let id = indi.id;
+                    // If dedupe is enabled, check for duplicates (basic check by name and birth date)
+                    if (options.dedupe) {
+                        const name = indi.NAME?.toValue();
+                        const birthDate = indi.BIRT?.DATE?.toValue();
+                        const duplicate = allIndividuals.find(existing => {
+                            return existing.NAME?.toValue() === name &&
+                                existing.BIRT?.DATE?.toValue() === birthDate;
+                        });
+                        if (duplicate) {
+                            // Skip duplicate
+                            return;
+                        }
+                    }
+                    // Ensure unique ID
+                    while (seenIds.has(id)) {
+                        id = `@I${idCounter++}@`;
+                    }
+                    seenIds.add(id);
+                    // Store with original object (we'll need to update ID in output)
+                    allIndividuals.push({ ...indi, newId: id });
+                });
+                // Add families with unique IDs
+                families.forEach(fam => {
+                    let id = fam.id;
+                    while (seenIds.has(id)) {
+                        id = `@F${idCounter++}@`;
+                    }
+                    seenIds.add(id);
+                    allFamilies.push({ ...fam, newId: id });
+                });
+            });
+            // Create merged GEDCOM
+            const lines = [];
+            lines.push('0 HEAD');
+            lines.push('1 SOUR gedcom-parser CLI');
+            lines.push('1 GEDC');
+            lines.push('2 VERS 5.5.1');
+            lines.push('1 CHAR UTF-8');
+            // Add all individuals
+            allIndividuals.forEach(indi => {
+                const raw = indi.raw?.() || '';
+                if (raw) {
+                    // Replace old ID with new ID if needed
+                    const updatedRaw = raw.replace(new RegExp(`^0 ${indi.id} INDI`, 'm'), `0 ${indi.newId} INDI`);
+                    lines.push(...updatedRaw.split('\n').filter(line => line.trim()));
+                }
+            });
+            // Add all families
+            allFamilies.forEach(fam => {
+                const raw = fam.raw?.() || '';
+                if (raw) {
+                    const updatedRaw = raw.replace(new RegExp(`^0 ${fam.id} FAM`, 'm'), `0 ${fam.newId} FAM`);
+                    lines.push(...updatedRaw.split('\n').filter(line => line.trim()));
+                }
+            });
+            lines.push('0 TRLR');
+            writeFileSync(options.output, lines.join('\n'), 'utf-8');
+            console.log(formatSuccess(`Merged ${files.length} files (${allIndividuals.length} individuals, ${allFamilies.length} families) into ${options.output}`));
+        }
+        catch (error) {
+            handleError(error, 'Failed to merge GEDCOM files');
+        }
+    });
+}

package/dist/cli/commands/relatives.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerRelativesCommand(program: Command): void;
+//# sourceMappingURL=relatives.d.ts.map

package/dist/cli/commands/relatives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relatives.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/relatives.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuBpC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwF/D"}