@carlgo11/simpleimfparser 0.0.1-a → 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { Readable } from 'node:stream';
+import Email from './types/Email.js';
+import type Envelope from './types/Envelope.js';
+/**
+ * Parses an email message from raw data and an envelope object.
+ *
+ * @param {string | Readable} rawData - The raw email message content.
+ * @param {object} envelope - The envelope containing sender/recipient metadata.
+ * @returns {Promise<Email>} A parsed email object.
+ * @since 0.0.1
+ */
+export default function parseEmail(rawData: string | Readable, envelope: object): Promise<Email>;
+export { Email, Envelope };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,MAAM,kBAAkB,CAAC;AAGrC,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAEhD;;;;;;;GAOG;AACH,wBAA8B,UAAU,CACtC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC"}

package/{src/parsers/parseEnvelope.ts → dist/parsers/parseEnvelope.d.ts}

@@ -1,11 +1,8 @@
 import Envelope from '../types/Envelope.js';
-
 /**
  * Parses envelope metadata from the SMTP transaction.
  * @param envelope - Envelope data object
  * @returns Parsed Envelope object
  */
-export default async function parseEnvelope(envelope: Object): Promise<Envelope> {
-  // TODO: Implement envelope parsing logic
-  return envelope as Envelope;
-}
+export default function parseEnvelope(envelope: Object): Promise<Envelope>;
+//# sourceMappingURL=parseEnvelope.d.ts.map

package/dist/parsers/parseEnvelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnvelope.d.ts","sourceRoot":"","sources":["../../src/parsers/parseEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,sBAAsB,CAAC;AAG5C;;;;GAIG;AACH,wBAA8B,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAyB/E"}

package/dist/parsers/parseHeaders.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parses headers from a raw IMF header string.
+ * @param {string} rawHeaders - The raw headers as a string
+ * @param {'strict'|'relaxed'} mode - Strict mode rejects emails with invalid headers. Relaxed simply deletes invalid headers.
+ * @returns {Promise<Record<string, string | string[]>>} - A dictionary of headers (handling duplicates)
+ * @throws {Error} - If any header fails validation.
+ * @since 0.0.1
+ */
+export default function parseHeaders(rawHeaders: string, mode?: 'strict' | 'relaxed'): Promise<Record<string, string | string[]>>;
+//# sourceMappingURL=parseHeaders.d.ts.map

package/dist/parsers/parseHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseHeaders.d.ts","sourceRoot":"","sources":["../../src/parsers/parseHeaders.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAA8B,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,GAAE,QAAQ,GAAG,SAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAIjJ"}

package/dist/parsers/parseMessage.d.ts

@@ -0,0 +1,11 @@
+import { Readable } from 'node:stream';
+/**
+ * Parses the raw email message (headers + body).
+ * @param rawData - Raw IMF email (string or stream)
+ * @returns Parsed email components
+ */
+export default function parseMessage(rawData: string | Readable): Promise<{
+    headers: Record<string, string | string[]>;
+    body: string;
+}>;
+//# sourceMappingURL=parseMessage.d.ts.map

package/dist/parsers/parseMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseMessage.d.ts","sourceRoot":"","sources":["../../src/parsers/parseMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIvC;;;;GAIG;AACH,wBAA8B,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAoB5I"}

package/dist/types/Attachment.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Represents an email attachment.
+ *
+ * This interface defines the structure of an attachment, including
+ * its filename, MIME type, size, and content.
+ *
+ * @interface Attachment
+ * @since 0.0.1
+ */
+export default interface Attachment {
+    /**
+     * The name of the attachment file.
+     *
+     * This is the filename as provided in the email message.
+     *
+     * @type {string}
+     * @example "invoice.pdf"
+     * @example "image.png"
+     * @since 0.0.1
+     */
+    filename: string;
+    /**
+     * The MIME type of the attachment.
+     *
+     * This indicates the media type of the file, as specified in the `Content-Type` header.
+     *
+     * @type {string}
+     * @example "application/pdf"
+     * @example "image/jpeg"
+     * @example "text/plain"
+     * @since 0.0.1
+     */
+    contentType: string;
+    /**
+     * The size of the attachment in bytes.
+     *
+     * Represents the total number of bytes in the attachment content.
+     *
+     * @type {number}
+     * @example 102400  // 100 KB
+     * @example 512     // 512 bytes
+     * @since 0.0.1
+     */
+    size: number;
+    /**
+     * The content of the attachment.
+     *
+     * This contains the actual file data as written in the email message.
+     *
+     * @type {string}
+     * @example /9j/4AAQSkZJRgABAQEAEQARAAD/2wB //JPEG example
+     * @since 0.0.1
+     */
+    content: string;
+}
+//# sourceMappingURL=Attachment.d.ts.map

package/dist/types/Attachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Attachment.d.ts","sourceRoot":"","sources":["../../src/types/Attachment.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,WAAW,UAAU;IACjC;;;;;;;;;OASG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;;;;;OAUG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;OASG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;OAQG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/types/Email.d.ts

@@ -0,0 +1,114 @@
+import Envelope from './Envelope.js';
+import Attachment from './Attachment.js';
+/**
+ * Represents an email message with an envelope, headers, body, and optional attachments.
+ *
+ * @class Email
+ * @module Email
+ * @since 0.0.1
+ */
+export default class Email {
+    /**
+     * The envelope containing sender and recipient details.
+     *
+     * @type {Envelope}
+     * @since 0.0.1
+     */
+    envelope: Envelope;
+    /**
+     * The headers of the email, stored as key-value pairs.
+     * Header names are case-insensitive.
+     *
+     * @type {Record<string, string | string[]>}
+     * @since 0.0.1
+     */
+    headers: Record<string, string | string[]>;
+    /**
+     * The plain text body of the email.
+     *
+     * @type {string}
+     * @since 0.0.1
+     */
+    body: string;
+    /**
+     * The attachments associated with the email.
+     * Defaults to an empty array if not provided.
+     *
+     * @type {Attachment[]}
+     * @since 0.0.1
+     */
+    attachments?: Attachment[];
+    /**
+     * Creates a new email instance.
+     *
+     * @param {Envelope} envelope - The envelope containing sender and recipient details.
+     * @param {Record<string, string | string[]>} headers - The headers of the email.
+     * @param {string} body - The plain text body of the email.
+     * @param {Attachment[]} [attachments=[]] - Optional attachments for the email.
+     * @since 0.0.1
+     */
+    constructor(envelope: Envelope, headers: Record<string, string | string[]>, body: string, attachments?: Attachment[]);
+    /**
+     * Retrieves a header value by name (case-insensitive).
+     *
+     * @param {string} name - The name of the header to retrieve.
+     * @returns {string | string[] | undefined} The header value, or `undefined` if not found.
+     * @example
+     * const email = new Email(envelope, { 'subject': 'Subject String' });
+     * console.log(email.getHeader('Subject')); // Output: 'Subject String'
+     * @since 0.0.1
+     */
+    getHeader(name: string): string | string[] | undefined;
+    /**
+     * Adds a new header or appends to an existing header.
+     * If the header already exists, it is converted to an array.
+     *
+     * @param {string} name - The name of the header.
+     * @param {string} value - The value to add to the header.
+     * @example
+     * const email = new Email(envelope, {}, 'Hello');
+     * email.addHeader('X-Custom-Header', 'Value1');
+     * email.addHeader('X-Custom-Header', 'Value2');
+     * console.log(email.getHeader('X-Custom-Header')); // Output: ['Value1', 'Value2']
+     * @since 0.0.1
+     */
+    addHeader(name: string, value: string): void;
+    /**
+     * Removes a header by name (case-insensitive).
+     *
+     * @param {string} name - The name of the header to remove.
+     * @example
+     * const email = new Email(envelope, { 'X-Test': 'value' }, 'Hello');
+     * email.removeHeader('X-Test');
+     * console.log(email.getHeader('X-Test')); // Output: undefined
+     * @since 0.0.1
+     */
+    removeHeader(name: string): void;
+    /**
+     * Retrieves the body of the email.
+     * If the email contains both plain text and HTML, plain text is preferred.
+     *
+     * @returns {string} The email body.
+     * @example
+     * const email = new Email(envelope, {}, 'Hello, world!');
+     * console.log(email.getBody()); // Output: 'Hello, world!'
+     * @since 0.0.1
+     */
+    getBody(): string;
+    /**
+     * Returns the email as a string in the IMF format.
+     *
+     * @returns {string} The formatted email as a string.
+     * @see https://datatracker.ietf.org/doc/html/rfc5322
+     * @example
+     * const email = new Email(envelope, { subject: 'Test' }, 'Hello');
+     * console.log(email.toString());
+     * // Output:
+     * // Subject: Test
+     * //
+     * // Hello
+     * @since 0.0.1
+     */
+    toString(): string;
+}
+//# sourceMappingURL=Email.d.ts.map

package/dist/types/Email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Email.d.ts","sourceRoot":"","sources":["../../src/types/Email.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB;;;;;OAKG;IACH,QAAQ,EAAE,QAAQ,CAAC;IAEnB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAE3C;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAE3B;;;;;;;;OAQG;gBAED,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAC1C,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,UAAU,EAAE;IAQ5B;;;;;;;;;OASG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAItD;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAa5C;;;;;;;;;OASG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIhC;;;;;;;;;OASG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/types/Envelope.d.ts

@@ -0,0 +1,45 @@
+import Sender from './Sender.js';
+/**
+ * Represents an email envelope, containing metadata about the sender, recipients, and delivery.
+ *
+ * The envelope is part of the message delivery process and includes information
+ * such as the sender, recipient list, and timestamps.
+ *
+ * @interface Envelope
+ * @since 0.0.1
+ */
+export default interface Envelope {
+    /**
+     * A unique identifier for the email.
+     * This can be set either by the sender using Message-ID, or by the recipient server.
+     *
+     * @type {string}
+     * @since 0.0.1
+     */
+    id: string;
+    /**
+     * The sender's "MAIL FROM" email address.
+     *
+     * Note: This address may differ from the address used in the "From"-header inside the email message.
+     *
+     * @type {string}
+     * @since 0.0.1
+     */
+    from: string;
+    /**
+     * The list of recipient email addresses.
+     *
+     * @type {string[]}
+     * @since 0.0.1
+     */
+    to: string[];
+    /**
+     * The sender details, including additional metadata about the sender.
+     *
+     * @type {Sender}
+     * @see Sender
+     * @since 0.0.1
+     */
+    sender: Sender;
+}
+//# sourceMappingURL=Envelope.d.ts.map

package/dist/types/Envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Envelope.d.ts","sourceRoot":"","sources":["../../src/types/Envelope.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAC;AAEjC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,WAAW,QAAQ;IAC/B;;;;;;OAMG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,EAAE,EAAE,MAAM,EAAE,CAAC;IAEb;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB"}

package/dist/types/Sender.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Represents details about the sender of an email during the SMTP transaction.
+ *
+ * This interface includes metadata about the sender's connection, such as
+ * the originating IP address, reverse DNS, HELO/EHLO value, TLS status,
+ * and authentication details (if applicable).
+ *
+ * @interface Sender
+ * @since 0.0.1
+ */
+export default interface Sender {
+    /**
+     * The IP address of the sender.
+     *
+     * This is the IP address of the SMTP client that initiated the connection.
+     *
+     * @type {string}
+     * @example "192.168.1.100"
+     * @example "2001:db8::1"
+     * @since 0.0.1
+     */
+    ip: string;
+    /**
+     * The reverse DNS (rDNS) hostname of the sender.
+     *
+     * If available, this represents the resolved hostname of the sender's IP.
+     * This value may be `undefined` if no rDNS record exists.
+     *
+     * @type {string | undefined}
+     * @example "mail.example.com"
+     * @since 0.0.1
+     */
+    rDNS?: string;
+    /**
+     * The HELO/EHLO value provided by the SMTP client.
+     *
+     * This is the argument sent by the client in the EHLO or HELO command.
+     * It is typically a hostname but may also be an IP address.
+     * If the value is an IP address, it is enclosed in square brackets.
+     *
+     * @type {string | undefined}
+     * @example "mail.example.com"
+     * @example "[192.168.1.100]"
+     * @example "[IPv6:2001:db8::1]"
+     * @since 0.0.1
+     */
+    helo?: string;
+    /**
+     * Indicates whether the connection was secured using TLS (STARTTLS).
+     *
+     * A `true` value means that the SMTP session was encrypted using TLS (STARTTLS).
+     *
+     * @type {boolean}
+     * @example true
+     * @example false
+     * @since 0.0.1
+     */
+    tls: boolean;
+    /**
+     * Authentication details if the sender authenticated.
+     *
+     * This property exists only if the sender used SMTP authentication.
+     *
+     * @type {Object | undefined}
+     * @property {string} method - The authentication method used (e.g., "PLAIN", "LOGIN", "CRAM-MD5").
+     * @property {string | undefined} username - The authenticated username, if available.
+     * @example { method: "PLAIN", username: "user@example.com" }
+     * @since 0.0.1
+     */
+    authenticated?: {
+        method: string;
+        username?: string;
+    };
+}
+//# sourceMappingURL=Sender.d.ts.map

package/dist/types/Sender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sender.d.ts","sourceRoot":"","sources":["../../src/types/Sender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,WAAW,MAAM;IAC7B;;;;;;;;;OASG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;;;;;OASG;IACH,GAAG,EAAE,OAAO,CAAC;IAEb;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH"}

package/dist/utils/streamToString.d.ts

@@ -0,0 +1,8 @@
+import { Readable } from 'node:stream';
+/**
+ * Converts a Readable Stream to a string.
+ * @param stream - Input stream
+ * @returns Promise resolving to the string content
+ */
+export default function streamToString(stream: Readable): Promise<string>;
+//# sourceMappingURL=streamToString.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streamToString.d.ts","sourceRoot":"","sources":["../../src/utils/streamToString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;;GAIG;AACH,wBAA8B,cAAc,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAO9E"}

package/package.json

@@ -1,10 +1,11 @@
 {
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "name": "@carlgo11/simpleimfparser",
   "description": "Simple IMF parser",
-  "version": "0.0.1a",
-  "license": "GPL-3.0",
+  "version": "0.0.2",
+  "license": "MIT",
   "author": "Carlgo11",
   "repository": {
     "type": "git",
@@ -17,16 +18,23 @@
   "scripts": {
     "start": "node src/index.ts",
     "test": "node --import tsx --test test/*.test.ts test/**/*.test.ts",
-    "build": "npx tsc"
+    "build": "npx tsc",
+    "docs": "npx typedoc"
   },
   "private": false,
   "dependencies": {
-    "@types/node": "^22.10.7"
+    "@types/node": "^22.10.7",
+    "validator": "^13.12.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^9.4.0",
+    "@types/validator": "^13.12.2",
+    "esbuild": "^0.24.2",
+    "jsdoc": "^4.0.4",
     "ts-node": "^10.9.2",
     "tsx": "^4.19.2",
+    "typedoc": "^0.27.6",
+    "typedoc-plugin-merge-modules": "^6.1.0",
     "typescript": "^5.7.3"
   },
   "engines": {

package/.github/workflows/publish.yaml

@@ -1,51 +0,0 @@
-name: Publish package
-on:
-  release:
-    types:
-      - published
-jobs:
-  test:
-    name: Test code
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm install
-      - run: npm test
-
-  publish:
-    name: Publish package
-    needs: test
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      matrix:
-        registry:
-          - gpr
-          - npm
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          registry-url: ${{ matrix.registry == 'gpr' && 'https://npm.pkg.github.com/' || 'https://registry.npmjs.org/' }}
-      - name: Extract version from tag
-        id: extract_version
-        run: |
-          VERSION=${GITHUB_REF#refs/tags/v}
-          echo "VERSION=$VERSION" >> $GITHUB_ENV
-      - name: Update package.json version
-        run: |
-          jq ".version = \"$VERSION\"" package.json > package.tmp.json
-          mv package.tmp.json package.json
-      - run: npm install
-      - run: npm run build
-      - name: Publish package
-        run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ matrix.registry == 'gpr' && secrets.GITHUB_TOKEN || secrets.npm_token }}

package/.github/workflows/test.yaml

@@ -1,14 +0,0 @@
-name: Test package
-on: push
-jobs:
-  test:
-    name: Test package
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm install
-      - run: npm test
-      - run: npm run build

package/.gitignore

@@ -1,6 +0,0 @@
-node_modules
-dist
-package-lock.json
-.*
-!.gitignore
-!.github

package/dist/index.js

@@ -1,8 +0,0 @@
-import { Email } from './types/Email.js';
-import parseEnvelope from './parsers/parseEnvelope.js';
-import parseMessage from './parsers/parseMessage.js';
-export default async function parseEmail(rawData, envelope) {
-    const parsedEnvelope = await parseEnvelope(envelope);
-    const { headers, body } = await parseMessage(rawData);
-    return new Email(parsedEnvelope, headers, body);
-}

package/dist/parsers/parseEnvelope.js

@@ -1,9 +0,0 @@
-/**
- * Parses envelope metadata from the SMTP transaction.
- * @param envelope - Envelope data object
- * @returns Parsed Envelope object
- */
-export default async function parseEnvelope(envelope) {
-    // TODO: Implement envelope parsing logic
-    return envelope;
-}

package/dist/parsers/parseHeaders.js

@@ -1,65 +0,0 @@
-/**
- * Parses headers from a raw IMF header string.
- * @param rawHeaders - The raw headers as a string
- * @returns A dictionary of headers (handling duplicates)
- */
-export default function parseHeaders(rawHeaders) {
-    const headers = {};
-    const lines = rawHeaders.split(/\r\n|\n/);
-    let currentKey = null;
-    let currentValue = '';
-    for (const line of lines) {
-        if (line.startsWith(' ') || line.startsWith('\t')) {
-            // Handle folded headers (continuation lines)
-            if (currentKey) {
-                if (Array.isArray(headers[currentKey])) {
-                    headers[currentKey][headers[currentKey].length - 1] += ' ' + line.trim();
-                }
-                else {
-                    headers[currentKey] += ' ' + line.trim();
-                }
-            }
-            else {
-                throw new Error('Header folding found without a preceding header field.');
-            }
-        }
-        else {
-            // Store previous header before starting a new one
-            if (currentKey) {
-                if (headers[currentKey]) {
-                    if (Array.isArray(headers[currentKey])) {
-                        headers[currentKey].push(currentValue);
-                    }
-                    else {
-                        headers[currentKey] = [headers[currentKey], currentValue];
-                    }
-                }
-                else {
-                    headers[currentKey] = currentValue;
-                }
-            }
-            // Extract new header key-value pair
-            const match = line.match(/^([!#$%&'*+\-.0-9A-Z^_`a-z|~]+):\s*(.*)$/);
-            if (!match) {
-                throw new Error(`Invalid header format: "${line}"`);
-            }
-            currentKey = match[1].toLowerCase(); // Convert key to lowercase
-            currentValue = match[2];
-        }
-    }
-    // Store the last header
-    if (currentKey) {
-        if (headers[currentKey]) {
-            if (Array.isArray(headers[currentKey])) {
-                headers[currentKey].push(currentValue);
-            }
-            else {
-                headers[currentKey] = [headers[currentKey], currentValue];
-            }
-        }
-        else {
-            headers[currentKey] = currentValue;
-        }
-    }
-    return headers;
-}

package/dist/parsers/parseMessage.js

@@ -1,30 +0,0 @@
-import { Readable } from 'node:stream';
-import parseHeaders from './parseHeaders.js';
-import streamToString from '../utils/streamToString.js';
-/**
- * Parses the raw email message (headers + body).
- * @param rawData - Raw IMF email (string or stream)
- * @returns Parsed email components
- */
-export default async function parseMessage(rawData) {
-    let rawEmail;
-    if (typeof rawData === 'string') {
-        rawEmail = rawData;
-    }
-    else if (rawData instanceof Readable) {
-        rawEmail = await streamToString(rawData);
-    }
-    else {
-        throw new TypeError('Invalid rawData type. Expected a string or a Readable stream.');
-    }
-    const headerBoundary = rawEmail.indexOf('\r\n\r\n');
-    const rawHeaders = rawEmail.slice(0, headerBoundary);
-    const body = rawEmail.slice(headerBoundary + 4);
-    if (body.length === 0) {
-        throw new Error('Header and Body must be separated by \\r\\n\\r\\n');
-    }
-    return {
-        headers: parseHeaders(rawHeaders),
-        body,
-    };
-}

package/dist/types/Attachment.js

@@ -1 +0,0 @@
-export {};