@mavogel/awscdk-rootmail 0.1.4 → 0.1.5

package/node_modules/nodemailer/dist/esm/mime-node/index.d.ts

@@ -1,6 +1,4 @@
 import { type Duplex, type Readable, type TransformOptions, type Writable } from 'node:stream';
-import * as mimeFuncs from '../mime-funcs/index.js';
-import { type Address } from '../addressparser/index.js';
 import type { NodemailerError } from '../errors.js';
 import type { OutgoingHttpHeaders } from 'node:http';
 /**
@@ -8,38 +6,38 @@ import type { OutgoingHttpHeaders } from 'node:http';
  */
 export interface MimeNodeOptions {
     /** root node for this tree */
-    rootNode?: MimeNode;
+    rootNode?: MimeNode | undefined;
     /** immediate parent for this node */
-    parentNode?: MimeNode;
+    parentNode?: MimeNode | undefined;
     /** filename for an attachment node */
-    filename?: string;
+    filename?: string | undefined;
     /** shared part of the unique multipart boundary */
-    baseBoundary?: string;
+    baseBoundary?: string | undefined;
     /** prefix for the generated multipart boundaries, defaults to '--_NmP' */
-    boundaryPrefix?: string;
+    boundaryPrefix?: string | undefined;
     /** If true, do not exclude Bcc from the generated headers */
-    keepBcc?: boolean;
+    keepBcc?: boolean | undefined;
     /** method to normalize header keys for custom caseing */
-    normalizeHeaderKey?: (key: string, value: string) => string;
+    normalizeHeaderKey?: ((key: string, value: string) => string) | undefined;
     /** either 'Q' (the default) or 'B' */
-    textEncoding?: string;
+    textEncoding?: string | undefined;
     /** Hostname for default message-id values */
-    hostname?: string;
+    hostname?: string | undefined;
     /** If set to 'win' then uses \r\n, if 'linux' then \n. If not set (or `raw` is used) then newlines are kept as is */
-    newline?: string;
+    newline?: string | undefined;
     /** Reject content that points to a file path, for this node and every node below it */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Reject content that points to a URL, for this node and every node below it */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
 }
 /**
  * An address object as accepted in address headers and produced by getAddresses. Either a
  * mailbox with an address or a group holding a list of addresses
  */
 export interface MimeNodeAddress {
-    name?: string;
-    address?: string;
-    group?: MimeNodeAddress[];
+    name?: string | undefined;
+    address?: string | undefined;
+    group?: MimeNodeAddress[] | undefined;
 }
 /**
  * Addresses as accepted by address headers and envelope fields: an address string, an
@@ -52,8 +50,8 @@ export type MimeNodeAddressInput = string | MimeNodeAddress | MimeNodeAddressInp
  */
 export interface MimeNodePreparedHeaderValue {
     value?: unknown;
-    prepared?: boolean;
-    foldLines?: boolean;
+    prepared?: boolean | undefined;
+    foldLines?: boolean | undefined;
 }
 /**
  * The values a header can hold: a string, a number, a Date (for the Date header), address
@@ -84,19 +82,15 @@ export type MimeNodeHeaders = MimeNodeHeader | MimeNodeHeader[] | MimeNodeHeader
  */
 export interface MimeNodeContentObject {
     /** File path to read the content from */
-    path?: string;
+    path?: string | undefined;
     /** URL to fetch the content from */
-    href?: string;
+    href?: string | undefined;
     /** Request headers for a URL fetch */
-    httpHeaders?: OutgoingHttpHeaders;
+    httpHeaders?: OutgoingHttpHeaders | undefined;
     /** TLS settings for a URL fetch, see nmfetch */
     tls?: {
         [key: string]: any;
-    };
-    /** Read the content once and reuse the buffered value for every stream. MailComposer sets it on the icalEvent content, which is used twice */
-    _resolve?: boolean;
-    /** The buffered content once _resolve has run */
-    _resolvedValue?: Buffer;
+    } | undefined;
 }
 /**
  * Body content as accepted by setContent and setRaw: a string, a Buffer, a readable stream
@@ -117,22 +111,22 @@ export interface MimeNodeEnvelope {
  * other field is copied to the envelope as is
  */
 export interface MimeNodeEnvelopeInput {
-    from?: MimeNodeAddressInput;
-    to?: MimeNodeAddressInput;
-    cc?: MimeNodeAddressInput;
-    bcc?: MimeNodeAddressInput;
+    from?: MimeNodeAddressInput | undefined;
+    to?: MimeNodeAddressInput | undefined;
+    cc?: MimeNodeAddressInput | undefined;
+    bcc?: MimeNodeAddressInput | undefined;
     [key: string]: unknown;
 }
 /**
  * Parsed address headers as returned by getAddresses, keyed by lowercase header name
  */
 export interface MimeNodeAddresses {
-    from?: MimeNodeAddress[];
-    sender?: MimeNodeAddress[];
-    'reply-to'?: MimeNodeAddress[];
-    to?: MimeNodeAddress[];
-    cc?: MimeNodeAddress[];
-    bcc?: MimeNodeAddress[];
+    from?: MimeNodeAddress[] | undefined;
+    sender?: MimeNodeAddress[] | undefined;
+    'reply-to'?: MimeNodeAddress[] | undefined;
+    to?: MimeNodeAddress[] | undefined;
+    cc?: MimeNodeAddress[] | undefined;
+    bcc?: MimeNodeAddress[] | undefined;
 }
 /**
  * Options for createReadStream. Handed to the PassThrough the message is written to and to
@@ -140,7 +134,7 @@ export interface MimeNodeAddresses {
  */
 export interface MimeNodeStreamOptions extends TransformOptions {
     /** Maximum line length for base64 and quoted-printable bodies, false disables wrapping */
-    lineLength?: number | false;
+    lineLength?: number | false | undefined;
 }
 /**
  * A transform stream the message is piped through, or a function returning one
@@ -184,25 +178,16 @@ declare class MimeNode {
     hostname: string | undefined;
     newline: string | undefined;
     childNodes: MimeNode[];
-    _nodeId: number;
-    _headers: MimeNodeHeader[];
-    _isPlainText: boolean;
-    _hasLongLines: boolean;
-    _envelope: MimeNodeEnvelope | false;
-    _raw: MimeNodeContent | Error | false;
-    _transforms: MimeNodeTransform[];
-    _processFuncs: MimeNodeProcessFunc[];
     /** Filename for this node. Useful with attachments */
-    filename?: string;
+    filename?: string | undefined;
     /** Body content, or the error a content stream emitted before it was read */
-    content?: MimeNodeContent | Error;
+    content?: MimeNodeContent | Error | undefined;
     /** Lowercase content type, set when the headers are built */
-    contentType?: string;
+    contentType?: string | undefined;
     /** Multipart subtype, false for a non-multipart node, set when the headers are built */
-    multipart?: string | false;
+    multipart?: string | false | undefined;
     /** Multipart boundary, false for a non-multipart node, set when the headers are built */
-    boundary?: string | false;
-    _contentErrorHandler?: (err: Error) => void;
+    boundary?: string | false | undefined;
     constructor(contentType?: string | false, options?: MimeNodeOptions);
     /**
      * Creates and appends a child node.Arguments provided are passed to MimeNode constructor
@@ -333,145 +318,6 @@ declare class MimeNode {
      * @param raw Raw MIME contents
      */
     setRaw(raw: MimeNodeContent): this;
-    /**
-     * Checks an access policy flag for this node and every node above it. The flags are set
-     * from the options the node was built with, and createChild only ever sees the options
-     * the caller passed, so a child of a closed tree starts out open. Reading the answer off
-     * the parent chain keeps it right whatever order the tree was assembled in.
-     *
-     * @param flag Either 'disableFileAccess' or 'disableUrlAccess'
-     * @return true if this node or an ancestor closed that access
-     */
-    _accessDisabled(flag: 'disableFileAccess' | 'disableUrlAccess'): boolean;
-    /**
-     * Detects and returns handle to a stream related with the content.
-     *
-     * @param content Node content
-     * @returns Stream object
-     */
-    _getStream(content: any): Readable;
-    /**
-     * Parses addresses. Takes in a single address or an array or an
-     * array of address arrays (eg. To: [[first group], [second group],...])
-     *
-     * @param addresses Addresses to be parsed
-     * @return An array of address objects
-     */
-    _parseAddresses(addresses: MimeNodeAddressInput | undefined): MimeNodeAddress[];
-    /**
-     * Normalizes the addresses of a freshly parsed address list, groups included.
-     *
-     * Everything this method returns carries a normalized address, whether it arrived as an
-     * object or was parsed out of a header value. Without this the two shapes disagree, and
-     * a consumer reading the parsed form back is handed the ambiguous
-     * 'user@evil.com@good.com' that the header and the envelope no longer carry.
-     *
-     * @param parsed An array of address objects, as returned by addressparser
-     * @return The same array, with every address normalized
-     */
-    _normalizeParsedAddresses(parsed: Address[]): Address[];
-    /**
-     * Parses the addresses of an explicitly set envelope.
-     *
-     * An envelope value is an addr-spec and never a display name, so a bare local username
-     * such as 'root' is the address here. Header parsing has to read the same value as a
-     * display name, as a value with no '@' in it can not be an addr-spec in a header.
-     *
-     * @param addresses Addresses to be parsed
-     * @return An array of address objects
-     */
-    _parseEnvelopeAddresses(addresses: MimeNodeAddressInput | undefined): MimeNodeAddress[];
-    /**
-     * Normalizes a header key, uses Camel-Case form, except for uppercase MIME-
-     *
-     * @param key Key to be normalized
-     * @return key in Camel-Case form
-     */
-    _normalizeHeaderKey(key: string): string;
-    /**
-     * Checks if the content type is multipart and defines boundary if needed.
-     * Doesn't return anything, modifies object argument instead.
-     *
-     * @param structured Parsed header value for 'Content-Type' key
-     */
-    _handleContentType(structured: mimeFuncs.StructuredHeaderValue): void;
-    /**
-     * Generates a multipart boundary value
-     *
-     * @return boundary value
-     */
-    _generateBoundary(): string;
-    /**
-     * Encodes a header value for use in the generated rfc2822 email.
-     *
-     * @param key Header key
-     * @param value Header value
-     */
-    _encodeHeaderValue(key: string, value: MimeNodeHeaderValue): string;
-    /**
-     * Rebuilds address object using punycode and other adjustments
-     *
-     * @param addresses An array of address objects
-     * @param [uniqueList] An array to be populated with addresses
-     * @return address string
-     */
-    _convertAddresses(addresses: MimeNodeAddress | MimeNodeAddress[] | undefined, uniqueList?: MimeNodeAddress[], seenAddresses?: Set<string>): string;
-    /**
-     * Normalizes an email address
-     *
-     * @param address An array of address objects
-     * @return address string
-     */
-    _normalizeAddress(address?: string | false): string;
-    /**
-     * Normalizes the local part of an address into a form that can be emitted as is.
-     *
-     * A local part is either a dot-atom or a quoted-string, anything else is not a valid
-     * addr-spec. The quotes of a quoted local part get lost along the way, and a bare
-     * 'user@evil.com@good.com' leaves it to the receiver which '@' splits the domain off,
-     * while the split here is always at the last one. So whatever is not already one of
-     * the two valid forms goes back out as a quoted-string.
-     *
-     * @param user Local part of an address
-     * @return Local part as a dot-atom or as a quoted-string
-     */
-    _normalizeLocalPart(user: string): string;
-    /**
-     * If needed, mime encodes the name part
-     *
-     * @param name Name part of an address
-     * @returns Mime word encoded string if needed
-     */
-    _encodeAddressName(name: string): string;
-    /**
-     * Encodes an unstructured header value. Such a value can only carry VCHAR and WSP, so a
-     * control char or DEL has to be forced into the mime encoded word that a non-ascii value
-     * would get anyway. HT stays as it is, it is valid folding whitespace here.
-     *
-     * @param value Header value to encode
-     * @returns Mime word encoded string if needed
-     */
-    _encodeHeaderText(value: string): string;
-    /**
-     * If needed, mime encodes the name part
-     *
-     * @param name Name part of an address
-     * @returns Mime word encoded string if needed
-     */
-    _encodeWords(value: string): string;
-    /**
-     * Detects best mime encoding for a text value
-     *
-     * @param value Value to check for
-     * @return either 'Q' or 'B'
-     */
-    _getTextEncoding(value?: string | Buffer): string;
-    /**
-     * Generates a message id
-     *
-     * @return Random Message-ID value
-     */
-    _generateMessageId(): string;
 }
 /**
  * Type aliases in the layout of @types/nodemailer, so `MimeNode.Options` style references keep working

package/node_modules/nodemailer/dist/esm/mime-node/index.js

@@ -61,6 +61,23 @@ function normalizeDomain(domain, toUnicode) {
     }
     return toUnicode ? punycode.toUnicode(domain) : punycode.toASCII(domain);
 }
+/**
+ * Removes the characters that must never reach a multipart delimiter line.
+ *
+ * A line break splits the delimiter, so the boundary declared in the header can never
+ * match it again and the parts go out as body lines instead. The other C0 controls and
+ * DEL do not split anything but must not be written either: RFC 5321 does not allow a
+ * NUL in DATA at all, and an MTA or a scanner that stops at one reads a different
+ * message than a client that does not, which is the same parser disagreement a split
+ * delimiter creates. Both sides are cleaned together, since the declared value and the
+ * delimiters come from this one result.
+ *
+ * @param value Value to clean
+ * @return Value with every control character removed
+ */
+function _stripBoundaryControls(value) {
+    return value.replace(/[\x00-\x1f\x7f]+/g, '');
+}
 /**
  * Creates a new mime tree node. Assumes 'multipart/*' as the content type
  * if it is a branch, anything else counts as leaf. If rootNode is missing from
@@ -81,10 +98,11 @@ class MimeNode {
         this.nodeCounter = 0;
         options = options || {};
         /**
-         * shared part of the unique multipart boundary
+         * shared part of the unique multipart boundary. Control characters are dropped
+         * here rather than at the delimiter, see _stripBoundaryControls
          */
-        this.baseBoundary = options.baseBoundary || crypto.randomBytes(8).toString('hex');
-        this.boundaryPrefix = options.boundaryPrefix || '--_NmP';
+        this.baseBoundary = _stripBoundaryControls(options.baseBoundary || crypto.randomBytes(8).toString('hex'));
+        this.boundaryPrefix = _stripBoundaryControls(options.boundaryPrefix || '--_NmP');
         this.disableFileAccess = !!options.disableFileAccess;
         this.disableUrlAccess = !!options.disableUrlAccess;
         this.normalizeHeaderKey = options.normalizeHeaderKey;
@@ -916,6 +934,7 @@ class MimeNode {
      *
      * @param flag Either 'disableFileAccess' or 'disableUrlAccess'
      * @return true if this node or an ancestor closed that access
+     * @internal
      */
     _accessDisabled(flag) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -933,6 +952,7 @@ class MimeNode {
      *
      * @param content Node content
      * @returns Stream object
+     * @internal
      */
     _getStream(content) {
         let contentStream;
@@ -999,19 +1019,41 @@ class MimeNode {
      *
      * @param addresses Addresses to be parsed
      * @return An array of address objects
+     * @internal
      */
     _parseAddresses(addresses) {
-        // Collected into one list as we go. concat.apply spreads the entries into arguments
-        // and throws a RangeError once a recipient array is long enough to pass the
-        // argument limit, which a large Bcc list reaches on its own.
         const flattened = [];
-        [].concat(addresses).forEach(address => {
+        // Nested arrays are flattened iteratively. concat.apply throws once a recipient list
+        // is long enough to pass the argument limit, and an array handed to addressparser is
+        // stringified, which recurses once per nesting level and exhausts the call stack on
+        // a deep enough value. Every array is walked once, which also ends a self-referential
+        // input
+        const seen = new WeakSet();
+        const stack = [];
+        const enter = (list) => {
+            if (!seen.has(list)) {
+                seen.add(list);
+                stack.push({ list, pos: 0 });
+            }
+        };
+        enter(Array.isArray(addresses) ? addresses : [addresses]);
+        while (stack.length) {
+            const frame = stack[stack.length - 1];
+            if (frame.pos >= frame.list.length) {
+                stack.pop();
+                continue;
+            }
+            const address = frame.list[frame.pos++];
+            if (Array.isArray(address)) {
+                enter(address);
+                continue;
+            }
             if (address && address.address) {
                 const normalized = this._normalizeAddress(address.address);
                 if (normalized === address.address && typeof address.name === 'string') {
                     // there is nothing to rewrite, so there is nothing to keep off the original
                     flattened.push(address);
-                    return;
+                    continue;
                 }
                 // rewriting would land on the object the caller passed in and might
                 // still hold a reference to, so rewrite a copy of it instead. An own
@@ -1021,13 +1063,13 @@ class MimeNode {
                 copy.address = normalized;
                 copy.name = address.name || '';
                 flattened.push(copy);
-                return;
+                continue;
             }
             const parsed = this._normalizeParsedAddresses(addressparser(address));
             for (let i = 0; i < parsed.length; i++) {
                 flattened.push(parsed[i]);
             }
-        });
+        }
         return flattened;
     }
     /**
@@ -1040,6 +1082,7 @@ class MimeNode {
      *
      * @param parsed An array of address objects, as returned by addressparser
      * @return The same array, with every address normalized
+     * @internal
      */
     _normalizeParsedAddresses(parsed) {
         // addressparser builds these objects, so no caller holds a reference to rewrite around
@@ -1062,6 +1105,7 @@ class MimeNode {
      *
      * @param addresses Addresses to be parsed
      * @return An array of address objects
+     * @internal
      */
     _parseEnvelopeAddresses(addresses) {
         return this._parseAddresses(addresses).map(entry => {
@@ -1076,6 +1120,7 @@ class MimeNode {
      *
      * @param key Key to be normalized
      * @return key in Camel-Case form
+     * @internal
      */
     _normalizeHeaderKey(key) {
         key = (key || '')
@@ -1098,13 +1143,26 @@ class MimeNode {
      * Doesn't return anything, modifies object argument instead.
      *
      * @param structured Parsed header value for 'Content-Type' key
+     * @internal
      */
     _handleContentType(structured) {
         this.contentType = structured.value.trim().toLowerCase();
         this.multipart = /^multipart\//i.test(this.contentType) ? this.contentType.substr(this.contentType.indexOf('/') + 1) : false;
         if (this.multipart) {
+            // The declared value and the delimiters are assigned from the same expression
+            // here, so whatever the header emitter then does with it, the two sides cannot
+            // disagree about which characters the boundary is made of.
+            //
+            // Stripping runs before the fallback rather than over the whole chain: a
+            // boundary made only of control characters would otherwise strip to '' and
+            // leave the node declaring no boundary and streaming bare '--' delimiters.
+            // _generateBoundary cleans what it builds, but this is the one place the boundary
+            // is written, so it cleans the value it is about to write rather than trusting
+            // where it came from. MimeNode is exported and subclassable, so the generator is
+            // not necessarily the one below. Stripping twice costs nothing, it is idempotent.
+            const declared = _stripBoundaryControls(structured.params.boundary || this.boundary || '');
             this.boundary = structured.params.boundary =
-                structured.params.boundary || this.boundary || this._generateBoundary();
+                declared || _stripBoundaryControls(this._generateBoundary());
         }
         else {
             this.boundary = false;
@@ -1114,15 +1172,19 @@ class MimeNode {
      * Generates a multipart boundary value
      *
      * @return boundary value
+     * @internal
      */
     _generateBoundary() {
-        return this.rootNode.boundaryPrefix + '-' + this.rootNode.baseBoundary + '-Part_' + this._nodeId;
+        // baseBoundary and boundaryPrefix are public, so they may hold something the
+        // constructor never cleaned, and the -Part_ suffix keeps the result non empty
+        return _stripBoundaryControls(this.rootNode.boundaryPrefix + '-' + this.rootNode.baseBoundary) + '-Part_' + this._nodeId;
     }
     /**
      * Encodes a header value for use in the generated rfc2822 email.
      *
      * @param key Header key
      * @param value Header value
+     * @internal
      */
     _encodeHeaderValue(key, value) {
         key = this._normalizeHeaderKey(key);
@@ -1195,6 +1257,7 @@ class MimeNode {
      * @param addresses An array of address objects
      * @param [uniqueList] An array to be populated with addresses
      * @return address string
+     * @internal
      */
     _convertAddresses(addresses, uniqueList, seenAddresses) {
         const values = [];
@@ -1239,6 +1302,7 @@ class MimeNode {
      *
      * @param address An array of address objects
      * @return address string
+     * @internal
      */
     _normalizeAddress(address) {
         address = (address || '')
@@ -1285,6 +1349,7 @@ class MimeNode {
      *
      * @param user Local part of an address
      * @return Local part as a dot-atom or as a quoted-string
+     * @internal
      */
     _normalizeLocalPart(user) {
         if (DOT_ATOM.test(user) || QUOTED_STRING.test(user)) {
@@ -1297,6 +1362,7 @@ class MimeNode {
      *
      * @param name Name part of an address
      * @returns Mime word encoded string if needed
+     * @internal
      */
     _encodeAddressName(name) {
         if (!/^[\w ]*$/.test(name)) {
@@ -1316,6 +1382,7 @@ class MimeNode {
      *
      * @param value Header value to encode
      * @returns Mime word encoded string if needed
+     * @internal
      */
     _encodeHeaderText(value) {
         return /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value)
@@ -1328,6 +1395,7 @@ class MimeNode {
      *
      * @param name Name part of an address
      * @returns Mime word encoded string if needed
+     * @internal
      */
     _encodeWords(value) {
         // set encodeAll parameter to true even though it is against the recommendation of RFC2047,
@@ -1340,6 +1408,7 @@ class MimeNode {
      *
      * @param value Value to check for
      * @return either 'Q' or 'B'
+     * @internal
      */
     _getTextEncoding(value) {
         value = (value || '').toString();
@@ -1367,6 +1436,7 @@ class MimeNode {
      * Generates a message id
      *
      * @return Random Message-ID value
+     * @internal
      */
     _generateMessageId() {
         return ('<' +

package/node_modules/nodemailer/dist/esm/mime-node/last-newline.d.ts

@@ -1,7 +1,5 @@
-import { Transform, type TransformCallback } from 'node:stream';
+import { Transform } from 'node:stream';
 export default class LastNewline extends Transform {
     lastByte: number | false;
     constructor();
-    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
-    _flush(done: TransformCallback): void;
 }

package/node_modules/nodemailer/dist/esm/mime-node/last-newline.js

@@ -4,6 +4,7 @@ export default class LastNewline extends Transform {
         super();
         this.lastByte = false;
     }
+    /** @internal */
     _transform(chunk, encoding, done) {
         if (chunk.length) {
             this.lastByte = chunk[chunk.length - 1];
@@ -11,6 +12,7 @@ export default class LastNewline extends Transform {
         this.push(chunk);
         done();
     }
+    /** @internal */
     _flush(done) {
         if (this.lastByte === 0x0a) {
             return done();

package/node_modules/nodemailer/dist/esm/mime-node/le-unix.d.ts

@@ -1,4 +1,4 @@
-import { Transform, type TransformCallback, type TransformOptions } from 'node:stream';
+import { Transform, type TransformOptions } from 'node:stream';
 /**
  * Ensures that only <LF> is used for linebreaks
  *
@@ -6,8 +6,4 @@ import { Transform, type TransformCallback, type TransformOptions } from 'node:s
  */
 export default class LeUnix extends Transform {
     constructor(options?: TransformOptions);
-    /**
-     * Escapes dots
-     */
-    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
 }

package/node_modules/nodemailer/dist/esm/mime-node/le-unix.js

@@ -10,6 +10,7 @@ export default class LeUnix extends Transform {
     }
     /**
      * Escapes dots
+     * @internal
      */
     _transform(chunk, encoding, done) {
         let buf;

package/node_modules/nodemailer/dist/esm/mime-node/le-windows.d.ts

@@ -1,4 +1,4 @@
-import { Transform, type TransformCallback, type TransformOptions } from 'node:stream';
+import { Transform, type TransformOptions } from 'node:stream';
 /**
  * Ensures that only <CR><LF> sequences are used for linebreaks
  *
@@ -7,8 +7,4 @@ import { Transform, type TransformCallback, type TransformOptions } from 'node:s
 export default class LeWindows extends Transform {
     lastByte: number | false;
     constructor(options?: TransformOptions);
-    /**
-     * Escapes dots
-     */
-    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
 }

package/node_modules/nodemailer/dist/esm/mime-node/le-windows.js

@@ -11,6 +11,7 @@ export default class LeWindows extends Transform {
     }
     /**
      * Escapes dots
+     * @internal
      */
     _transform(chunk, encoding, done) {
         let buf;

package/node_modules/nodemailer/dist/esm/nodemailer.d.ts

@@ -25,7 +25,7 @@ export interface TestAccount {
     pop3: TestAccountService;
     web: string;
     /** true if the account can also receive external mail */
-    mxEnabled?: boolean;
+    mxEnabled?: boolean | undefined;
     [key: string]: unknown;
 }
 /**
@@ -77,7 +77,7 @@ export declare function createTestAccount(apiUrl?: string | false | null): Promi
  * @returns URL of the message in the Ethereal web interface, or false if the response does not carry one
  */
 export declare function getTestMessageUrl(info?: {
-    response?: string | Buffer | null;
+    response?: string | Buffer | null | undefined;
 } | false | null): string | false;
 declare const nodemailer: {
     createTransport: typeof createTransport;

package/node_modules/nodemailer/dist/esm/package-info.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "nodemailer";
-export declare const version = "10.0.0";
+export declare const version = "10.0.9";
 export declare const homepage = "https://nodemailer.com/";

package/node_modules/nodemailer/dist/esm/package-info.js

@@ -1,4 +1,4 @@
 // Generated by scripts/build.js from package.json. Do not edit by hand.
 export const name = 'nodemailer';
-export const version = '10.0.0';
+export const version = '10.0.9';
 export const homepage = 'https://nodemailer.com/';