nodemailer 10.0.0 → 10.0.2

package/dist/cjs/mime-node/index.js

@@ -954,6 +954,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
@@ -971,6 +972,7 @@ class MimeNode {
      *
      * @param content Node content
      * @returns Stream object
+     * @internal
      */
     _getStream(content) {
         let contentStream;
@@ -1037,19 +1039,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
@@ -1059,13 +1083,13 @@ class MimeNode {
                 copy.address = normalized;
                 copy.name = address.name || '';
                 flattened.push(copy);
-                return;
+                continue;
             }
             const parsed = this._normalizeParsedAddresses((0, index_js_1.default)(address));
             for (let i = 0; i < parsed.length; i++) {
                 flattened.push(parsed[i]);
             }
-        });
+        }
         return flattened;
     }
     /**
@@ -1078,6 +1102,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
@@ -1100,6 +1125,7 @@ class MimeNode {
      *
      * @param addresses Addresses to be parsed
      * @return An array of address objects
+     * @internal
      */
     _parseEnvelopeAddresses(addresses) {
         return this._parseAddresses(addresses).map(entry => {
@@ -1114,6 +1140,7 @@ class MimeNode {
      *
      * @param key Key to be normalized
      * @return key in Camel-Case form
+     * @internal
      */
     _normalizeHeaderKey(key) {
         key = (key || '')
@@ -1136,6 +1163,7 @@ 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();
@@ -1152,6 +1180,7 @@ class MimeNode {
      * Generates a multipart boundary value
      *
      * @return boundary value
+     * @internal
      */
     _generateBoundary() {
         return this.rootNode.boundaryPrefix + '-' + this.rootNode.baseBoundary + '-Part_' + this._nodeId;
@@ -1161,6 +1190,7 @@ class MimeNode {
      *
      * @param key Header key
      * @param value Header value
+     * @internal
      */
     _encodeHeaderValue(key, value) {
         key = this._normalizeHeaderKey(key);
@@ -1233,6 +1263,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 = [];
@@ -1277,6 +1308,7 @@ class MimeNode {
      *
      * @param address An array of address objects
      * @return address string
+     * @internal
      */
     _normalizeAddress(address) {
         address = (address || '')
@@ -1323,6 +1355,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)) {
@@ -1335,6 +1368,7 @@ class MimeNode {
      *
      * @param name Name part of an address
      * @returns Mime word encoded string if needed
+     * @internal
      */
     _encodeAddressName(name) {
         if (!/^[\w ]*$/.test(name)) {
@@ -1354,6 +1388,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)
@@ -1366,6 +1401,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,
@@ -1378,6 +1414,7 @@ class MimeNode {
      *
      * @param value Value to check for
      * @return either 'Q' or 'B'
+     * @internal
      */
     _getTextEncoding(value) {
         value = (value || '').toString();
@@ -1405,6 +1442,7 @@ class MimeNode {
      * Generates a message id
      *
      * @return Random Message-ID value
+     * @internal
      */
     _generateMessageId() {
         return ('<' +

package/dist/cjs/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/dist/cjs/mime-node/last-newline.js

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

package/dist/cjs/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/dist/cjs/mime-node/le-unix.js

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

package/dist/cjs/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/dist/cjs/mime-node/le-windows.js

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

package/dist/cjs/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/dist/cjs/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.2";
 export declare const homepage = "https://nodemailer.com/";

package/dist/cjs/package-info.js

@@ -3,5 +3,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.homepage = exports.version = exports.name = void 0;
 exports.name = 'nodemailer';
-exports.version = '10.0.0';
+exports.version = '10.0.2';
 exports.homepage = 'https://nodemailer.com/';

package/dist/cjs/qp/index.d.ts

@@ -1,4 +1,4 @@
-import { Transform, type TransformCallback } from 'node:stream';
+import { Transform } from 'node:stream';
 export declare function encode(buffer: Buffer | string): string;
 /**
  * Adds soft line breaks to a Quoted-Printable string
@@ -13,7 +13,7 @@ export declare function wrap(str: string, lineLength?: number): string;
  */
 export interface QPEncoderOptions {
     /** Maximum length for lines, set to false to disable wrapping */
-    lineLength?: number | false;
+    lineLength?: number | false | undefined;
 }
 /**
  * Creates a transform stream for encoding data to Quoted-Printable encoding
@@ -26,8 +26,5 @@ export declare class Encoder extends Transform {
     options: QPEncoderOptions;
     inputBytes: number;
     outputBytes: number;
-    _curLine: string;
     constructor(options?: QPEncoderOptions);
-    _transform(chunk: Buffer | string, encoding: BufferEncoding | 'buffer', done: TransformCallback): void;
-    _flush(done: TransformCallback): void;
 }

package/dist/cjs/qp/index.js

@@ -157,6 +157,7 @@ class Encoder extends node_stream_1.Transform {
         this.inputBytes = 0;
         this.outputBytes = 0;
     }
+    /** @internal */
     _transform(chunk, encoding, done) {
         let qp;
         if (encoding !== 'buffer') {
@@ -185,6 +186,7 @@ class Encoder extends node_stream_1.Transform {
         }
         done();
     }
+    /** @internal */
     _flush(done) {
         if (this._curLine) {
             this.outputBytes += this._curLine.length;

package/dist/cjs/sendmail-transport/index.d.ts

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import type { Logger } from '../shared/index.js';
 import type { MimeNodeEnvelope } from '../mime-node/index.js';
 import type MailMessage from '../mailer/mail-message.js';
@@ -8,13 +7,13 @@ import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOption
  */
 export interface SendmailTransportOptions extends TransportOptions {
     /** Selects this transport in createTransport, the binary itself is set with `path` */
-    sendmail?: boolean | string;
+    sendmail?: boolean | string | undefined;
     /** Path to the sendmail binary, defaults to 'sendmail' */
-    path?: string;
+    path?: string | undefined;
     /** Either 'windows' or 'unix', the line ending of the message piped to sendmail */
-    newline?: string;
+    newline?: string | undefined;
     /** Arguments for the sendmail binary, replaces the default '-f <sender>' */
-    args?: string[];
+    args?: string[] | undefined;
 }
 /**
  * The value the Sendmail transport hands to the send callback
@@ -41,7 +40,6 @@ export interface SendmailSentMessageInfo extends SentMessageInfo {
  */
 declare class SendmailTransport {
     mailer: Mail<SendmailSentMessageInfo>;
-    _spawn: typeof spawn;
     options: SendmailTransportOptions;
     name: string;
     version: string;

package/dist/cjs/ses-transport/index.d.ts

@@ -12,9 +12,9 @@ export interface SESTransportOptions extends TransportOptions {
         /** SESv2Client instance. Its config.region provider is resolved for the domain of the returned Message-ID */
         sesClient: {
             config?: {
-                region?: () => Promise<string>;
+                region?: (() => Promise<string>) | undefined;
                 [key: string]: any;
-            };
+            } | undefined;
             send(command: unknown): Promise<any>;
         };
         /** SendEmailCommand class, constructed with the SendEmailCommandInput of every message */

package/dist/cjs/shared/index.d.ts

@@ -9,39 +9,36 @@ export { isProtoKey, copyOwnKeys };
  */
 export interface ResolveHostnameOptions {
     /** Hostname or IP address to resolve */
-    host?: string;
+    host?: string | undefined;
     /** Server name for TLS, used as the host when no host is set */
-    servername?: string;
+    servername?: string | undefined;
     /** Count loopback interfaces when checking which address families are usable */
-    allowInternalNetworkInterfaces?: boolean;
+    allowInternalNetworkInterfaces?: boolean | undefined;
     /** How long a resolved value stays cached, in milliseconds (default 5 minutes) */
-    dnsTtl?: number;
+    dnsTtl?: number | undefined;
     /** Query timeout in milliseconds, passed to dns.Resolver */
-    timeout?: number;
+    timeout?: number | undefined;
     /** Number of query attempts, passed to dns.Resolver */
-    tries?: number;
+    tries?: number | undefined;
 }
 /**
  * Resolved value handed to the resolveHostname callback
  */
 export interface ResolvedHostname {
     /** Server name to use for TLS, false when an IP literal was given without one */
-    servername?: string | false;
+    servername?: string | false | undefined;
     /** Address to connect to, picked at random from the resolved addresses */
-    host?: string | null;
-    /** All resolved addresses, for connection fallback support */
-    _addresses?: string[];
+    host?: string | null | undefined;
     /** Whether the value came from the DNS cache */
-    cached?: boolean;
+    cached?: boolean | undefined;
     /** The resolver error when a cached value was used because of it */
-    error?: Error;
+    error?: Error | undefined;
 }
 /**
  * Resolved addresses as stored in the DNS cache
  */
 export interface DnsCacheValue {
     addresses: string[];
-    servername: string | false;
 }
 /**
  * A DNS cache entry
@@ -49,26 +46,26 @@ export interface DnsCacheValue {
 export interface DnsCacheEntry {
     value: DnsCacheValue;
     /** Expiration time as a timestamp, entries without one never expire */
-    expires?: number;
+    expires?: number | undefined;
 }
 /**
  * Configuration object parsed from a connection url. Query parameters become
  * top level keys, `tls.*` parameters go into `tls`
  */
 export interface ConnectionUrlOptions {
-    secure?: boolean;
-    direct?: boolean;
-    port?: number;
-    host?: string;
+    secure?: boolean | undefined;
+    direct?: boolean | undefined;
+    port?: number | undefined;
+    host?: string | undefined;
     /** Well-known service name from the ?service= query parameter */
-    service?: string;
+    service?: string | undefined;
     auth?: {
         user: string;
         pass: string;
-    };
+    } | undefined;
     tls?: {
         [key: string]: unknown;
-    };
+    } | undefined;
     [key: string]: unknown;
 }
 /**
@@ -77,12 +74,12 @@ export interface ConnectionUrlOptions {
  */
 export interface LogEntry {
     /** 'server' or 'client' for SMTP transaction lines */
-    tnx?: string;
+    tnx?: string | undefined;
     /** Session id */
-    sid?: string;
+    sid?: string | undefined;
     /** Connection id */
-    cid?: string | number;
-    level?: string;
+    cid?: string | number | undefined;
+    level?: string | undefined;
     [key: string]: any;
 }
 export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
@@ -105,7 +102,7 @@ export interface ExternalLogger {
  */
 export interface GetLoggerOptions {
     /** A bunyan compatible logger, true for the default console logger, false or unset for no logging */
-    logger?: ExternalLogger | boolean;
+    logger?: ExternalLogger | boolean | undefined;
 }
 /**
  * The bunyan compatible logger interface returned by getLogger
@@ -137,9 +134,9 @@ export interface ParsedDataURI {
  */
 export interface ResolveContentOptions {
     /** Reject content that points to a file path */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Reject content that points to a URL */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
 }
 /**
  * An object value resolveContent understands. A plain string or Buffer value is returned as
@@ -148,23 +145,21 @@ export interface ResolveContentOptions {
  */
 export interface ContentDescriptor {
     /** The content itself, a string, a Buffer or a readable stream */
-    content?: string | Buffer | Readable;
+    content?: string | Buffer | Readable | undefined;
     /** Encoding of a string `content`, it is decoded into a Buffer unless it is utf8 or ascii */
-    encoding?: string;
+    encoding?: string | undefined;
     /** File path, http(s) URL or data URI 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;
-    };
+    } | undefined;
 }
 export type ResolveContentCallback = (err: Error | null, value?: any) => void;
-export declare const _lastCacheCleanup: () => number;
-export declare const _resetCacheCleanup: () => void;
 export declare let networkInterfaces: NodeJS.Dict<os.NetworkInterfaceInfo[]> | undefined;
 export declare const dnsCache: Map<string, DnsCacheEntry>;
 export declare const resolveHostname: (options: ResolveHostnameOptions | undefined, callback: (err: Error | null, result?: ResolvedHostname) => void) => void;
@@ -175,7 +170,6 @@ export declare const resolveHostname: (options: ResolveHostnameOptions | undefin
  * @return Configuration object
  */
 export declare const parseConnectionUrl: (str?: string | null) => ConnectionUrlOptions;
-export declare const _logFunc: (logger: ExternalLogger, level: string, defaults: LogEntry | undefined, data: LogEntry | undefined, message?: string, ...args: any[]) => void;
 /**
  * Returns a bunyan-compatible logger interface. Uses either provided logger or
  * creates a default console logger

package/dist/cjs/shared/index.js

@@ -54,8 +54,10 @@ const DNS_TTL = 5 * 60 * 1000;
 const CACHE_CLEANUP_INTERVAL = 30 * 1000; // Minimum 30 seconds between cleanups
 const MAX_CACHE_SIZE = 1000; // Maximum number of entries in cache
 let lastCacheCleanup = 0;
+/** @internal */
 const _lastCacheCleanup = () => lastCacheCleanup;
 exports._lastCacheCleanup = _lastCacheCleanup;
+/** @internal */
 const _resetCacheCleanup = () => {
     lastCacheCleanup = 0;
 };
@@ -107,7 +109,6 @@ const formatDNSValue = (value, extra) => {
     // Select a random address from available addresses, or null if none
     const host = addresses.length > 0 ? addresses[Math.floor(Math.random() * addresses.length)] : null;
     return Object.assign({
-        servername: value.servername,
         host,
         // Include all addresses for connection fallback support
         _addresses: addresses
@@ -121,14 +122,19 @@ const resolveHostname = (options, callback) => {
     if (!options.host || node_net_1.default.isIP(options.host)) {
         // nothing to do here
         const value = {
-            addresses: [options.host],
-            servername: options.servername || false
+            addresses: [options.host]
         };
         return callback(null, formatDNSValue(value, {
+            servername: options.servername || false,
             cached: false
         }));
     }
     const host = options.host;
+    // The TLS server name belongs to the connection asking, not to the host it resolves. The
+    // cache is shared by every transport of the process and keyed by host alone, so a server
+    // name stored in it would be the one of whichever transport resolved the host first, and a
+    // later transport with its own tls.servername would present and verify that name instead
+    const servername = options.servername || host;
     let cached;
     if (exports.dnsCache.has(options.host)) {
         cached = exports.dnsCache.get(options.host);
@@ -151,6 +157,7 @@ const resolveHostname = (options, callback) => {
         }
         if (!cached.expires || cached.expires >= now) {
             return callback(null, formatDNSValue(cached.value, {
+                servername,
                 cached: true
             }));
         }
@@ -178,14 +185,14 @@ const resolveHostname = (options, callback) => {
             const allAddresses = ipv4Addresses.concat(ipv6Addresses);
             if (allAddresses.length) {
                 const value = {
-                    addresses: allAddresses,
-                    servername: options.servername || host
+                    addresses: allAddresses
                 };
                 exports.dnsCache.set(host, {
                     value,
                     expires: Date.now() + (options.dnsTtl || DNS_TTL)
                 });
                 return callback(null, formatDNSValue(value, {
+                    servername,
                     cached: false
                 }));
             }
@@ -198,6 +205,7 @@ const resolveHostname = (options, callback) => {
                         expires: Date.now() + (options.dnsTtl || DNS_TTL)
                     });
                     return callback(null, formatDNSValue(cached.value, {
+                        servername,
                         cached: true,
                         error: ipv4Error
                     }));
@@ -212,6 +220,7 @@ const resolveHostname = (options, callback) => {
                                 expires: Date.now() + (options.dnsTtl || DNS_TTL)
                             });
                             return callback(null, formatDNSValue(cached.value, {
+                                servername,
                                 cached: true,
                                 error: err
                             }));
@@ -229,18 +238,19 @@ const resolveHostname = (options, callback) => {
                     if (!supportedAddresses.length && cached) {
                         // nothing was found, fallback to cached value
                         return callback(null, formatDNSValue(cached.value, {
+                            servername,
                             cached: true
                         }));
                     }
                     const value = {
-                        addresses: supportedAddresses.length ? supportedAddresses : [host],
-                        servername: options.servername || host
+                        addresses: supportedAddresses.length ? supportedAddresses : [host]
                     };
                     exports.dnsCache.set(host, {
                         value,
                         expires: Date.now() + (options.dnsTtl || DNS_TTL)
                     });
                     return callback(null, formatDNSValue(value, {
+                        servername,
                         cached: false
                     }));
                 });
@@ -252,6 +262,7 @@ const resolveHostname = (options, callback) => {
                         expires: Date.now() + (options.dnsTtl || DNS_TTL)
                     });
                     return callback(null, formatDNSValue(cached.value, {
+                        servername,
                         cached: true,
                         error: lookupErr
                     }));
@@ -331,6 +342,7 @@ const parseConnectionUrl = (str) => {
     return options;
 };
 exports.parseConnectionUrl = parseConnectionUrl;
+/** @internal */
 const _logFunc = (logger, level, defaults, data, message, ...args) => {
     const entry = Object.assign({}, defaults || {}, data || {});
     delete entry.level;

package/dist/cjs/smtp-connection/data-stream.d.ts

@@ -1,4 +1,4 @@
-import { Transform, type TransformCallback, type TransformOptions } from 'node:stream';
+import { Transform, type TransformOptions } from 'node:stream';
 /**
  * Escapes dots in the beginning of lines. Ends the stream with <CR><LF>.<CR><LF>
  * Also makes sure that only <CR><LF> sequences are used for linebreaks
@@ -11,12 +11,4 @@ export default class DataStream extends Transform {
     outByteCount: number;
     lastByte: number | false;
     constructor(options?: TransformOptions);
-    /**
-     * Escapes dots
-     */
-    _transform(chunk: Buffer | string, encoding: BufferEncoding, done: TransformCallback): void;
-    /**
-     * Finalizes the stream with a dot on a single line
-     */
-    _flush(done: TransformCallback): void;
 }