m06_task3.js 1.0.0

package/package/node_modules/@types/nodemailer/lib/mime-funcs/index.d.ts

@@ -0,0 +1,87 @@
+export interface HeaderValue {
+    value: string;
+    params?: { [key: string]: string } | undefined;
+}
+
+export interface ParsedHeaderValue extends HeaderValue {
+    params: { [key: string]: string };
+}
+
+export interface ParsedHeaderParam {
+    key: string;
+    value: string;
+}
+
+/** Checks if a value is plaintext string (uses only printable 7bit chars) */
+export function isPlainText(value: string): boolean;
+
+/**
+ * Checks if a multi line string containes lines longer than the selected value.
+ *
+ * Useful when detecting if a mail message needs any processing at all –
+ * if only plaintext characters are used and lines are short, then there is
+ * no need to encode the values in any way. If the value is plaintext but has
+ * longer lines then allowed, then use format=flowed
+ */
+export function hasLongerLines(str: string, lineLength: number): boolean;
+
+/** Encodes a string or an Buffer to an UTF-8 MIME Word (rfc2047) */
+export function encodeWord(data: Buffer | string, mimeWordEncoding?: 'Q' | 'B', maxLength?: number): string;
+
+/** Finds word sequences with non ascii text and converts these to mime words */
+export function encodeWords(value: string, mimeWordEncoding?: 'Q' | 'B', maxLength?: number): string;
+
+/**
+ * Joins parsed header value together as 'value; param1=value1; param2=value2'
+ * PS: We are following RFC 822 for the list of special characters that we need to keep in quotes.
+ *      Refer: https://www.w3.org/Protocols/rfc1341/4_Content-Type.html
+ */
+export function buildHeaderValue(structured: HeaderValue): string;
+
+/**
+ * Encodes a string or an Buffer to an UTF-8 Parameter Value Continuation encoding (rfc2231)
+ * Useful for splitting long parameter values.
+ *
+ * For example
+ * ```
+ *     title="unicode string"
+ * ```
+ * becomes
+ * ```
+ *     title*0*=utf-8''unicode
+ *     title*1*=%20string
+ * ```
+ */
+export function buildHeaderParam(key: string, data: Buffer | string, maxLength?: number): ParsedHeaderParam[];
+
+/**
+ * Parses a header value with key=value arguments into a structured
+ * object.
+ *
+ * ```
+ *   parseHeaderValue('content-type: text/plain; CHARSET='UTF-8') ->
+ *   {
+ *     'value': 'text/plain',
+ *     'params': {
+ *       'charset': 'UTF-8'
+ *     }
+ *   }
+ * ```
+ */
+export function parseHeaderValue(str: string): ParsedHeaderValue;
+
+/** Returns file extension for a content type string. If no suitable extensions are found, 'bin' is used as the default extension */
+export function detectExtension(mimeType: string): string;
+
+/** Returns content type for a file extension. If no suitable content types are found, 'application/octet-stream' is used as the default content type */
+export function detectMimeType(extension: string): string;
+
+/** Folds long lines, useful for folding header lines (afterSpace=false) and flowed text (afterSpace=true) */
+export function foldLines(str: string, lineLength?: number, afterSpace?: boolean): string;
+
+/** Splits a mime encoded string. Needed for dividing mime words into smaller chunks */
+export function splitMimeEncodedString(str: string, maxlen?: number): string[];
+
+export function encodeURICharComponent(chr: string): string;
+
+export function safeEncodeURIComponent(str: string): string;

package/package/node_modules/@types/nodemailer/lib/mime-funcs/mime-types.d.ts

@@ -0,0 +1,2 @@
+export function detectMimeType(filename: string | false): string;
+export function detectExtension(mimeType: string | false): string;

package/package/node_modules/@types/nodemailer/lib/mime-node/index.d.ts

@@ -0,0 +1,137 @@
+/// <reference types="node" />
+
+import { Readable, ReadableOptions, Transform } from 'stream';
+
+import Mail = require('../mailer');
+import SMTPConnection = require('../smtp-connection');
+
+declare namespace MimeNode {
+    interface Addresses {
+        from?: string[] | undefined;
+        sender?: string[] | undefined;
+        'reply-to'?: string[] | undefined;
+        to?: string[] | undefined;
+        cc?: string[] | undefined;
+        bcc?: string[] | undefined;
+    }
+
+    interface Envelope {
+        /** includes an address object or is set to false */
+        from: string | false;
+        /** includes an array of address objects */
+        to: string[];
+    }
+
+    interface Options {
+        /** root node for this tree */
+        rootNode?: MimeNode | undefined;
+        /** immediate parent for this node */
+        parentNode?: MimeNode | undefined;
+        /** filename for an attachment node */
+        filename?: string | undefined;
+        /** shared part of the unique multipart boundary */
+        baseBoundary?: string | undefined;
+        /** If true, do not exclude Bcc from the generated headers */
+        keepBcc?: boolean | undefined;
+        /** either 'Q' (the default) or 'B' */
+        textEncoding?: 'B' | 'Q' | undefined;
+        /** method to normalize header keys for custom caseing */
+        normalizeHeaderKey?(key: string): string;
+    }
+}
+
+/**
+ * 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
+ * the options, assumes this is the root.
+ */
+declare class MimeNode {
+    constructor(contentType?: string, options?: MimeNode.Options);
+
+    /** Creates and appends a child node.Arguments provided are passed to MimeNode constructor */
+    createChild(contentType: string, options?: MimeNode.Options): MimeNode;
+
+    /** Appends an existing node to the mime tree. Removes the node from an existing tree if needed */
+    appendChild(childNode: MimeNode): MimeNode;
+
+    /** Replaces current node with another node */
+    replace(node: MimeNode): MimeNode;
+
+    /** Removes current node from the mime tree */
+    remove(): this;
+
+    /**
+     * Sets a header value. If the value for selected key exists, it is overwritten.
+     * You can set multiple values as well by using [{key:'', value:''}] or
+     * {key: 'value'} as the first argument.
+     */
+    setHeader(key: string, value: string | string[]): this;
+    setHeader(headers: { [key: string]: string } | Array<{ key: string, value: string }>): this;
+
+    /**
+     * Adds a header value. If the value for selected key exists, the value is appended
+     * as a new field and old one is not touched.
+     * You can set multiple values as well by using [{key:'', value:''}] or
+     * {key: 'value'} as the first argument.
+     */
+    addHeader(key: string, value: string): this;
+    addHeader(headers: { [key: string]: string } | Array<{ key: string, value: string }>): this;
+
+    /** Retrieves the first mathcing value of a selected key */
+    getHeader(key: string): string;
+
+    /**
+     * Sets body content for current node. If the value is a string, charset is added automatically
+     * to Content-Type (if it is text/*). If the value is a Buffer, you need to specify
+     * the charset yourself
+     */
+    setContent(content: string | Buffer | Readable): this;
+
+    /** Generate the message and return it with a callback or promise */
+    build(callback: (err: Error | null, buf: Buffer) => void): void;
+    build(): Promise<Buffer>;
+
+    getTransferEncoding(): string;
+
+    /** Builds the header block for the mime node. Append \r\n\r\n before writing the content */
+    buildHeaders(): string;
+
+    /**
+     * Streams the rfc2822 message from the current node. If this is a root node,
+     * mandatory header fields are set if missing (Date, Message-Id, MIME-Version)
+     */
+    createReadStream(options?: ReadableOptions): Readable;
+
+    /**
+     * Appends a transform stream object to the transforms list. Final output
+     * is passed through this stream before exposing
+     */
+    transform(transform: Transform): void;
+
+    /**
+     * Appends a post process function. The functon is run after transforms and
+     * uses the following syntax
+     *
+     *   processFunc(input) -> outputStream
+     */
+    processFunc(processFunc: (outputStream: Readable) => Readable): void;
+
+    stream(outputStream: Readable, options: ReadableOptions, done: (err?: Error | null) => void): void;
+
+    /** Sets envelope to be used instead of the generated one */
+    setEnvelope(envelope: Mail.Envelope): this;
+
+    /** Generates and returns an object with parsed address fields */
+    getAddresses(): MimeNode.Addresses;
+
+    /** Generates and returns SMTP envelope with the sender address and a list of recipients addresses */
+    getEnvelope(): MimeNode.Envelope;
+
+    /** Returns Message-Id value. If it does not exist, then creates one */
+    messageId(): string;
+
+    /** Sets pregenerated content that will be used as the output of this node */
+    setRaw(raw: string | Buffer | Readable): this;
+}
+
+export = MimeNode;

package/package/node_modules/@types/nodemailer/lib/mime-node/last-newline.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+
+import { Transform } from 'stream';
+
+declare class LastNewline extends Transform {
+    lastByte: boolean;
+}
+
+export = LastNewline;

package/package/node_modules/@types/nodemailer/lib/qp/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+
+import { Transform, TransformOptions } from 'stream';
+
+/** Encodes a Buffer into a Quoted-Printable encoded string */
+export function encode(buffer: Buffer | string): string;
+
+/** Adds soft line breaks to a Quoted-Printable string */
+export function wrap(str: string, lineLength?: number): string;
+
+export interface EncoderOptions extends TransformOptions {
+    lineLength?: number | false | undefined;
+}
+
+/** Creates a transform stream for encoding data to Quoted-Printable encoding */
+export class Encoder extends Transform {
+    options: EncoderOptions;
+
+    inputBytes: number;
+    outputBytes: number;
+
+    constructor(options?: EncoderOptions);
+}

package/package/node_modules/@types/nodemailer/lib/sendmail-transport/index.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+
+import { Transport, TransportOptions } from '../..';
+
+import * as shared from '../shared';
+
+import Mail = require('../mailer');
+import MailMessage = require('../mailer/mail-message');
+import MimeNode = require('../mime-node');
+
+declare namespace SendmailTransport {
+    type MailOptions = Mail.Options;
+
+    interface Options extends MailOptions, TransportOptions {
+        sendmail: true;
+        /** path to the sendmail command (defaults to ‘sendmail’) */
+        path?: string | undefined;
+        /** either ‘windows’ or ‘unix’ (default). Forces all newlines in the output to either use Windows syntax <CR><LF> or Unix syntax <LF> */
+        newline?: string | undefined;
+        /** an optional array of command line options to pass to the sendmail command (ie. ["-f", "foo@blurdybloop.com"]). This overrides all default arguments except for ’-i’ and recipient list so you need to make sure you have all required arguments set (ie. the ‘-f’ flag). */
+        args?: string[] | undefined;
+    }
+
+    interface SentMessageInfo {
+        envelope: MimeNode.Envelope;
+        messageId: string;
+        response: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+    }
+}
+
+declare class SendmailTransport implements Transport<SendmailTransport.SentMessageInfo> {
+    options: SendmailTransport.Options;
+    logger: shared.Logger;
+    mailer: Mail<SendmailTransport.SentMessageInfo>;
+    name: string;
+    version: string;
+    path: string;
+    args: string[] | false;
+    winbreak: boolean;
+
+    constructor(options: SendmailTransport.Options);
+
+    /** Compiles a mailcomposer message and forwards it to handler that sends it */
+    send(
+        mail: MailMessage<SendmailTransport.SentMessageInfo>,
+        callback: (err: Error | null, info: SendmailTransport.SentMessageInfo) => void,
+    ): void;
+}
+
+export = SendmailTransport;

package/package/node_modules/@types/nodemailer/lib/sendmail-transport/le-unix.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+
+import { Transform } from 'stream';
+
+declare class LeUnix extends Transform {}
+
+export = LeUnix;

package/package/node_modules/@types/nodemailer/lib/sendmail-transport/le-windows.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+
+import { Transform } from 'stream';
+
+declare class LeWindows extends Transform {}
+
+export = LeWindows;

package/package/node_modules/@types/nodemailer/lib/ses-transport/index.d.ts

@@ -0,0 +1,136 @@
+/// <reference types="node" />
+
+import { EventEmitter } from 'events';
+
+import { Transport, TransportOptions } from '../..';
+
+import * as shared from '../shared';
+
+import Mail = require('../mailer');
+import MailMessage = require('../mailer/mail-message');
+import MimeNode = require('../mime-node');
+
+declare namespace SESTransport {
+    interface MailOptions extends Mail.Options {
+        /** list of keys that SendRawEmail method can take */
+        ses?: MailSesOptions | undefined;
+    }
+
+    interface MailSesOptions {
+        /**
+         * The identity's email address. If you do not provide a value for this parameter, you must specify a "From" address in the raw text of the message. (You can also specify both.)  Amazon SES does not support the SMTPUTF8 extension, as described inRFC6531. For this reason, the local part of a source email address (the part of the email address that precedes the @ sign) may only contain 7-bit ASCII characters. If the domain part of an address (the part after the @ sign) contains non-ASCII characters, they must be encoded using Punycode, as described in RFC3492. The sender name (also known as the friendly name) may contain non-ASCII characters. These characters must be encoded using MIME encoded-word syntax, as described in RFC 2047. MIME encoded-word syntax uses the following form: =?charset?encoding?encoded-text?=.  If you specify the Source parameter and have feedback forwarding enabled, then bounces and complaints will be sent to this email address. This takes precedence over any Return-Path header that you might include in the raw text of the message.
+         */
+        Source?: string | undefined;
+        /**
+         * A list of destinations for the message, consisting of To:, CC:, and BCC: addresses.
+         */
+        Destinations?: string[] | undefined;
+        /**
+         * The raw email message itself. The message has to meet the following criteria:   The message has to contain a header and a body, separated by a blank line.   All of the required header fields must be present in the message.   Each part of a multipart MIME message must be formatted properly.   Attachments must be of a content type that Amazon SES supports. For a list on unsupported content types, see Unsupported Attachment Types in the Amazon SES Developer Guide.   The entire message must be base64-encoded.   If any of the MIME parts in your message contain content that is outside of the 7-bit ASCII character range, we highly recommend that you encode that content. For more information, see Sending Raw Email in the Amazon SES Developer Guide.   Per RFC 5321, the maximum length of each line of text, including the &lt;CRLF&gt;, must not exceed 1,000 characters.
+         */
+        RawMessage?: {
+            /**
+             * The raw data of the message. This data needs to base64-encoded if you are accessing Amazon SES directly through the HTTPS interface. If you are accessing Amazon SES using an AWS SDK, the SDK takes care of the base 64-encoding for you. In all cases, the client must ensure that the message format complies with Internet email standards regarding email header fields, MIME types, and MIME encoding. The To:, CC:, and BCC: headers in the raw message can contain a group list. If you are using SendRawEmail with sending authorization, you can include X-headers in the raw message to specify the "Source," "From," and "Return-Path" addresses. For more information, see the documentation for SendRawEmail.   Do not include these X-headers in the DKIM signature, because they are removed by Amazon SES before sending the email.  For more information, go to the Amazon SES Developer Guide.
+             */
+            Data: Buffer|Uint8Array|{}|string;
+        } | undefined;
+        /**
+         * This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to specify a particular "From" address in the header of the raw email. Instead of using this parameter, you can use the X-header X-SES-FROM-ARN in the raw message of the email. If you use both the FromArn parameter and the corresponding X-header, Amazon SES uses the value of the FromArn parameter.  For information about when to use this parameter, see the description of SendRawEmail in this guide, or see the Amazon SES Developer Guide.
+         */
+        FromArn?: string | undefined;
+        /**
+         * This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to send for the email address specified in the Source parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to send from user@example.com, then you would specify the SourceArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the Source to be user@example.com. Instead of using this parameter, you can use the X-header X-SES-SOURCE-ARN in the raw message of the email. If you use both the SourceArn parameter and the corresponding X-header, Amazon SES uses the value of the SourceArn parameter.  For information about when to use this parameter, see the description of SendRawEmail in this guide, or see the Amazon SES Developer Guide.
+         */
+        SourceArn?: string | undefined;
+        /**
+         * This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to use the email address specified in the ReturnPath parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to use feedback@example.com, then you would specify the ReturnPathArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the ReturnPath to be feedback@example.com. Instead of using this parameter, you can use the X-header X-SES-RETURN-PATH-ARN in the raw message of the email. If you use both the ReturnPathArn parameter and the corresponding X-header, Amazon SES uses the value of the ReturnPathArn parameter.  For information about when to use this parameter, see the description of SendRawEmail in this guide, or see the Amazon SES Developer Guide.
+         */
+        ReturnPathArn?: string | undefined;
+        /**
+         * A list of tags, in the form of name/value pairs, to apply to an email that you send using SendRawEmail. Tags correspond to characteristics of the email that you define, so that you can publish email sending events.
+         */
+        Tags?: Array<{
+            /**
+             * The name of the tag. The name must:   This value can only contain ASCII letters (a-z, A-Z), numbers (0-9), underscores (_), or dashes (-).   Contain less than 256 characters.
+             */
+            Name: string;
+            /**
+             * The value of the tag. The value must:   This value can only contain ASCII letters (a-z, A-Z), numbers (0-9), underscores (_), or dashes (-).   Contain less than 256 characters.
+             */
+            Value: string;
+        }> | undefined;
+        /**
+         * The name of the configuration set to use when you send an email using SendRawEmail.
+         */
+        ConfigurationSetName?: string | undefined;
+    }
+
+    interface Options extends MailOptions, TransportOptions {
+        /** is an option that expects an instantiated aws.SES object */
+        SES: any; // aws-sdk.SES object
+        /** How many messages per second is allowed to be delivered to SES */
+        maxConnections?: number | undefined;
+        /** How many parallel connections to allow towards SES */
+        sendingRate?: number | undefined;
+    }
+
+    interface SentMessageInfo {
+        /** an envelope object {from:‘address’, to:[‘address’]} */
+        envelope: MimeNode.Envelope;
+        /** the Message-ID header value. This value is derived from the response of SES API, so it differs from the Message-ID values used in logging. */
+        messageId: string;
+        response: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+    }
+}
+
+declare class SESTransport extends EventEmitter implements Transport<SESTransport.SentMessageInfo> {
+    options: SESTransport.Options;
+
+    logger: shared.Logger;
+    mailer: Mail<SESTransport.SentMessageInfo>;
+
+    name: string;
+    version: string;
+
+    ses: any;
+
+    maxConnections: number;
+    connections: number;
+    sendingRate: number;
+    sendingRateTTL: number | null;
+    rateInterval: number;
+    rateMessages: Array<{ ts: number, pending: boolean }>;
+    pending: Array<{ mail: Mail<SESTransport.SentMessageInfo>; callback(err: Error | null, info: SESTransport.SentMessageInfo): void; }>;
+    idling: boolean;
+
+    constructor(options: SESTransport.Options);
+
+    /** Schedules a sending of a message */
+    send(mail: MailMessage<SESTransport.SentMessageInfo>, callback: (err: Error | null, info: SESTransport.SentMessageInfo) => void): void;
+
+    /** Returns true if there are free slots in the queue */
+    isIdle(): boolean;
+
+    /** Verifies SES configuration */
+    verify(callback: (err: Error | null, success: true) => void): void;
+    verify(): Promise<true>;
+
+    addListener(event: 'idle', listener: () => void): this;
+
+    emit(event: 'idle'): boolean;
+
+    on(event: 'idle', listener: () => void): this;
+
+    once(event: 'idle', listener: () => void): this;
+
+    prependListener(event: 'idle', listener: () => void): this;
+
+    prependOnceListener(event: 'idle', listener: () => void): this;
+
+    listeners(event: 'idle'): Array<() => void>;
+}
+
+export = SESTransport;

package/package/node_modules/@types/nodemailer/lib/shared/index.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+
+import SMTPConnection = require('../smtp-connection');
+
+import * as stream from 'stream';
+
+export type LoggerLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+
+export interface Logger {
+  level(level: LoggerLevel): void;
+  trace(...params: any[]): void;
+  debug(...params: any[]): void;
+  info(...params: any[]): void;
+  warn(...params: any[]): void;
+  error(...params: any[]): void;
+  fatal(...params: any[]): void;
+}
+
+export interface ResolveHostnameOptions {
+  host?: string | undefined;
+  servername?: string | false | undefined;
+}
+
+export interface ResolveHostnameValue {
+  host: string;
+  servername: string | false;
+  _cached?: true | undefined;
+}
+
+export function resolveHostname(options: ResolveHostnameOptions | null | undefined, callback: (err: Error | null, value: ResolveHostnameValue) => void): void;
+
+/** Parses connection url to a structured configuration object */
+export function parseConnectionUrl(url: string): SMTPConnection.Options;
+/** Returns a bunyan-compatible logger interface. Uses either provided logger or creates a default console logger */
+export function getLogger(options?: { [key: string]: any }, defaults?: { [key: string]: any }): Logger;
+/** Wrapper for creating a callback than either resolves or rejects a promise based on input */
+export function callbackPromise(resolve: (...args: any[]) => void, reject: (err: Error) => void): () => void;
+/**
+ * Resolves a String or a Buffer value for content value. Useful if the value
+ * is a Stream or a file or an URL. If the value is a Stream, overwrites
+ * the stream object with the resolved value (you can't stream a value twice).
+ *
+ * This is useful when you want to create a plugin that needs a content value,
+ * for example the `html` or `text` value as a String or a Buffer but not as
+ * a file path or an URL.
+ */
+export function resolveContent(data: object | any[], key: string | number, callback: (err: Error | null, value: Buffer | string) => void): void;
+export function resolveContent(data: object | any[], key: string | number): Promise<Buffer | string>;
+/** Copies properties from source objects to target objects */
+export function assign(target: object, ...sources: object[]): object;
+export function encodeXText(str: string): string;

package/package/node_modules/@types/nodemailer/lib/smtp-connection/data-stream.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+
+import { Transform } from '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
+ */
+declare class DataStream extends Transform {}
+
+export = DataStream;

package/package/node_modules/@types/nodemailer/lib/smtp-connection/http-proxy-client.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+
+import { Socket } from 'net';
+import { TLSSocket } from 'tls';
+
+/**
+ * Establishes proxied connection to destinationPort
+ */
+declare function httpProxyClient(proxyUrl: string, destinationPort: number, destinationHost: string, callback: (err: Error | null, socket: TLSSocket | Socket) => void): void;
+
+export = httpProxyClient;