linkedin-secret-sauce 0.4.0 → 0.5.0

package/dist/enrichment/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Enrichment Utilities
+ */
+export { isPersonalEmail, isBusinessEmail, isPersonalDomain, PERSONAL_DOMAINS } from './personal-domains';
+export { isDisposableEmail, isDisposableDomain, DISPOSABLE_DOMAINS } from './disposable-domains';
+export { isValidEmailSyntax, isRoleAccount, asciiFold, cleanNamePart, hostnameFromUrl, extractLinkedInUsername, } from './validation';

package/dist/enrichment/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Enrichment Utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLinkedInUsername = exports.hostnameFromUrl = exports.cleanNamePart = exports.asciiFold = exports.isRoleAccount = exports.isValidEmailSyntax = exports.DISPOSABLE_DOMAINS = exports.isDisposableDomain = exports.isDisposableEmail = exports.PERSONAL_DOMAINS = exports.isPersonalDomain = exports.isBusinessEmail = exports.isPersonalEmail = void 0;
+var personal_domains_1 = require("./personal-domains");
+Object.defineProperty(exports, "isPersonalEmail", { enumerable: true, get: function () { return personal_domains_1.isPersonalEmail; } });
+Object.defineProperty(exports, "isBusinessEmail", { enumerable: true, get: function () { return personal_domains_1.isBusinessEmail; } });
+Object.defineProperty(exports, "isPersonalDomain", { enumerable: true, get: function () { return personal_domains_1.isPersonalDomain; } });
+Object.defineProperty(exports, "PERSONAL_DOMAINS", { enumerable: true, get: function () { return personal_domains_1.PERSONAL_DOMAINS; } });
+var disposable_domains_1 = require("./disposable-domains");
+Object.defineProperty(exports, "isDisposableEmail", { enumerable: true, get: function () { return disposable_domains_1.isDisposableEmail; } });
+Object.defineProperty(exports, "isDisposableDomain", { enumerable: true, get: function () { return disposable_domains_1.isDisposableDomain; } });
+Object.defineProperty(exports, "DISPOSABLE_DOMAINS", { enumerable: true, get: function () { return disposable_domains_1.DISPOSABLE_DOMAINS; } });
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "isValidEmailSyntax", { enumerable: true, get: function () { return validation_1.isValidEmailSyntax; } });
+Object.defineProperty(exports, "isRoleAccount", { enumerable: true, get: function () { return validation_1.isRoleAccount; } });
+Object.defineProperty(exports, "asciiFold", { enumerable: true, get: function () { return validation_1.asciiFold; } });
+Object.defineProperty(exports, "cleanNamePart", { enumerable: true, get: function () { return validation_1.cleanNamePart; } });
+Object.defineProperty(exports, "hostnameFromUrl", { enumerable: true, get: function () { return validation_1.hostnameFromUrl; } });
+Object.defineProperty(exports, "extractLinkedInUsername", { enumerable: true, get: function () { return validation_1.extractLinkedInUsername; } });

package/dist/enrichment/utils/personal-domains.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Personal Email Domain Detection
+ *
+ * Detects personal email domains (Gmail, Yahoo, Outlook, etc.) that should
+ * be filtered out when looking for business emails.
+ */
+/**
+ * Set of known personal email domains
+ */
+export declare const PERSONAL_DOMAINS: Set<string>;
+/**
+ * Check if an email is from a personal domain
+ *
+ * @param email - Email address to check
+ * @returns true if the email is from a personal domain
+ */
+export declare function isPersonalEmail(email: string): boolean;
+/**
+ * Check if an email is from a business domain
+ *
+ * @param email - Email address to check
+ * @returns true if the email is NOT from a personal domain
+ */
+export declare function isBusinessEmail(email: string): boolean;
+/**
+ * Check if a domain is a personal email domain
+ *
+ * @param domain - Domain to check
+ * @returns true if the domain is a personal email domain
+ */
+export declare function isPersonalDomain(domain: string): boolean;

package/dist/enrichment/utils/personal-domains.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Personal Email Domain Detection
+ *
+ * Detects personal email domains (Gmail, Yahoo, Outlook, etc.) that should
+ * be filtered out when looking for business emails.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERSONAL_DOMAINS = void 0;
+exports.isPersonalEmail = isPersonalEmail;
+exports.isBusinessEmail = isBusinessEmail;
+exports.isPersonalDomain = isPersonalDomain;
+/**
+ * Set of known personal email domains
+ */
+exports.PERSONAL_DOMAINS = new Set([
+    // Gmail ecosystem
+    'gmail.com',
+    'googlemail.com',
+    // Microsoft ecosystem
+    'outlook.com',
+    'hotmail.com',
+    'live.com',
+    'msn.com',
+    // Yahoo
+    'yahoo.com',
+    'ymail.com',
+    'yahoo.co.uk',
+    'yahoo.fr',
+    'yahoo.de',
+    'yahoo.es',
+    'yahoo.it',
+    'yahoo.ca',
+    'yahoo.com.au',
+    'yahoo.co.jp',
+    'yahoo.co.in',
+    // Apple
+    'icloud.com',
+    'me.com',
+    'mac.com',
+    // Other major providers
+    'aol.com',
+    'proton.me',
+    'protonmail.com',
+    'pm.me',
+    'gmx.com',
+    'gmx.de',
+    'gmx.net',
+    'mail.com',
+    'zoho.com',
+    // International
+    'yandex.ru',
+    'yandex.com',
+    'mail.ru',
+    'qq.com',
+    '163.com',
+    '126.com',
+    'naver.com',
+    'daum.net',
+]);
+/**
+ * Check if an email is from a personal domain
+ *
+ * @param email - Email address to check
+ * @returns true if the email is from a personal domain
+ */
+function isPersonalEmail(email) {
+    if (!email || typeof email !== 'string')
+        return true;
+    const at = email.indexOf('@');
+    if (at < 0)
+        return true;
+    const domain = email.slice(at + 1).toLowerCase();
+    return exports.PERSONAL_DOMAINS.has(domain);
+}
+/**
+ * Check if an email is from a business domain
+ *
+ * @param email - Email address to check
+ * @returns true if the email is NOT from a personal domain
+ */
+function isBusinessEmail(email) {
+    return !isPersonalEmail(email);
+}
+/**
+ * Check if a domain is a personal email domain
+ *
+ * @param domain - Domain to check
+ * @returns true if the domain is a personal email domain
+ */
+function isPersonalDomain(domain) {
+    if (!domain || typeof domain !== 'string')
+        return false;
+    return exports.PERSONAL_DOMAINS.has(domain.toLowerCase());
+}

package/dist/enrichment/utils/validation.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Email Validation Utilities
+ *
+ * Provides email syntax validation and name parsing utilities.
+ */
+/**
+ * Validate email syntax
+ *
+ * @param email - Email address to validate
+ * @returns true if the email has valid syntax
+ */
+export declare function isValidEmailSyntax(email: string): boolean;
+/**
+ * Check if an email is a role account
+ *
+ * @param email - Email address to check
+ * @returns true if the email is a role account
+ */
+export declare function isRoleAccount(email: string): boolean;
+/**
+ * ASCII fold diacritics for name normalization
+ * e.g., "Jos" -> "Jose", "Mller" -> "Muller"
+ */
+export declare function asciiFold(s: string): string;
+/**
+ * Clean name part: lowercase, remove diacritics, keep only a-z0-9
+ */
+export declare function cleanNamePart(s: string): string;
+/**
+ * Extract hostname from URL
+ *
+ * @param url - URL to extract hostname from
+ * @returns hostname without www prefix, or null if invalid
+ */
+export declare function hostnameFromUrl(url?: string | null): string | null;
+/**
+ * Extract LinkedIn username from URL
+ *
+ * @param url - LinkedIn URL
+ * @returns username or null if not found
+ */
+export declare function extractLinkedInUsername(url: string): string | null;

package/dist/enrichment/utils/validation.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Email Validation Utilities
+ *
+ * Provides email syntax validation and name parsing utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmailSyntax = isValidEmailSyntax;
+exports.isRoleAccount = isRoleAccount;
+exports.asciiFold = asciiFold;
+exports.cleanNamePart = cleanNamePart;
+exports.hostnameFromUrl = hostnameFromUrl;
+exports.extractLinkedInUsername = extractLinkedInUsername;
+/**
+ * Validate email syntax
+ *
+ * @param email - Email address to validate
+ * @returns true if the email has valid syntax
+ */
+function isValidEmailSyntax(email) {
+    if (!email || typeof email !== 'string')
+        return false;
+    if (email.includes(' '))
+        return false;
+    const parts = email.split('@');
+    if (parts.length !== 2)
+        return false;
+    const [local, domain] = parts;
+    if (!local || !domain)
+        return false;
+    if (!domain.includes('.'))
+        return false;
+    if (local.length > 64)
+        return false;
+    if (domain.length > 255)
+        return false;
+    return true;
+}
+/**
+ * Role account patterns (info@, support@, etc.)
+ */
+const ROLE_PATTERNS = [
+    /^info@/i,
+    /^support@/i,
+    /^admin@/i,
+    /^noreply@/i,
+    /^no-reply@/i,
+    /^contact@/i,
+    /^sales@/i,
+    /^help@/i,
+    /^team@/i,
+    /^hello@/i,
+    /^feedback@/i,
+    /^service@/i,
+    /^webmaster@/i,
+    /^postmaster@/i,
+    /^abuse@/i,
+    /^security@/i,
+    /^hostmaster@/i,
+    /^marketing@/i,
+    /^press@/i,
+    /^media@/i,
+    /^jobs@/i,
+    /^careers@/i,
+    /^hr@/i,
+    /^legal@/i,
+    /^billing@/i,
+    /^privacy@/i,
+];
+/**
+ * Check if an email is a role account
+ *
+ * @param email - Email address to check
+ * @returns true if the email is a role account
+ */
+function isRoleAccount(email) {
+    if (!email)
+        return false;
+    const emailLower = email.toLowerCase();
+    return ROLE_PATTERNS.some((pattern) => pattern.test(emailLower));
+}
+/**
+ * ASCII fold diacritics for name normalization
+ * e.g., "Jos" -> "Jose", "Mller" -> "Muller"
+ */
+function asciiFold(s) {
+    try {
+        return s.normalize('NFD').replace(/\p{Diacritic}+/gu, '');
+    }
+    catch {
+        return s;
+    }
+}
+/**
+ * Clean name part: lowercase, remove diacritics, keep only a-z0-9
+ */
+function cleanNamePart(s) {
+    const lower = asciiFold(String(s || '').toLowerCase());
+    return lower.replace(/[^a-z0-9]/g, '');
+}
+/**
+ * Extract hostname from URL
+ *
+ * @param url - URL to extract hostname from
+ * @returns hostname without www prefix, or null if invalid
+ */
+function hostnameFromUrl(url) {
+    if (!url)
+        return null;
+    try {
+        const u = new URL(url);
+        const h = u.hostname.toLowerCase();
+        return h.startsWith('www.') ? h.slice(4) : h;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract LinkedIn username from URL
+ *
+ * @param url - LinkedIn URL
+ * @returns username or null if not found
+ */
+function extractLinkedInUsername(url) {
+    if (!url)
+        return null;
+    const match = url.match(/linkedin\.com\/in\/([^/?]+)/);
+    return match ? match[1] : null;
+}

package/dist/enrichment/verification/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Email Verification Module
+ */
+export { verifyEmailMx } from './mx';

package/dist/enrichment/verification/index.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Email Verification Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyEmailMx = void 0;
+var mx_1 = require("./mx");
+Object.defineProperty(exports, "verifyEmailMx", { enumerable: true, get: function () { return mx_1.verifyEmailMx; } });

package/dist/enrichment/verification/mx.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MX Record Resolution and Email Verification
+ *
+ * Provides MX record resolution with timeout support and confidence scoring.
+ */
+import type { VerificationResult } from '../types';
+/**
+ * Verify an email address via MX record lookup
+ *
+ * @param email - Email address to verify
+ * @param options - Verification options
+ * @returns Verification result with confidence score
+ */
+export declare function verifyEmailMx(email: string, options?: {
+    timeoutMs?: number;
+}): Promise<VerificationResult>;

package/dist/enrichment/verification/mx.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * MX Record Resolution and Email Verification
+ *
+ * Provides MX record resolution with timeout support and confidence scoring.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyEmailMx = verifyEmailMx;
+const promises_1 = require("node:dns/promises");
+const disposable_domains_1 = require("../utils/disposable-domains");
+const validation_1 = require("../utils/validation");
+/**
+ * Resolve MX records with timeout
+ *
+ * @param domain - Domain to resolve
+ * @param timeoutMs - Timeout in milliseconds
+ * @returns Array of MX records or empty array on failure
+ */
+async function resolveMxWithTimeout(domain, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const result = await (0, promises_1.resolveMx)(domain);
+        return Array.isArray(result) ? result : [];
+    }
+    catch {
+        return [];
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Calculate confidence score based on verification factors
+ */
+function calculateConfidence(params) {
+    const { mxValid, isCatchAll, isRoleAccount, isDisposable, mxCount } = params;
+    if (!mxValid)
+        return 0;
+    let score = 20; // Base score for valid MX
+    // MX record count bonus
+    if (mxCount >= 2)
+        score += 20;
+    else if (mxCount === 1)
+        score += 10;
+    // Non-catch-all bonus (we assume catch-all if MX exists but can't verify)
+    if (!isCatchAll)
+        score += 30;
+    // Non-role account bonus
+    if (!isRoleAccount)
+        score += 20;
+    // Non-disposable bonus
+    if (!isDisposable)
+        score += 20;
+    return Math.min(100, Math.max(0, score));
+}
+/**
+ * Verify an email address via MX record lookup
+ *
+ * @param email - Email address to verify
+ * @param options - Verification options
+ * @returns Verification result with confidence score
+ */
+async function verifyEmailMx(email, options) {
+    const timeoutMs = options?.timeoutMs ?? 5000;
+    // Step 1: Syntax validation
+    if (!(0, validation_1.isValidEmailSyntax)(email)) {
+        return {
+            valid: false,
+            confidence: 0,
+            reason: 'syntax',
+            isCatchAll: false,
+            isRoleAccount: false,
+            isDisposable: false,
+        };
+    }
+    // Step 2: Disposable email detection
+    const disposable = (0, disposable_domains_1.isDisposableEmail)(email);
+    if (disposable) {
+        return {
+            valid: false,
+            confidence: 0,
+            reason: 'disposable',
+            isCatchAll: false,
+            isRoleAccount: false,
+            isDisposable: true,
+        };
+    }
+    // Step 3: Role account detection
+    const roleAccount = (0, validation_1.isRoleAccount)(email);
+    // Step 4: MX record validation
+    const domain = email.split('@')[1];
+    if (!domain) {
+        return {
+            valid: false,
+            confidence: 0,
+            reason: 'syntax',
+            isCatchAll: false,
+            isRoleAccount: roleAccount,
+            isDisposable: false,
+        };
+    }
+    try {
+        const mx = await resolveMxWithTimeout(domain, timeoutMs);
+        if (!mx || mx.length === 0) {
+            return {
+                valid: false,
+                confidence: 0,
+                reason: 'mx_missing',
+                isCatchAll: false,
+                isRoleAccount: roleAccount,
+                isDisposable: false,
+                mxRecords: [],
+            };
+        }
+        // Conservative: assume catch-all if MX exists (full detection requires SMTP handshake)
+        const catchAll = true;
+        // Calculate confidence
+        const confidence = calculateConfidence({
+            mxValid: true,
+            isCatchAll: catchAll,
+            isRoleAccount: roleAccount,
+            isDisposable: false,
+            mxCount: mx.length,
+        });
+        const valid = confidence >= 50;
+        // Determine reason
+        let reason = 'valid';
+        if (!valid) {
+            if (catchAll)
+                reason = 'catch_all';
+            else if (roleAccount)
+                reason = 'role_account';
+        }
+        const mxRecords = mx.map((m) => m.exchange);
+        return {
+            valid,
+            confidence,
+            reason,
+            isCatchAll: catchAll,
+            isRoleAccount: roleAccount,
+            isDisposable: false,
+            mxRecords,
+        };
+    }
+    catch (err) {
+        const error = err;
+        if (error &&
+            (error.code === 'ETIMEOUT' || error.name === 'AbortError' || error.message === 'timeout')) {
+            return {
+                valid: null,
+                confidence: 0,
+                reason: 'timeout',
+                isCatchAll: false,
+                isRoleAccount: roleAccount,
+                isDisposable: false,
+            };
+        }
+        return {
+            valid: null,
+            confidence: 0,
+            reason: 'error',
+            isCatchAll: false,
+            isRoleAccount: roleAccount,
+            isDisposable: false,
+        };
+    }
+}

package/dist/index.d.ts

@@ -1,14 +1,17 @@
-export { initializeLinkedInClient, getConfig } from './config';
-export type { LinkedInClientConfig } from './config';
-export { LinkedInClientError } from './utils/errors';
-export * from './cosiall-client';
-export * from './cookie-pool';
-export { parseFullProfile } from './parsers/profile-parser';
-export { parseSalesSearchResults } from './parsers/search-parser';
-export * from './linkedin-api';
-export * from './types';
-export type { LinkedInTenure, LinkedInPosition, LinkedInSpotlightBadge, SalesLeadSearchResult, } from './types';
-export * from './utils/metrics';
-export { getRequestHistory, clearRequestHistory } from './utils/request-history';
-export type { RequestHistoryEntry } from './utils/request-history';
-export * from './constants';
+export { initializeLinkedInClient, getConfig } from "./config";
+export type { LinkedInClientConfig } from "./config";
+export { LinkedInClientError } from "./utils/errors";
+export * from "./cosiall-client";
+export * from "./cookie-pool";
+export { parseFullProfile } from "./parsers/profile-parser";
+export { parseSalesSearchResults } from "./parsers/search-parser";
+export * from "./linkedin-api";
+export * from "./types";
+export type { LinkedInTenure, LinkedInPosition, LinkedInSpotlightBadge, SalesLeadSearchResult, } from "./types";
+export * from "./utils/metrics";
+export { getRequestHistory, clearRequestHistory, } from "./utils/request-history";
+export type { RequestHistoryEntry } from "./utils/request-history";
+export * from "./constants";
+export { createEnrichmentClient } from "./enrichment";
+export type { CanonicalEmail, EnrichmentCandidate, ProviderResult, ProviderFunc, ProviderName, EnrichmentClientConfig, EnrichmentClient, ProvidersConfig, EnrichmentOptions, BatchEnrichmentOptions, HunterConfig, ApolloConfig, SmartProspectConfig, LddConfig, DropcontactConfig, ConstructConfig, CacheAdapter, CostCallback, EnrichmentLogger, VerificationResult, SmartProspectContact, SmartProspectSearchFilters, LddProfileData, LddApiResponse, } from "./enrichment";
+export { isPersonalEmail, isBusinessEmail, isPersonalDomain, isDisposableEmail, isDisposableDomain, isValidEmailSyntax, isRoleAccount, verifyEmailMx, PERSONAL_DOMAINS, DISPOSABLE_DOMAINS, DEFAULT_PROVIDER_ORDER, PROVIDER_COSTS, } from "./enrichment";

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearRequestHistory = exports.getRequestHistory = exports.parseSalesSearchResults = exports.parseFullProfile = exports.LinkedInClientError = exports.getConfig = exports.initializeLinkedInClient = void 0;
+exports.PROVIDER_COSTS = exports.DEFAULT_PROVIDER_ORDER = exports.DISPOSABLE_DOMAINS = exports.PERSONAL_DOMAINS = exports.verifyEmailMx = exports.isRoleAccount = exports.isValidEmailSyntax = exports.isDisposableDomain = exports.isDisposableEmail = exports.isPersonalDomain = exports.isBusinessEmail = exports.isPersonalEmail = exports.createEnrichmentClient = exports.clearRequestHistory = exports.getRequestHistory = exports.parseSalesSearchResults = exports.parseFullProfile = exports.LinkedInClientError = exports.getConfig = exports.initializeLinkedInClient = void 0;
 var config_1 = require("./config");
 Object.defineProperty(exports, "initializeLinkedInClient", { enumerable: true, get: function () { return config_1.initializeLinkedInClient; } });
 Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
@@ -33,3 +33,22 @@ var request_history_1 = require("./utils/request-history");
 Object.defineProperty(exports, "getRequestHistory", { enumerable: true, get: function () { return request_history_1.getRequestHistory; } });
 Object.defineProperty(exports, "clearRequestHistory", { enumerable: true, get: function () { return request_history_1.clearRequestHistory; } });
 __exportStar(require("./constants"), exports);
+// Email Enrichment Module
+var enrichment_1 = require("./enrichment");
+Object.defineProperty(exports, "createEnrichmentClient", { enumerable: true, get: function () { return enrichment_1.createEnrichmentClient; } });
+var enrichment_2 = require("./enrichment");
+// Utilities
+Object.defineProperty(exports, "isPersonalEmail", { enumerable: true, get: function () { return enrichment_2.isPersonalEmail; } });
+Object.defineProperty(exports, "isBusinessEmail", { enumerable: true, get: function () { return enrichment_2.isBusinessEmail; } });
+Object.defineProperty(exports, "isPersonalDomain", { enumerable: true, get: function () { return enrichment_2.isPersonalDomain; } });
+Object.defineProperty(exports, "isDisposableEmail", { enumerable: true, get: function () { return enrichment_2.isDisposableEmail; } });
+Object.defineProperty(exports, "isDisposableDomain", { enumerable: true, get: function () { return enrichment_2.isDisposableDomain; } });
+Object.defineProperty(exports, "isValidEmailSyntax", { enumerable: true, get: function () { return enrichment_2.isValidEmailSyntax; } });
+Object.defineProperty(exports, "isRoleAccount", { enumerable: true, get: function () { return enrichment_2.isRoleAccount; } });
+// Verification
+Object.defineProperty(exports, "verifyEmailMx", { enumerable: true, get: function () { return enrichment_2.verifyEmailMx; } });
+// Constants
+Object.defineProperty(exports, "PERSONAL_DOMAINS", { enumerable: true, get: function () { return enrichment_2.PERSONAL_DOMAINS; } });
+Object.defineProperty(exports, "DISPOSABLE_DOMAINS", { enumerable: true, get: function () { return enrichment_2.DISPOSABLE_DOMAINS; } });
+Object.defineProperty(exports, "DEFAULT_PROVIDER_ORDER", { enumerable: true, get: function () { return enrichment_2.DEFAULT_PROVIDER_ORDER; } });
+Object.defineProperty(exports, "PROVIDER_COSTS", { enumerable: true, get: function () { return enrichment_2.PROVIDER_COSTS; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkedin-secret-sauce",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",