@visulima/email-verifier 0.0.1 → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+## @visulima/email-verifier 1.0.0 (2026-07-03)
+
+### Features
+
+* **email:** emailable-parity verification & enrichment packages ([#718](https://github.com/visulima/visulima/issues/718)) ([e2d8c1e](https://github.com/visulima/visulima/commit/e2d8c1e78e3e0c2548ece87b20d730dab60f677a))
+
+### Miscellaneous Chores
+
+* **release:** @visulima/email-verifier@1.0.0-alpha.1 [skip ci]\n\n## @visulima/email-verifier 1.0.0-alpha.1 (2026-06-30) ([2f54bf0](https://github.com/visulima/visulima/commit/2f54bf0d4eced72aea511f282df9c132e965aac7))
+
+
+### Dependencies
+
+* **@visulima/disposable-email-domains:** upgraded to 1.0.0
+* **@visulima/email-provider-mx:** upgraded to 1.0.0
+* **@visulima/free-email-domains:** upgraded to 1.0.0
+
+## @visulima/email-verifier 1.0.0-alpha.1 (2026-06-30)
+
+### Features
+
+* **email:** emailable-parity verification & enrichment packages ([#718](https://github.com/visulima/visulima/issues/718)) ([e2d8c1e](https://github.com/visulima/visulima/commit/e2d8c1e78e3e0c2548ece87b20d730dab60f677a))
+
+
+### Dependencies
+
+* **@visulima/disposable-email-domains:** upgraded to 1.0.0-alpha.18
+* **@visulima/email-provider-mx:** upgraded to 1.0.0-alpha.1
+* **@visulima/free-email-domains:** upgraded to 1.0.0-alpha.1

package/LICENSE.md

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 visulima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+<!-- DEPENDENCIES -->
+<!-- /DEPENDENCIES -->
+
+<!-- TYPE_DEPENDENCIES -->
+<!-- /TYPE_DEPENDENCIES -->

package/README.md

@@ -1,45 +1,150 @@
-# @visulima/email-verifier
+<!-- START_PACKAGE_OG_IMAGE_PLACEHOLDER -->
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+<a href="https://www.anolilab.com/open-source" align="center">
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+  <img src="__assets__/package-og.svg" alt="email-verifier" />
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+</a>
 
-## Purpose
+<h3 align="center">Mailer-free email address verification and enrichment: syntax, MX/SMTP probing, disposable/free/role detection, catch-all, provider & secure-email-gateway classification, typo suggestions, and a 0–100 quality score.</h3>
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@visulima/email-verifier`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+<!-- END_PACKAGE_OG_IMAGE_PLACEHOLDER -->
 
-## What is OIDC Trusted Publishing?
+<br />
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+<div align="center">
 
-## Setup Instructions
+[![typescript-image][typescript-badge]][typescript-url]
+[![mit licence][license-badge]][license]
+[![npm downloads][npm-downloads-badge]][npm-downloads]
+[![Chat][chat-badge]][chat]
+[![PRs Welcome][prs-welcome-badge]][prs-welcome]
 
-To properly configure OIDC trusted publishing for this package:
+</div>
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+---
+
+<div align="center">
+    <p>
+        <sup>
+            Daniel Bannert's open source work is supported by the community on <a href="https://github.com/sponsors/prisis">GitHub Sponsors</a>
+        </sup>
+    </p>
+</div>
 
-## DO NOT USE THIS PACKAGE
+---
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+`@visulima/email-verifier` validates and enriches an email address without
+pulling in a mail-sending stack. It mirrors the surface of commercial APIs like
+[emailable](https://emailable.com): syntax + domain + SMTP verification,
+catch-all / mailbox-full / greylist handling, disposable / free / role / no-reply
+detection, sub-address (tag) parsing, character & Unicode-symbol analysis,
+provider & Secure-Email-Gateway classification, misspelled-domain suggestions,
+name parsing, and a transparent 0–100 quality score — all aggregated into one
+`EmailVerificationReport`.
 
-## More Information
+> It is **mailer-free**: it does not depend on `@visulima/email`, so a
+> validation-only consumer never installs the 25 provider adapters.
 
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
+## Install
 
----
+```sh
+npm install @visulima/email-verifier
+```
+
+```sh
+yarn add @visulima/email-verifier
+```
+
+```sh
+pnpm add @visulima/email-verifier
+```
+
+## Usage
+
+```ts
+import { verifyEmail } from "@visulima/email-verifier";
+
+const report = await verifyEmail("john.doe@gmail.com");
+
+report.state; // "deliverable" | "risky" | "undeliverable" | "unknown"
+report.reason; // e.g. "accepted_email"
+report.score; // 0–100
+report.free; // true
+report.provider?.display; // "Google"
+report.name; // { firstName: "John", lastName: "Doe", fullName: "John Doe", confidence: "high" }
+```
+
+> **Network caveat:** SMTP verification connects to the recipient's mail server on
+> port 25. Many networks block outbound 25 and many servers tarpit or refuse
+> verification probes, so treat a `deferred`/`unknown` result as inconclusive
+> rather than undeliverable. Pass `{ offline: true }` to skip all network checks.
+
+### À la carte checks
+
+Every check and enrichment is also exported on its own subpath so you only pull
+in what you need:
+
+```ts
+import { validateSyntax } from "@visulima/email-verifier/checks/syntax";
+import { checkMxRecords } from "@visulima/email-verifier/checks/mx";
+import { verifySmtp } from "@visulima/email-verifier/checks/smtp";
+import { checkDisposable } from "@visulima/email-verifier/checks/disposable";
+import { checkFree } from "@visulima/email-verifier/checks/free";
+import { isRoleAccount, isNoReply } from "@visulima/email-verifier/checks/role";
+import { detectTag } from "@visulima/email-verifier/checks/tag";
+import { analyzeCharacters } from "@visulima/email-verifier/checks/character";
+import { analyzeSymbols } from "@visulima/email-verifier/checks/symbol";
+import { enrichProvider } from "@visulima/email-verifier/enrich/provider";
+import { suggestEmailTypo } from "@visulima/email-verifier/enrich/typo";
+import { parseName } from "@visulima/email-verifier/enrich/name";
+import { scoreReport } from "@visulima/email-verifier/score";
+```
+
+### Scoring
+
+The score is a transparent additive model over a 100-point baseline. Every weight
+is overridable:
+
+```ts
+import { verifyEmail } from "@visulima/email-verifier";
+
+const report = await verifyEmail("info@example.com", {
+    weights: { role: 40, free: 0 },
+});
+```
+
+## Related
+
+- [`@visulima/disposable-email-domains`](https://github.com/visulima/visulima/tree/main/packages/email/disposable-email-domains) — disposable-domain list (used by `checks/disposable`).
+- [`@visulima/free-email-domains`](https://github.com/visulima/visulima/tree/main/packages/email/free-email-domains) — free-provider domain list (used by `checks/free`).
+- [`@visulima/email-provider-mx`](https://github.com/visulima/visulima/tree/main/packages/email/email-provider-mx) — MX-host → provider/SEG map (used by `enrich/provider`).
+- [`@visulima/email`](https://github.com/visulima/visulima/tree/main/packages/email/email) — the mail-sending library (send-side validation only).
+
+## Supported Node.js Versions
+
+Libraries in this ecosystem make the best effort to track [Node.js' release schedule](https://github.com/nodejs/release#release-schedule).
+
+## Contributing
+
+If you would like to help take a look at the [list of issues](https://github.com/visulima/visulima/issues) and check our [Contributing](.github/CONTRIBUTING.md) guidelines.
+
+## Credits
+
+- [Daniel Bannert](https://github.com/prisis)
+- [All Contributors](https://github.com/visulima/visulima/graphs/contributors)
+
+## License
+
+The visulima email-verifier is open-sourced software licensed under the [MIT][license]
 
-**Maintained for OIDC setup purposes only**
+[typescript-badge]: https://img.shields.io/badge/TypeScript-3178C6.svg?style=for-the-badge&logo=typescript&logoColor=white "typescript"
+[typescript-url]: https://www.typescriptlang.org/ "TypeScript"
+[license-badge]: https://img.shields.io/npm/l/@visulima/email-verifier?color=blueviolet&style=for-the-badge "license"
+[license]: LICENSE.md "license"
+[npm-downloads-badge]: https://img.shields.io/npm/dm/@visulima/email-verifier?logo=npm&style=for-the-badge&labelColor=333333&color=476ad3 "npm downloads"
+[npm-downloads]: https://www.npmjs.com/package/@visulima/email-verifier "npm downloads"
+[chat-badge]: https://img.shields.io/discord/677851225179ita68409?color=7289da&label=Discord&logo=discord&logoColor=ffffff&style=for-the-badge "chat"
+[chat]: https://discord.gg/J8GxgQ7Xv5 "chat"
+[prs-welcome-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge "PRs welcome"
+[prs-welcome]: https://github.com/visulima/visulima/blob/main/.github/CONTRIBUTING.md "PRs welcome"

package/dist/checks/character.d.ts

@@ -0,0 +1,31 @@
+/**
+* The result of local-part character analysis.
+*/
+interface CharacterResult {
+  /** Ratio of digits to total characters in the local part (0–1). */
+  digitRatio: number;
+  /** True when the local part looks irregular / machine-generated / risky. */
+  irregular: boolean;
+  /** Length of the local part. */
+  length: number;
+  /** Human-readable reasons contributing to the `irregular` verdict. */
+  reasons: string[];
+}
+/**
+* Analyzes the local part of an email for irregular characteristics that
+* correlate with low-quality, spam-trap, or machine-generated addresses.
+*
+* Heuristic and intentionally conservative — it flags *patterns* (excessive
+* length, digit-heavy locals, long unpronounceable consonant runs, long repeats)
+* rather than asserting invalidity.
+* @param email The email address to analyze.
+* @returns The character analysis result.
+* @example
+* ```ts
+* import { analyzeCharacters } from "@visulima/email-verifier/checks/character";
+*
+* analyzeCharacters("aaaaaaa@example.com").irregular; // long repeat ⇒ true
+* ```
+*/
+declare const analyzeCharacters: (email: string) => CharacterResult;
+export { type CharacterResult, analyzeCharacters, analyzeCharacters as default };

package/dist/checks/character.js

@@ -0,0 +1 @@
+import{splitAddress as h}from"../packem_shared/extractDomain-CYJf1_0N.js";const g=30,l=.6,i=7,o=/\d/g,c=/[bcdfghj-np-tvwxz]{7,}/,u=/(.)\1{4,}/,p=a=>{const r=h(a);if(!r)return{digitRatio:0,irregular:!0,length:0,reasons:["invalid-format"]};const{localPart:t}=r,e=[],s=(t.match(o)??[]).length,n=t.length===0?0:s/t.length;return t.length>g&&e.push("excessive-length"),n>=l&&t.length>4&&e.push("digit-heavy"),c.test(t)&&e.push(`consonant-run-${String(i)}+`),u.test(t)&&e.push("repeated-character"),{digitRatio:n,irregular:e.length>0,length:t.length,reasons:e}};export{p as analyzeCharacters,p as default};

package/dist/checks/disposable.d.ts

@@ -0,0 +1 @@
+export { type DisposableEmailOptions, areDisposableEmails, isDisposableEmail as default, isDisposableDomain, isDisposableEmail, isListLoaded, preload, setDomains } from '@visulima/disposable-email-domains';

package/dist/checks/disposable.js

@@ -0,0 +1 @@
+import{areDisposableEmails as i,isDisposableEmail as e,isDisposableDomain as o,isDisposableEmail as l,isListLoaded as m,preload as p,setDomains as D}from"@visulima/disposable-email-domains";export{i as areDisposableEmails,e as default,o as isDisposableDomain,l as isDisposableEmail,m as isListLoaded,p as preload,D as setDomains};

package/dist/checks/free.d.ts

@@ -0,0 +1 @@
+export { type FreeEmailOptions, areFreeEmails, isFreeEmail as default, isFreeDomain, isFreeEmail, isListLoaded, preload, setDomains } from '@visulima/free-email-domains';

package/dist/checks/free.js

@@ -0,0 +1 @@
+import{areFreeEmails as i,isFreeEmail as s,isFreeDomain as r,isFreeEmail as m,isListLoaded as o,preload as l,setDomains as d}from"@visulima/free-email-domains";export{i as areFreeEmails,s as default,r as isFreeDomain,m as isFreeEmail,o as isListLoaded,l as preload,d as setDomains};

package/dist/checks/mx.d.ts

@@ -0,0 +1 @@
+export { type C as Cache, type I as InMemoryCache, type M as MxCheckOptions, type b as MxCheckResult, type c as MxRecord, type d as MxResolution, e as checkMxRecords, e as default } from "../packem_shared/mx.d-NAesS5sg.js";

package/dist/checks/mx.js

@@ -0,0 +1 @@
+import{createRequire as d}from"node:module";const u=d(import.meta.url),o=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,f=e=>{if(typeof o<"u"&&o.versions&&o.versions.node){const[r,s]=o.versions.node.split(".").map(Number);if(r>22||r===22&&s>=3||r===20&&s>=16)return o.getBuiltinModule(e)}return u(e)},{resolveMx:v,resolve4:p,resolve6:h}=f("node:dns/promises"),c=async e=>{try{if((await p(e)).length>0)return!0}catch{}try{return(await h(e)).length>0}catch{return!1}},l=e=>({domainResolves:!0,records:[{exchange:e,priority:0}],resolvedVia:"address",valid:!0}),g=async(e,r)=>{try{const s=(await v(e)).map(t=>({exchange:t.exchange,priority:t.priority}));return s.length>0?{domainResolves:!0,records:s.toSorted((t,a)=>t.priority-a.priority),resolvedVia:"mx",valid:!0}:r&&await c(e)?l(e):{domainResolves:!1,records:[],resolvedVia:"none",valid:!1}}catch(s){return r&&await c(e)?l(e):{domainResolves:!1,error:s instanceof Error?s.message:String(s),resolvedVia:"none",valid:!1}}},y=async(e,r={})=>{const{fallbackToAddress:s=!0}=r,t=r.ttl??36e5,a=`${e}:${String(s)}`;if(r.cache){const n=await r.cache.get(a);if(n!==void 0)return n}const i=await g(e,s);return r.cache&&await r.cache.set(a,i,t),i};export{y as checkMxRecords,y as default};

package/dist/checks/role.d.ts

@@ -0,0 +1,41 @@
+/**
+* Local-part prefixes that indicate a no-reply / do-not-reply mailbox.
+* These are a strict subset of {@link ROLE_ACCOUNT_PREFIXES}.
+*/
+declare const NO_REPLY_PREFIXES: ReadonlySet<string>;
+/**
+* Local-part prefixes that identify a role-based (shared, function) mailbox
+* rather than a personal one. Superset of RFC 2142 plus common real-world roles.
+*/
+declare const ROLE_ACCOUNT_PREFIXES: ReadonlySet<string>;
+/**
+* Determines whether an email address is a role-based account.
+*
+* Matches the whole local part, the part before any `+tag`, and each
+* dot/dash/underscore-separated token (so `sales.john`, `info+news`, and
+* `no-reply` are all caught).
+* @param email The email address to check.
+* @param customPrefixes Optional additional role prefixes to recognize.
+* @returns True when the address is a role account.
+* @example
+* ```ts
+* import { isRoleAccount } from "@visulima/email-verifier/checks/role";
+*
+* isRoleAccount("info@example.com"); // true
+* isRoleAccount("john.doe@example.com"); // false
+* ```
+*/
+declare const isRoleAccount: (email: string, customPrefixes?: Iterable<string>) => boolean;
+/**
+* Determines whether an email address is a no-reply / do-not-reply mailbox.
+* @param email The email address to check.
+* @returns True when the address is a no-reply mailbox.
+* @example
+* ```ts
+* import { isNoReply } from "@visulima/email-verifier/checks/role";
+*
+* isNoReply("no-reply@example.com"); // true
+* ```
+*/
+declare const isNoReply: (email: string) => boolean;
+export { NO_REPLY_PREFIXES, ROLE_ACCOUNT_PREFIXES, isRoleAccount as default, isNoReply, isRoleAccount };

package/dist/checks/role.js

@@ -0,0 +1 @@
+import{splitAddress as c}from"../packem_shared/extractDomain-CYJf1_0N.js";const l=new Set(["do-not-reply","do_not_reply","donotreply","no-reply","no_reply","noreply","notification","notifications","notify"]),n=new Set(["abuse","accounting","accounts","admin","administrator","all","billing","board","career","careers","ceo","cfo","compliance","contact","contacts","cto","customercare","customerservice","dev","developer","devnull","do-not-reply","do_not_reply","donotreply","enquiries","enquiry","everyone","feedback","finance","ftp","hello","help","helpdesk","hi","hostmaster","hr","info","information","inquiries","inquiry","investor","investors","it","jobs","legal","list","list-request","mail","mailer-daemon","mailerdaemon","majordomo","marketing","media","members","newsletter","no-reply","no_reply","noc","noreply","notification","notifications","notify","office","operations","order","orders","postmaster","press","privacy","purchasing","recruitment","register","registration","root","sales","secretary","security","service","services","shop","spam","staff","subscribe","support","sysadmin","team","tech","test","unsubscribe","usenet","uucp","webmaster","welcome","www"]),u=/[.\-_+]/,o=(t,e,r)=>{if(e.has(t))return!0;if(r){for(const s of r)if(s.toLowerCase()===t)return!0}return!1},m=(t,e)=>{const r=c(t);if(!r)return!1;const{localPart:s}=r,i=s.split("+")[0];if(o(s,n,e)||o(i,n,e))return!0;const a=i.split(u).filter(Boolean);return a.length>1&&a.some(p=>o(p,n,e))},d=t=>{const e=c(t);if(!e)return!1;const r=e.localPart.split("+")[0];return o(e.localPart,l)||o(r,l)};export{l as NO_REPLY_PREFIXES,n as ROLE_ACCOUNT_PREFIXES,m as default,d as isNoReply,m as isRoleAccount};

package/dist/checks/smtp.d.ts

@@ -0,0 +1,93 @@
+import { b as MxCheckResult, C as Cache, c as MxRecord } from "../packem_shared/mx.d-NAesS5sg.js";
+/**
+* Options for SMTP verification.
+*/
+interface SmtpVerificationOptions {
+  /** Cache for the underlying MX lookup. */
+  cache?: Cache<MxCheckResult>;
+  /**
+  * Number of random, almost-certainly-nonexistent addresses to probe for
+  * catch-all detection. More probes reduce false positives from
+  * deferred-rejection servers. Set to 0 to disable.
+  * @default 1
+  */
+  catchAllProbes?: number;
+  /**
+  * MAIL FROM address used during the probe; defaults to `verify@` followed by
+  * the HELO host.
+  */
+  fromEmail?: string;
+  /**
+  * HELO/EHLO hostname presented to the remote server.
+  * @default the address domain
+  */
+  heloHost?: string;
+  /**
+  * Pre-resolved MX records to probe, in priority order. When provided, the
+  * probe skips its own DNS lookup — the orchestrator passes the records it
+  * already resolved so the domain is not queried twice.
+  */
+  mxRecords?: MxRecord[];
+  port?: number;
+  /**
+  * Number of times to retry the whole probe on a temporary (greylist) failure.
+  * @default 1
+  */
+  retries?: number;
+  /**
+  * Delay in milliseconds between greylist retries.
+  * @default 5000
+  */
+  retryDelay?: number;
+  /** Cache for SMTP results. */
+  smtpCache?: Cache<SmtpVerificationResult>;
+  timeout?: number;
+  ttl?: number;
+}
+/**
+* Detailed result of an SMTP verification attempt.
+*/
+interface SmtpVerificationResult {
+  /** True when the server accepts a random, nonexistent recipient (catch-all). */
+  acceptAll?: boolean;
+  /** The numeric SMTP status code for the real RCPT TO. */
+  code?: number;
+  /** True when the result is inconclusive due to a temporary failure (greylisting). */
+  deferred?: boolean;
+  /** Final enhanced status code for the real RCPT (e.g. "5.1.1"), if present. */
+  enhancedCode?: string;
+  error?: string;
+  /** True when the mailbox exists but is over quota (452/552 / 4.2.2). */
+  mailboxFull?: boolean;
+  mxRecords?: MxRecord[];
+  smtpResponse?: string;
+  /** True when the real RCPT TO was accepted (250). */
+  valid: boolean;
+}
+/**
+* Verifies an email address over SMTP without sending a message.
+*
+* Performs the full handshake (greeting → EHLO/HELO → MAIL FROM → RCPT TO),
+* then — when the real recipient is accepted — issues additional RCPT TO probes
+* for random addresses to detect catch-all (accept-all) servers. Temporary
+* (4xx) failures are surfaced as `deferred` and retried up to `retries` times to
+* survive greylisting, and over-quota responses set `mailboxFull`.
+*
+* Note: many networks block outbound port 25 and many servers refuse or tarpit
+* verification probes, so treat a `deferred`/errored result as inconclusive
+* rather than undeliverable.
+* @param email The email address to verify.
+* @param options Verification options.
+* @returns The detailed SMTP verification result.
+* @example
+* ```ts
+* import { verifySmtp } from "@visulima/email-verifier/checks/smtp";
+*
+* const result = await verifySmtp("user@example.com", { catchAllProbes: 2 });
+* if (result.valid && !result.acceptAll) {
+*     console.log("Mailbox exists");
+* }
+* ```
+*/
+declare const verifySmtp: (email: string, options?: SmtpVerificationOptions) => Promise<SmtpVerificationResult>;
+export { type SmtpVerificationOptions, type SmtpVerificationResult, verifySmtp as default, verifySmtp };

package/dist/checks/smtp.js

@@ -0,0 +1,7 @@
+import{createRequire as x}from"node:module";import{splitAddress as M}from"../packem_shared/extractDomain-CYJf1_0N.js";import{checkMxRecords as j}from"./mx.js";const $=x(import.meta.url),h=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,R=r=>{if(typeof h<"u"&&h.versions&&h.versions.node){const[e,t]=h.versions.node.split(".").map(Number);if(e>22||e===22&&t>=3||e===20&&t>=16)return h.getBuiltinModule(r)}return $(r)},{Socket:T}=R("node:net"),y=/[\u0000-\u001F\u007F]/,k=/\b([245]\.\d{1,3}\.\d{1,3})\b/,C=/^(\d{3})(?: |$)/,E=/\r?\n/,g="abcdefghijklmnopqrstuvwxyz0123456789",P=(r=20)=>{let e="";for(let t=0;t<r;t+=1)e+=g[Math.floor(Math.random()*g.length)]??"";return e},S=async r=>new Promise(e=>{setTimeout(e,r)});class _{transcript="";buffer="";completed=[];failure;finished=!1;socket;waiter;constructor(e){this.socket=e,e.on("data",o=>{this.transcript+=o.toString(),this.buffer+=o.toString(),this.drain()});const t=o=>{this.finished=!0,this.failure=o??new Error("Connection closed by server"),this.completed.length===0&&this.waiter&&(this.waiter.reject(this.failure),this.waiter=void 0)};e.on("error",t),e.on("close",()=>{t()}),e.on("timeout",()=>{t(new Error("SMTP socket timeout")),e.destroy()})}async command(e){return this.transcript+=`${e}\r
+`,this.socket.write(`${e}\r
+`),this.readReply()}close(){try{this.socket.write(`QUIT\r
+`)}catch{}this.socket.removeAllListeners(),this.socket.destroy()}async readReply(){if(this.completed.length>0)return this.completed.shift();if(this.finished)throw this.failure??new Error("Connection closed");return new Promise((e,t)=>{this.waiter={reject:t,resolve:e}})}drain(){const e=this.buffer.split(E);this.buffer=e.pop()??"";let t=[];for(const o of e){t.push(o);const a=C.exec(o);if(a){const i=t.join(`
+`),c=k.exec(i)?.[1];this.completed.push({code:Number.parseInt(a[1],10),enhanced:c,text:i}),t=[]}}if(t.length>0&&(this.buffer=`${t.join(`
+`)}
+${this.buffer}`),this.waiter&&this.completed.length>0){const{resolve:o}=this.waiter;this.waiter=void 0,o(this.completed.shift())}}}const A=r=>{const{code:e,enhanced:t}=r;return e>=200&&e<300?{code:e,enhancedCode:t,valid:!0}:e===452||e===552||t==="4.2.2"||t==="5.2.2"?{code:e,deferred:e===452,enhancedCode:t,mailboxFull:!0,valid:!1}:e>=400&&e<500?{code:e,deferred:!0,enhancedCode:t,valid:!1}:{code:e,enhancedCode:t,valid:!1}},L=async(r,e,t)=>new Promise((o,a)=>{const i=new T;i.setTimeout(t);const c=f=>{i.removeAllListeners(),i.destroy(),a(f)},l=()=>{c(new Error("SMTP connection timeout"))};i.once("error",c),i.once("timeout",l),i.connect(e,r,()=>{i.removeListener("error",c),i.removeListener("timeout",l),o(new _(i))})}),H=async(r,e,t,o)=>{const{catchAllProbes:a=1,port:i=25,timeout:c=5e3}=o,l=o.heloHost??e,f=o.fromEmail??`verify@${l}`;let n;try{n=await L(t.exchange,i,c);const d=await n.readReply();if(d.code!==220)return{deferred:!0,error:`Unexpected greeting: ${d.text}`,valid:!1};let s=await n.command(`EHLO ${l}`);if(s.code!==250&&(s=await n.command(`HELO ${l}`),s.code!==250))return{deferred:!0,error:`HELO rejected: ${s.text}`,valid:!1};const u=await n.command(`MAIL FROM:<${f}>`);if(u.code!==250)return{deferred:!0,error:`MAIL FROM rejected: ${u.text}`,valid:!1};const b=await n.command(`RCPT TO:<${r}>`),p=A(b);let m;if(p.valid&&a>0){m=!0;for(let v=0;v<a;v+=1){const w=await n.command(`RCPT TO:<${P()}@${e}>`);if(w.code<200||w.code>=300){m=!1;break}}}return{...p,acceptAll:m,smtpResponse:n.transcript}}finally{n?.close()}},O=async(r,e,t,o)=>{let a="SMTP verification did not complete";for(const i of t)try{return await H(r,e,i,o)}catch(c){a=c instanceof Error?c.message:String(c)}return{deferred:!0,error:a,valid:!1}},I=r=>{if(r.heloHost!==void 0&&y.test(r.heloHost))return{error:"Invalid heloHost: control characters are not allowed",valid:!1};if(r.fromEmail!==void 0&&y.test(r.fromEmail))return{error:"Invalid fromEmail: control characters are not allowed",valid:!1}},B=async(r,e={})=>{const t=M(r);if(!t)return{error:"Invalid email format",valid:!1};const{domain:o}=t,a=I(e);if(a)return a;const{retries:i=1,retryDelay:c=5e3,ttl:l=36e5}=e,f=["smtp",t.address,e.fromEmail??"",String(e.port??25),e.heloHost??"",String(e.catchAllProbes??1),(e.mxRecords??[]).map(s=>s.exchange).join(",")].join("|");if(e.smtpCache){const s=await e.smtpCache.get(f);if(s!==void 0)return s}let n=e.mxRecords;if(!n||n.length===0){const s=await j(o,{cache:e.cache,fallbackToAddress:!1});if(!s.valid||!s.records||s.records.length===0)return{error:s.error??"No MX records found",mxRecords:s.records,valid:!1};n=s.records}let d={error:"SMTP verification did not complete",valid:!1};for(let s=0;s<=i&&(d=await O(t.address,o,n,e),!(!d.deferred||s===i));s+=1)await S(c);return d={...d,mxRecords:n},e.smtpCache&&!d.deferred&&await e.smtpCache.set(f,d,l),d};export{B as default,B as verifySmtp};

package/dist/checks/symbol.d.ts

@@ -0,0 +1,29 @@
+/**
+* The result of symbol / Unicode analysis.
+*/
+interface SymbolResult {
+  /** True when the address mixes Unicode scripts (a homoglyph-spoofing signal). */
+  hasMixedScripts: boolean;
+  /** True when the address contains non-ASCII characters anywhere. */
+  hasNonAscii: boolean;
+  /** True when the local part or domain contains symbol/emoji characters. */
+  hasSymbols: boolean;
+  /** The distinct Unicode scripts detected (e.g. ["Latin", "Cyrillic"]). */
+  scripts: string[];
+}
+/**
+* Detects symbols, emoji, and mixed Unicode scripts in an email address.
+*
+* Mixed-script local parts (e.g. Latin + Cyrillic) are a classic homoglyph /
+* spoofing signal; symbol or emoji characters indicate a non-standard address.
+* @param email The email address to analyze.
+* @returns The symbol analysis result.
+* @example
+* ```ts
+* import { analyzeSymbols } from "@visulima/email-verifier/checks/symbol";
+*
+* analyzeSymbols("раypal@example.com").hasMixedScripts; // true (Cyrillic "ра")
+* ```
+*/
+declare const analyzeSymbols: (email: string) => SymbolResult;
+export { type SymbolResult, analyzeSymbols, analyzeSymbols as default };

package/dist/checks/symbol.js

@@ -0,0 +1 @@
+import{splitAddress as n}from"../packem_shared/extractDomain-CYJf1_0N.js";const l=new RegExp("\\P{ASCII}","u"),c=new RegExp("\\p{S}","u"),p=[["Latin",new RegExp("\\p{Script=Latin}","u")],["Cyrillic",new RegExp("\\p{Script=Cyrillic}","u")],["Greek",new RegExp("\\p{Script=Greek}","u")],["Han",new RegExp("\\p{Script=Han}","u")],["Hiragana",new RegExp("\\p{Script=Hiragana}","u")],["Katakana",new RegExp("\\p{Script=Katakana}","u")],["Hangul",new RegExp("\\p{Script=Hangul}","u")],["Arabic",new RegExp("\\p{Script=Arabic}","u")],["Hebrew",new RegExp("\\p{Script=Hebrew}","u")]],g=i=>{const e=n(i);if(!e)return{hasMixedScripts:!1,hasNonAscii:!1,hasSymbols:!1,scripts:[]};const t=`${e.localPart}${e.domain}`,r=p.filter(([,a])=>a.test(t)).map(([a])=>a);return{hasMixedScripts:[e.localPart,...e.domain.split(".").filter(Boolean)].some(a=>p.filter(([,s])=>s.test(a)).length>1),hasNonAscii:l.test(e.address),hasSymbols:c.test(t),scripts:r}};export{g as analyzeSymbols,g as default};

package/dist/checks/syntax.d.ts

@@ -0,0 +1,19 @@
+/**
+* Validates an email address format according to basic RFC standards.
+*
+* This is intentionally pragmatic rather than a full RFC 5322 parser: it rejects
+* the address shapes that never deliver (missing parts, consecutive dots, leading
+* or trailing dots, hyphen-bounded domain labels) while accepting the long tail
+* of legitimate real-world addresses.
+* @param email The email address string to validate.
+* @returns True if the email address is syntactically valid, false otherwise.
+* @example
+* ```ts
+* import { validateSyntax } from "@visulima/email-verifier/checks/syntax";
+*
+* validateSyntax("user@example.com"); // true
+* validateSyntax("user@@example.com"); // false
+* ```
+*/
+declare const validateSyntax: (email: string) => boolean;
+export { validateSyntax as default, validateSyntax };

package/dist/checks/syntax.js

@@ -0,0 +1 @@
+import{splitAddress as n}from"../packem_shared/extractDomain-CYJf1_0N.js";const r=/^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/,l=/^[\p{L}\p{N}-]+$/u,o=s=>{if(!s||typeof s!="string"||!r.test(s)||s.includes(".."))return!1;const a=n(s);if(!a)return!1;const{domain:t,localPart:i}=a;return i.startsWith(".")||i.endsWith(".")||!t.includes(".")||t.startsWith("-")||t.endsWith("-")?!1:t.split(".").every(e=>e.length>0&&!e.startsWith("-")&&!e.endsWith("-")&&l.test(e))};export{o as default,o as validateSyntax};

package/dist/checks/tag.d.ts

@@ -0,0 +1,31 @@
+/**
+* The result of sub-address (tag) detection.
+*/
+interface TagResult {
+  /** The local part with the tag and separator removed (the "real" mailbox). */
+  baseLocalPart: string;
+  /** True when a sub-address tag was found. */
+  hasTag: boolean;
+  /** The separator that introduced the tag (`+` or `-`), if any. */
+  separator?: string;
+  /** The detected tag value (everything after the separator), if any. */
+  tag?: string;
+}
+/**
+* Detects plus-addressing / sub-addressing tags in an email address.
+*
+* Most providers (Gmail, Outlook, iCloud, Proton, …) delimit the tag with `+`;
+* a few (Fastmail, Yahoo) use `-`. The returned {@link TagResult.baseLocalPart}
+* is the canonical mailbox with the tag stripped.
+* @param email The email address to inspect.
+* @returns The tag detection result.
+* @example
+* ```ts
+* import { detectTag } from "@visulima/email-verifier/checks/tag";
+*
+* detectTag("user+newsletter@gmail.com");
+* // { hasTag: true, tag: "newsletter", separator: "+", baseLocalPart: "user" }
+* ```
+*/
+declare const detectTag: (email: string) => TagResult;
+export { type TagResult, detectTag as default, detectTag };

package/dist/checks/tag.js

@@ -0,0 +1 @@
+import{splitAddress as c}from"../packem_shared/extractDomain-CYJf1_0N.js";const l=new Set(["fastmail.com","fastmail.fm","yahoo.co.uk","yahoo.com"]),f=r=>{const e=c(r);if(!e)return{baseLocalPart:"",hasTag:!1};const{domain:o,localPart:a}=e,s=a.indexOf("+");if(s>0)return{baseLocalPart:a.slice(0,s),hasTag:!0,separator:"+",tag:a.slice(s+1)};if(l.has(o)){const t=a.indexOf("-");if(t>0)return{baseLocalPart:a.slice(0,t),hasTag:!0,separator:"-",tag:a.slice(t+1)}}return{baseLocalPart:a,hasTag:!1}};export{f as default,f as detectTag};

package/dist/enrich/name.d.ts

@@ -0,0 +1,32 @@
+/**
+* A name parsed from an email's local part.
+*/
+interface NameResult {
+  /** Confidence in the parse: `high` (clear separator), `medium` (camelCase), `low` (heuristic), `none`. */
+  confidence: "high" | "low" | "medium" | "none";
+  /** The detected first name, capitalized, if any. */
+  firstName?: string;
+  /** The detected first + last name joined, if any. */
+  fullName?: string;
+  /** The detected last name, capitalized, if any. */
+  lastName?: string;
+}
+/**
+* Heuristically parses a person's name from the local part of an email address.
+*
+* Handles separator-delimited (`john.doe`), camelCase (`johnDoe`), and
+* single-token local parts, stripping trailing digits. This is best-effort name
+* parsing only — no gender detection — and confidence is reported so callers
+* can decide how much to trust it.
+* @param email The email address to parse.
+* @returns The parsed name and a confidence level.
+* @example
+* ```ts
+* import { parseName } from "@visulima/email-verifier/enrich/name";
+*
+* parseName("john.doe@example.com");
+* // { firstName: "John", lastName: "Doe", fullName: "John Doe", confidence: "high" }
+* ```
+*/
+declare const parseName: (email: string) => NameResult;
+export { type NameResult, parseName as default, parseName };

package/dist/enrich/name.js

@@ -0,0 +1 @@
+import{splitAddress as p}from"../packem_shared/extractDomain-CYJf1_0N.js";const f=/[.\-_]/,u=/^[a-z]+(?:[A-Z][a-z]+)+$/,d=/\d+$/,N=/\d/,r=e=>e.length===0?e:e.charAt(0).toUpperCase()+e.slice(1).toLowerCase(),h=e=>e.replaceAll(/([a-z])([A-Z])/g,"$1 $2").split(" "),g=e=>{const s=p(e);if(!s)return{confidence:"none"};const i=e.trim().lastIndexOf("@"),t=(i>0?e.trim().slice(0,i):s.localPart).split("+")[0].replace(d,"");if(t.length===0)return{confidence:"none"};let a,o;if(f.test(t))a=t.split(f).filter(Boolean),o="high";else if(u.test(t))a=h(t),o="medium";else return N.test(t)?{confidence:"none"}:{confidence:"low",firstName:r(t),fullName:r(t)};const n=a.map(m=>m.replace(d,"")).filter(Boolean);if(n.length===0)return{confidence:"none"};const l=r(n[0]);if(n.length===1)return{confidence:"low",firstName:l,fullName:l};const c=r(n.at(-1));return{confidence:o,firstName:l,fullName:`${l} ${c}`,lastName:c}};export{g as default,g as parseName};

package/dist/enrich/provider.d.ts

@@ -0,0 +1,40 @@
+import { MxProviderInfo } from '@visulima/email-provider-mx';
+export { type MxProviderInfo, classifyMx, classifyMxRecords, isSecureEmailGateway } from '@visulima/email-provider-mx';
+import { c as MxRecord, b as MxCheckResult, C as Cache } from "../packem_shared/mx.d-NAesS5sg.js";
+/**
+* The enriched provider details for an email address.
+*/
+interface ProviderDetails {
+  /** True when the resolving MX is a Secure Email Gateway (Proofpoint, Mimecast, …). */
+  isSecureEmailGateway: boolean;
+  /** The MX records the classification was derived from. */
+  mxRecords: MxRecord[];
+  /** The classified provider, or `undefined` when no MX matched a known provider. */
+  provider?: MxProviderInfo;
+}
+/**
+* Options for provider enrichment.
+*/
+interface ProviderEnrichOptions {
+  cache?: Cache<MxCheckResult>;
+  ttl?: number;
+}
+/**
+* Resolves an email address's mailbox/SEG provider from its MX records.
+*
+* Looks up the domain's MX records, then classifies the highest-priority host
+* via `@visulima/email-provider-mx` — emailable's "SMTP Provider Details" plus
+* Secure-Email-Gateway detection.
+* @param email The email address to enrich.
+* @param options Caching options for the MX lookup.
+* @returns The provider details, including the MX records used.
+* @example
+* ```ts
+* import { enrichProvider } from "@visulima/email-verifier/enrich/provider";
+*
+* const details = await enrichProvider("user@gmail.com");
+* console.log(details.provider?.display); // "Google"
+* ```
+*/
+declare const enrichProvider: (email: string, options?: ProviderEnrichOptions) => Promise<ProviderDetails>;
+export { type ProviderDetails, type ProviderEnrichOptions, enrichProvider as default, enrichProvider };

package/dist/enrich/provider.js

@@ -0,0 +1 @@
+import{classifyMxRecords as t}from"@visulima/email-provider-mx";import{classifyMx as y,classifyMxRecords as u,isSecureEmailGateway as p}from"@visulima/email-provider-mx";import{checkMxRecords as o}from"../checks/mx.js";import{extractDomain as i}from"../packem_shared/extractDomain-CYJf1_0N.js";const d=async(c,a={})=>{const r=i(c);if(!r)return{isSecureEmailGateway:!1,mxRecords:[]};const e=(await o(r,{cache:a.cache,fallbackToAddress:!1,ttl:a.ttl})).records??[];if(e.length===0)return{isSecureEmailGateway:!1,mxRecords:e};const s=t(e);return{isSecureEmailGateway:s?.type==="seg",mxRecords:e,provider:s}};export{y as classifyMx,u as classifyMxRecords,d as default,d as enrichProvider,p as isSecureEmailGateway};

package/dist/enrich/typo.d.ts

@@ -0,0 +1,59 @@
+/**
+* A suggested correction for a likely-misspelled email address.
+*/
+interface TypoSuggestion {
+  /** The suggested corrected domain. */
+  domain: string;
+  /** The full suggested address (original local part + corrected domain). */
+  full: string;
+}
+/**
+* Options for typo suggestion.
+*/
+interface TypoOptions {
+  /** Popular full domains to match against (e.g. `gmail.com`). */
+  domains?: string[];
+  /**
+  * Distance threshold for the full-domain match.
+  * @default 2
+  */
+  domainThreshold?: number;
+  /** Popular second-level domains to match against (e.g. `gmail`). */
+  secondLevelDomains?: string[];
+  /**
+  * Distance threshold for the second-level match.
+  * @default 2
+  */
+  secondLevelThreshold?: number;
+  /** Popular top-level domains to match against (e.g. `com`). */
+  topLevelDomains?: string[];
+  /**
+  * Distance threshold for the top-level match.
+  * @default 2
+  */
+  topLevelThreshold?: number;
+}
+declare const sift3Distance: (s1: string, s2: string) => number;
+/**
+* Suggests a corrected domain for a likely-misspelled one, using the mailcheck
+* algorithm (full-domain match, then second-level + top-level matching).
+* @param domain The domain to check.
+* @param options Override domain lists and thresholds.
+* @returns The suggested domain, or `undefined` when the domain looks fine.
+*/
+declare const suggestDomain: (domain: string, options?: TypoOptions) => string | undefined;
+/**
+* Suggests a corrected email address when the domain looks misspelled
+* (e.g. `user@gmial.com` → `user@gmail.com`).
+* @param email The email address to check.
+* @param options Override domain lists and thresholds.
+* @returns A {@link TypoSuggestion}, or `undefined` when nothing looks wrong.
+* @example
+* ```ts
+* import { suggestEmailTypo } from "@visulima/email-verifier/enrich/typo";
+*
+* suggestEmailTypo("user@gmial.com")?.full; // "user@gmail.com"
+* ```
+*/
+declare const suggestEmailTypo: (email: string, options?: TypoOptions) => TypoSuggestion | undefined;
+export { type TypoOptions, type TypoSuggestion, suggestEmailTypo as default, sift3Distance, suggestDomain, suggestEmailTypo };

package/dist/enrich/typo.js

@@ -0,0 +1 @@
+import{splitAddress as d}from"../packem_shared/extractDomain-CYJf1_0N.js";const g=["aol.com","fastmail.com","gmail.com","googlemail.com","hotmail.com","hotmail.co.uk","icloud.com","live.com","mail.com","me.com","msn.com","outlook.com","proton.me","protonmail.com","yahoo.com","yahoo.co.uk","ymail.com","zoho.com"],v=["aol","fastmail","gmail","googlemail","hotmail","icloud","live","mail","me","msn","outlook","proton","protonmail","yahoo","ymail","zoho"],f=["co.uk","com","de","edu","fr","gov","info","io","me","net","org"],p=5,L=(n,o,e)=>{for(let l=0;l<p;l+=1){if(e+l<n.length&&n[e+l]===o[e])return{offset1:l,offset2:0};if(e+l<o.length&&n[e]===o[e+l])return{offset1:0,offset2:l}}return{offset1:0,offset2:0}},y=(n,o)=>{if(n.length===0)return o.length;if(o.length===0)return n.length;let e=0,l=0,t=0,i=0;for(;e+l<n.length&&e+t<o.length;)n[e+l]===o[e+t]?i+=1:{offset1:l,offset2:t}=L(n,o,e),e+=1;return(n.length+o.length)/2-i},c=(n,o,e)=>{let l=Number.POSITIVE_INFINITY,t;for(const i of o){if(n===i)return n;const s=y(n,i);s<l&&(l=s,t=i)}return l<=e?t:void 0},T=n=>{const o=n.split(".");return o.length>=3&&f.includes(o.slice(-2).join("."))?{secondLevel:o.slice(0,-2).join("."),topLevel:o.slice(-2).join(".")}:{secondLevel:o.slice(0,-1).join("."),topLevel:o.at(-1)??""}},k=(n,o={})=>{const e=n.toLowerCase().trim(),l=o.domains??g,t=o.secondLevelDomains??v,i=o.topLevelDomains??f;if(l.includes(e))return;const s=c(e,l,o.domainThreshold??2);if(s&&s!==e)return s;const{secondLevel:r,topLevel:m}=T(e);if(!r||!m)return;const u=c(r,t,o.secondLevelThreshold??2)??r,h=c(m,i,o.topLevelThreshold??2)??m,a=`${u}.${h}`;return a===e?void 0:a},I=(n,o={})=>{const e=d(n);if(!e)return;const l=k(e.domain,o);if(l)return{domain:l,full:`${e.localPart}@${l}`}};export{I as default,y as sift3Distance,k as suggestDomain,I as suggestEmailTypo};

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+export { type CharacterResult, analyzeCharacters } from "./checks/character.js";
+export { type DisposableEmailOptions, areDisposableEmails, isDisposableDomain, isDisposableEmail } from '@visulima/disposable-email-domains';
+export { type FreeEmailOptions, areFreeEmails, isFreeDomain, isFreeEmail } from '@visulima/free-email-domains';
+export { type C as Cache, I as InMemoryCache, type a as InMemoryCacheOptions, type M as MxCheckOptions, type b as MxCheckResult, type c as MxRecord, type d as MxResolution, e as checkMxRecords } from "./packem_shared/mx.d-NAesS5sg.js";
+export { NO_REPLY_PREFIXES, ROLE_ACCOUNT_PREFIXES, isNoReply, default as isRoleAccount } from "./checks/role.js";
+export { type SmtpVerificationOptions, type SmtpVerificationResult, default as verifySmtp } from "./checks/smtp.js";
+export { type SymbolResult, analyzeSymbols } from "./checks/symbol.js";
+export { default as validateSyntax } from "./checks/syntax.js";
+export { type TagResult, default as detectTag } from "./checks/tag.js";
+export { type NameResult, default as parseName } from "./enrich/name.js";
+export { type ProviderDetails, type ProviderEnrichOptions, default as enrichProvider } from "./enrich/provider.js";
+export { type TypoOptions, type TypoSuggestion, sift3Distance, suggestDomain, default as suggestEmailTypo } from "./enrich/typo.js";
+export { D as DEFAULT_WEIGHTS, type a as DomainReport, type E as EmailVerificationReport, type S as ScoreInput, type b as ScoreResult, type c as ScoreWeights, type V as VerificationState, s as scoreReport } from "./packem_shared/score.d-BTcZnl2L.js";
+export { type VerifyEmailOptions, default as verifyEmail } from "./verify-email.js";
+export { type MxProviderInfo, classifyMx, classifyMxRecords, isSecureEmailGateway } from '@visulima/email-provider-mx';
+/**
+* The split parts of an email address.
+*/
+interface AddressParts {
+  /** The full normalized (lowercased, trimmed) address. */
+  address: string;
+  /** The domain part, lowercased and with any trailing dot stripped. */
+  domain: string;
+  /** The local part (before the `@`), lowercased. */
+  localPart: string;
+}
+/**
+* Splits an email address into its normalized local and domain parts.
+*
+* Uses the last `@` as the separator so quoted local parts containing `@` are
+* handled the same way the SMTP/MX probes treat them. Inputs containing
+* whitespace (after trimming) are rejected so a payload that embeds a CRLF
+* followed by a second SMTP command cannot be smuggled into the SMTP dialogue
+* by callers of the standalone probes.
+* @param email The email address to split.
+* @returns The normalized parts, or `undefined` if the address is structurally invalid.
+*/
+declare const splitAddress: (email: string) => AddressParts | undefined;
+/**
+* Extracts and normalizes just the domain from an email address.
+* @param email The email address to extract the domain from.
+* @returns The normalized domain, or `undefined` if invalid.
+*/
+declare const extractDomain: (email: string) => string | undefined;
+export { type AddressParts, extractDomain, splitAddress };

package/dist/index.js

@@ -0,0 +1 @@
+import{analyzeCharacters as a}from"./checks/character.js";import{checkMxRecords as s}from"./checks/mx.js";import{NO_REPLY_PREFIXES as m,ROLE_ACCOUNT_PREFIXES as f,isNoReply as i,default as l}from"./checks/role.js";import{default as x}from"./checks/smtp.js";import{analyzeSymbols as d}from"./checks/symbol.js";import{default as u}from"./checks/syntax.js";import{default as n}from"./checks/tag.js";import{default as R}from"./enrich/name.js";import{default as F}from"./enrich/provider.js";import{sift3Distance as T,suggestDomain as _,default as b}from"./enrich/typo.js";import{extractDomain as v,splitAddress as A}from"./packem_shared/extractDomain-CYJf1_0N.js";import{InMemoryCache as I}from"./packem_shared/InMemoryCache-DyBUMeKq.js";import{DEFAULT_WEIGHTS as N,default as P}from"./score.js";import{default as O}from"./verify-email.js";import{areDisposableEmails as G,isDisposableDomain as U,isDisposableEmail as X}from"@visulima/disposable-email-domains";import{areFreeEmails as w,isFreeDomain as H,isFreeEmail as W}from"@visulima/free-email-domains";import{classifyMx as j,classifyMxRecords as q,isSecureEmailGateway as B}from"@visulima/email-provider-mx";export{N as DEFAULT_WEIGHTS,I as InMemoryCache,m as NO_REPLY_PREFIXES,f as ROLE_ACCOUNT_PREFIXES,a as analyzeCharacters,d as analyzeSymbols,G as areDisposableEmails,w as areFreeEmails,s as checkMxRecords,j as classifyMx,q as classifyMxRecords,n as detectTag,F as enrichProvider,v as extractDomain,U as isDisposableDomain,X as isDisposableEmail,H as isFreeDomain,W as isFreeEmail,i as isNoReply,l as isRoleAccount,B as isSecureEmailGateway,R as parseName,P as scoreReport,T as sift3Distance,A as splitAddress,_ as suggestDomain,b as suggestEmailTypo,u as validateSyntax,O as verifyEmail,x as verifySmtp};

package/dist/packem_shared/InMemoryCache-DyBUMeKq.js

@@ -0,0 +1 @@
+import{LRUCache as a}from"lru-cache";class l{cache;constructor(c={}){const{max:e=500,ttl:t=36e5}=c;this.cache=new a({max:e,ttl:t})}clear=async()=>{this.cache.clear()};delete=async c=>{this.cache.delete(c)};get=async c=>this.cache.get(c);set=async(c,e,t)=>{this.cache.set(c,e,{ttl:t})}}export{l as InMemoryCache};

package/dist/packem_shared/extractDomain-CYJf1_0N.js

@@ -0,0 +1 @@
+const a=/\.$/,i=/\s/,o=s=>{if(!s||typeof s!="string")return;const e=s.trim().toLowerCase();if(i.test(e))return;const t=e.lastIndexOf("@");if(t<=0||t===e.length-1)return;const r=e.slice(0,t),n=e.slice(t+1).replace(a,"");if(!(!r||!n))return{address:e,domain:n,localPart:r}},c=s=>o(s)?.domain;export{c as extractDomain,o as splitAddress};

package/dist/packem_shared/mx.d-NAesS5sg.d.ts

@@ -0,0 +1,117 @@
+/**
+* Generic cache interface for caching any type of data.
+* Implementations can use in-memory cache, LRU cache, Redis, etc.
+*/
+interface Cache<T = unknown> {
+  /**
+  * Clears all cached entries.
+  */
+  clear: () => Promise<void>;
+  /**
+  * Deletes a cached entry.
+  * @param key The cache key.
+  */
+  delete: (key: string) => Promise<void>;
+  /**
+  * Gets a cached value.
+  * @param key The cache key.
+  * @returns The cached value or undefined if not found or expired.
+  */
+  get: (key: string) => Promise<T | undefined>;
+  /**
+  * Sets a cached value.
+  * @param key The cache key.
+  * @param value The value to cache.
+  * @param ttl Time-to-live in milliseconds.
+  */
+  set: (key: string, value: T, ttl: number) => Promise<void>;
+}
+/**
+* Options for creating an in-memory cache.
+*/
+interface InMemoryCacheOptions {
+  /**
+  * Maximum number of entries in the cache.
+  * @default 500
+  */
+  max?: number;
+  /**
+  * Default TTL in milliseconds for entries.
+  * @default 3600000 (1 hour)
+  */
+  ttl?: number;
+}
+/**
+* Default in-memory cache implementation using LRU cache.
+*
+* Shared by the MX and SMTP probes so repeated lookups against the same domain
+* (e.g. when verifying a list) avoid redundant DNS/socket work.
+*/
+declare class InMemoryCache<T extends object = Record<string, unknown>> implements Cache<T> {
+  private readonly cache;
+  constructor(options?: InMemoryCacheOptions);
+  clear: () => Promise<void>;
+  delete: (key: string) => Promise<void>;
+  get: (key: string) => Promise<T | undefined>;
+  set: (key: string, value: T, ttl: number) => Promise<void>;
+}
+/**
+* MX record information.
+*/
+interface MxRecord {
+  exchange: string;
+  priority: number;
+}
+/**
+* How the domain's mail-acceptance was established.
+*
+* - `mx`: the domain published MX records.
+* - `address`: the domain has no MX but resolves to an A/AAAA record, so by RFC 5321 §5.1 the address itself is treated as an implicit MX.
+* - `none`: neither MX nor address records exist.
+*/
+type MxResolution = "address" | "mx" | "none";
+/**
+* Result of an MX/domain check.
+*/
+interface MxCheckResult {
+  /** True when the domain itself resolves but publishes no MX records. */
+  domainResolves: boolean;
+  error?: string;
+  records?: MxRecord[];
+  resolvedVia: MxResolution;
+  /** True when the domain can accept mail (has MX or A/AAAA records). */
+  valid: boolean;
+}
+/**
+* Options for MX record checking.
+*/
+interface MxCheckOptions {
+  cache?: Cache<MxCheckResult>;
+  /**
+  * When true (the default), a domain with no MX records but a resolvable
+  * A/AAAA record is still considered able to accept mail (implicit MX).
+  */
+  fallbackToAddress?: boolean;
+  ttl?: number;
+}
+/**
+* Checks MX records for a domain, with an optional A/AAAA fallback.
+*
+* Distinguishes three states emailable separates as "MX Record Detection" and
+* "Domain Validation": records present (`mx`), no MX but the domain resolves
+* (`address`, implicit MX), and nothing resolves (`none`).
+* @param domain The domain to check.
+* @param options Options including caching and the address fallback toggle.
+* @returns The MX/domain check result.
+* @example
+* ```ts
+* import { checkMxRecords } from "@visulima/email-verifier/checks/mx";
+*
+* const result = await checkMxRecords("example.com");
+* if (result.valid) {
+*     console.log(result.resolvedVia, result.records);
+* }
+* ```
+*/
+declare const checkMxRecords: (domain: string, options?: MxCheckOptions) => Promise<MxCheckResult>;
+export { Cache as C, InMemoryCache as I, MxCheckOptions as M, InMemoryCacheOptions as a, MxCheckResult as b, MxRecord as c, MxResolution as d, checkMxRecords as e };

package/dist/packem_shared/score.d-BTcZnl2L.d.ts

@@ -0,0 +1,134 @@
+import { CharacterResult } from "../checks/character.js";
+import { c as MxRecord, d as MxResolution } from "./mx.d-NAesS5sg.js";
+import { SmtpVerificationResult } from "../checks/smtp.js";
+import { SymbolResult } from "../checks/symbol.js";
+import { TagResult } from "../checks/tag.js";
+import { NameResult } from "../enrich/name.js";
+import { MxProviderInfo } from '@visulima/email-provider-mx';
+/**
+* The overall deliverability verdict for an address, mirroring emailable's states.
+*
+* - `deliverable`: the mailbox almost certainly exists and accepts mail.
+* - `risky`: deliverable but lower-quality (catch-all, role, disposable, full mailbox).
+* - `undeliverable`: syntax/domain/mailbox failure — do not send.
+* - `unknown`: could not be determined (SMTP blocked, greylisted, or not probed).
+*/
+type VerificationState = "deliverable" | "risky" | "undeliverable" | "unknown";
+/**
+* The resolved domain portion of a verification report.
+*/
+interface DomainReport {
+  /** The MX records found (empty when resolved via A/AAAA or not at all). */
+  records: MxRecord[];
+  /** How mail-acceptance was established (`unchecked` when DNS was skipped). */
+  resolvedVia: MxResolution | "unchecked";
+  /** True when the domain can accept mail. */
+  valid: boolean;
+}
+/**
+* A complete email verification + enrichment report.
+*
+* Aggregates every check and enrichment into a single object whose shape reads
+* as a drop-in mental model for emailable's API response.
+*/
+interface EmailVerificationReport {
+  /** True when the SMTP server accepts any recipient (catch-all / accept-all). */
+  acceptAll: boolean;
+  /** Local-part character analysis. */
+  character: CharacterResult;
+  /** True when the SMTP result was inconclusive (greylisting / temporary failure). */
+  deferred: boolean;
+  /** Typo-corrected address suggestion, if the domain looked misspelled. */
+  didYouMean?: string;
+  /** True when the address uses a known disposable / throwaway domain. */
+  disposable: boolean;
+  /** The resolved domain details. */
+  domain: DomainReport;
+  /** The normalized (lowercased, trimmed) email address. */
+  email: string;
+  /** True when the address uses a known free mailbox provider. */
+  free: boolean;
+  /** True when the mailbox exists but is over quota. */
+  mailboxFull: boolean;
+  /** Name parsed from the local part (no gender detection). */
+  name: NameResult;
+  /** True when the address is a no-reply / do-not-reply mailbox. */
+  noReply: boolean;
+  /** The classified mailbox/SEG provider, if recognized. */
+  provider?: MxProviderInfo;
+  /** Human-readable explanation of the `state`. */
+  reason: string;
+  /** True when the address is a role-based (shared) mailbox. */
+  role: boolean;
+  /** Composite 0–100 quality score. */
+  score: number;
+  /** True when the resolving MX is a Secure Email Gateway. */
+  secureEmailGateway: boolean;
+  /** The raw SMTP probe result, when SMTP verification ran. */
+  smtp?: SmtpVerificationResult;
+  /** The overall deliverability verdict. */
+  state: VerificationState;
+  /** Symbol / Unicode-script analysis. */
+  symbol: SymbolResult;
+  /** True when the address passed the syntax check. */
+  syntaxValid: boolean;
+  /** Sub-address (tag) detection result. */
+  tag: TagResult;
+}
+/**
+* The fields of a report the scorer consumes (everything except the derived
+* `score`, `state`, and `reason`).
+*/
+type ScoreInput = Omit<EmailVerificationReport, "reason" | "score" | "state">;
+/**
+* Overridable penalty/bonus weights for the quality score.
+*
+* Each value is points applied to a 100-point baseline. Penalties are positive
+* numbers that get subtracted; bonuses are added.
+*/
+interface ScoreWeights {
+  acceptAll: number;
+  character: number;
+  deferred: number;
+  didYouMean: number;
+  disposable: number;
+  free: number;
+  knownProvider: number;
+  mailboxFull: number;
+  mixedScripts: number;
+  noReply: number;
+  role: number;
+  smtpUnverified: number;
+  symbol: number;
+}
+/**
+* The default scoring rubric. Transparent and additive so callers can reason
+* about — and override — every weight.
+*/
+declare const DEFAULT_WEIGHTS: ScoreWeights;
+/**
+* The outcome of scoring: the numeric score plus the derived state and reason.
+*/
+interface ScoreResult {
+  reason: string;
+  score: number;
+  state: VerificationState;
+}
+/**
+* Computes a 0–100 quality score and the deliverability state for a report.
+*
+* The state is derived from hard signals (syntax, domain, SMTP verdict); the
+* score layers transparent penalties/bonuses on top so two `risky` addresses can
+* still be ranked against each other.
+* @param input The verification signals (a report without its derived fields).
+* @param weights Optional weight overrides.
+* @returns The score, state, and reason.
+* @example
+* ```ts
+* import { scoreReport } from "@visulima/email-verifier/score";
+*
+* const { score, state } = scoreReport(report);
+* ```
+*/
+declare const scoreReport: (input: ScoreInput, weights?: Partial<ScoreWeights>) => ScoreResult;
+export { DEFAULT_WEIGHTS as D, EmailVerificationReport as E, ScoreInput as S, VerificationState as V, DomainReport as a, ScoreResult as b, ScoreWeights as c, scoreReport as s };

package/dist/score.d.ts

@@ -0,0 +1,8 @@
+export { D as DEFAULT_WEIGHTS, type S as ScoreInput, type b as ScoreResult, type c as ScoreWeights, s as default, s as scoreReport } from "./packem_shared/score.d-BTcZnl2L.js";
+import "./checks/character.js";
+import "./packem_shared/mx.d-NAesS5sg.js";
+import "./checks/smtp.js";
+import "./checks/symbol.js";
+import "./checks/tag.js";
+import "./enrich/name.js";
+import '@visulima/email-provider-mx';

package/dist/score.js

@@ -0,0 +1 @@
+const t={acceptAll:25,character:15,deferred:15,didYouMean:20,disposable:60,free:5,knownProvider:5,mailboxFull:40,mixedScripts:30,noReply:25,role:25,smtpUnverified:10,symbol:10},i=e=>Math.max(0,Math.min(100,Math.round(e))),n=e=>e.smtp!==void 0&&!e.smtp.valid&&!e.smtp.deferred&&!e.mailboxFull&&(e.smtp.code??0)>=500,d=e=>e.disposable?{reason:"disposable_mailbox",state:"risky"}:e.mailboxFull?{reason:"mailbox_full",state:"risky"}:e.acceptAll?{reason:"accept_all",state:"risky"}:e.noReply?{reason:"no_reply",state:"risky"}:e.role?{reason:"role_account",state:"risky"}:{reason:"accepted_email",state:"deliverable"},m=e=>n(e)?{reason:"rejected_email",state:"undeliverable"}:e.smtp?.valid?d(e):e.mailboxFull?{reason:"mailbox_full",state:"risky"}:e.smtp?.deferred?{reason:"greylisted",state:"unknown"}:{reason:"unknown",state:"unknown"},c=e=>e.syntaxValid?e.domain.resolvedVia!=="unchecked"&&!e.domain.valid?{reason:e.domain.resolvedVia==="none"?"no_mx_records":"invalid_domain",state:"undeliverable"}:e.smtp?m(e):e.disposable?{reason:"disposable_mailbox",state:"risky"}:{reason:"smtp_not_checked",state:"unknown"}:{reason:"invalid_syntax",state:"undeliverable"},p=(e,o={})=>{const s={...t,...o},{reason:l,state:r}=c(e);if(r==="undeliverable")return{reason:l,score:0,state:r};let a=100;return e.smtp?.valid!==!0&&(a-=s.smtpUnverified),e.deferred&&(a-=s.deferred),e.disposable&&(a-=s.disposable),e.acceptAll&&(a-=s.acceptAll),e.mailboxFull&&(a-=s.mailboxFull),e.role&&(a-=s.role),e.noReply&&(a-=s.noReply),e.free&&(a-=s.free),e.character.irregular&&(a-=s.character),e.symbol.hasMixedScripts?a-=s.mixedScripts:e.symbol.hasSymbols&&(a-=s.symbol),e.didYouMean&&(a-=s.didYouMean),e.provider&&(a+=s.knownProvider),{reason:l,score:i(a),state:r}};export{t as DEFAULT_WEIGHTS,p as default,p as scoreReport};

package/dist/verify-email.d.ts

@@ -0,0 +1,62 @@
+import { DisposableEmailOptions } from '@visulima/disposable-email-domains';
+import { FreeEmailOptions } from '@visulima/free-email-domains';
+import { b as MxCheckResult, C as Cache } from "./packem_shared/mx.d-NAesS5sg.js";
+import { SmtpVerificationOptions } from "./checks/smtp.js";
+import { TypoOptions } from "./enrich/typo.js";
+import { c as ScoreWeights, E as EmailVerificationReport } from "./packem_shared/score.d-BTcZnl2L.js";
+export type { V as VerificationState } from "./packem_shared/score.d-BTcZnl2L.js";
+import "./checks/character.js";
+import "./checks/symbol.js";
+import "./checks/tag.js";
+import "./enrich/name.js";
+import '@visulima/email-provider-mx';
+/**
+* Options for `verifyEmail`.
+*/
+interface VerifyEmailOptions {
+  /** Shared cache for MX/SMTP lookups (dedupes work when verifying lists). */
+  cache?: Cache<MxCheckResult>;
+  /**
+  * Run live SMTP verification (catch-all, mailbox-full, greylist).
+  * @default true
+  */
+  checkSmtp?: boolean;
+  /** Disposable-list overrides. */
+  disposable?: DisposableEmailOptions;
+  /** Free-list overrides. */
+  free?: FreeEmailOptions;
+  /**
+  * Skip all network checks (MX, SMTP, provider) and produce a syntax +
+  * heuristic-only report. Overrides `checkSmtp`.
+  * @default false
+  */
+  offline?: boolean;
+  /** Additional role-account prefixes to recognize. */
+  roleCustomPrefixes?: Iterable<string>;
+  /** SMTP probe options (timeout, catch-all probes, retries, …). */
+  smtp?: SmtpVerificationOptions;
+  /** Typo-suggestion overrides. */
+  typo?: TypoOptions;
+  /** Score weight overrides. */
+  weights?: Partial<ScoreWeights>;
+}
+/**
+* Verifies and enriches a single email address end-to-end.
+*
+* Runs the offline checks (syntax, disposable, free, role, tag, character,
+* symbol, name, typo) immediately, then — unless `offline` is set — resolves the
+* domain's MX and runs the SMTP probe and provider classification concurrently.
+* Everything is aggregated into one {@link EmailVerificationReport} and scored.
+* @param email The email address to verify.
+* @param options Verification options.
+* @returns The complete verification report.
+* @example
+* ```ts
+* import { verifyEmail } from "@visulima/email-verifier";
+*
+* const report = await verifyEmail("user@gmail.com");
+* console.log(report.state, report.score); // "deliverable" 95
+* ```
+*/
+declare const verifyEmail: (email: string, options?: VerifyEmailOptions) => Promise<EmailVerificationReport>;
+export { type EmailVerificationReport, type VerifyEmailOptions, verifyEmail as default, verifyEmail };

package/dist/verify-email.js

@@ -0,0 +1 @@
+import{analyzeCharacters as h}from"./checks/character.js";import{checkMxRecords as v}from"./checks/mx.js";import x,{isNoReply as b}from"./checks/role.js";import g from"./checks/smtp.js";import{analyzeSymbols as w}from"./checks/symbol.js";import V from"./checks/syntax.js";import E from"./checks/tag.js";import R from"./enrich/name.js";import $ from"./enrich/typo.js";import{splitAddress as k}from"./packem_shared/extractDomain-CYJf1_0N.js";import f from"./score.js";import{classifyMxRecords as A}from"@visulima/email-provider-mx";import{isFreeEmail as F}from"@visulima/free-email-domains";import{isDisposableEmail as C}from"@visulima/disposable-email-domains";const p=(e,a)=>({character:h(e),didYouMean:$(e,a.typo)?.full,disposable:C(e,a.disposable),free:F(e,a.free),name:R(e),noReply:b(e),role:x(e,a.roleCustomPrefixes),symbol:w(e),tag:E(e)}),J=async(e,a={})=>{const{checkSmtp:n=!0,offline:y=!1}=a,o=k(e),t=o?.address??(typeof e=="string"?e.trim().toLowerCase():"");if(!V(e)||!o){const s={...p(t,a),acceptAll:!1,deferred:!1,domain:{records:[],resolvedVia:"unchecked",valid:!1},email:t,mailboxFull:!1,secureEmailGateway:!1,syntaxValid:!1};return{...s,...f(s,a.weights)}}const u=p(o.address,a);let m={records:[],resolvedVia:"unchecked",valid:!1},r,l,d=!1;if(!y){const s=await v(o.domain,{cache:a.cache});m={records:s.records??[],resolvedVia:s.resolvedVia,valid:s.valid};const i=s.records??[];s.valid&&i.length>0&&(l=A(i),d=l?.type==="seg",n&&(r=await g(o.address,{cache:a.cache,...a.smtp,mxRecords:i})))}const c={...u,acceptAll:r?.acceptAll??!1,deferred:r?.deferred??!1,domain:m,email:o.address,mailboxFull:r?.mailboxFull??!1,provider:l,secureEmailGateway:d,smtp:r,syntaxValid:!0};return{...c,...f(c,a.weights)}};export{J as default,J as verifyEmail};

package/package.json

@@ -1,10 +1,125 @@
 {
   "name": "@visulima/email-verifier",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @visulima/email-verifier",
+  "version": "1.0.0",
+  "description": "Mailer-free email address verification and enrichment: syntax, MX/SMTP probing, disposable/free/role detection, catch-all, provider & secure-email-gateway classification, typo suggestions, and a 0–100 quality score.",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+    "accept-all",
+    "catch-all",
+    "disposable-email",
+    "email-enrichment",
+    "email-quality-score",
+    "email-validation",
+    "email-verification",
+    "free-email",
+    "mx-records",
+    "role-account",
+    "secure-email-gateway",
+    "smtp-verification",
+    "visulima"
+  ],
+  "homepage": "https://visulima.com/packages/email-verifier",
+  "bugs": "https://github.com/visulima/visulima/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/visulima/visulima.git",
+    "directory": "packages/email/email-verifier"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/prisis"
+    },
+    {
+      "type": "consulting",
+      "url": "https://anolilab.com/support"
+    }
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./verify-email": {
+      "types": "./dist/verify-email.d.ts",
+      "default": "./dist/verify-email.js"
+    },
+    "./score": {
+      "types": "./dist/score.d.ts",
+      "default": "./dist/score.js"
+    },
+    "./checks/syntax": {
+      "types": "./dist/checks/syntax.d.ts",
+      "default": "./dist/checks/syntax.js"
+    },
+    "./checks/mx": {
+      "types": "./dist/checks/mx.d.ts",
+      "default": "./dist/checks/mx.js"
+    },
+    "./checks/smtp": {
+      "types": "./dist/checks/smtp.d.ts",
+      "default": "./dist/checks/smtp.js"
+    },
+    "./checks/disposable": {
+      "types": "./dist/checks/disposable.d.ts",
+      "default": "./dist/checks/disposable.js"
+    },
+    "./checks/free": {
+      "types": "./dist/checks/free.d.ts",
+      "default": "./dist/checks/free.js"
+    },
+    "./checks/role": {
+      "types": "./dist/checks/role.d.ts",
+      "default": "./dist/checks/role.js"
+    },
+    "./checks/tag": {
+      "types": "./dist/checks/tag.d.ts",
+      "default": "./dist/checks/tag.js"
+    },
+    "./checks/character": {
+      "types": "./dist/checks/character.d.ts",
+      "default": "./dist/checks/character.js"
+    },
+    "./checks/symbol": {
+      "types": "./dist/checks/symbol.d.ts",
+      "default": "./dist/checks/symbol.js"
+    },
+    "./enrich/provider": {
+      "types": "./dist/enrich/provider.d.ts",
+      "default": "./dist/enrich/provider.js"
+    },
+    "./enrich/typo": {
+      "types": "./dist/enrich/typo.d.ts",
+      "default": "./dist/enrich/typo.js"
+    },
+    "./enrich/name": {
+      "types": "./dist/enrich/name.d.ts",
+      "default": "./dist/enrich/name.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@visulima/disposable-email-domains": "1.0.0",
+    "@visulima/email-provider-mx": "1.0.0",
+    "@visulima/free-email-domains": "1.0.0",
+    "lru-cache": "11.5.1"
+  },
+  "engines": {
+    "node": "^22.14.0 || >=24.10.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}