prostgles-server 4.2.185 → 4.2.187

package/examples/full-example-typescript/node_modules/nodemailer/lib/punycode/index.js

@@ -1,460 +0,0 @@
-/*
-
-Copied from https://github.com/mathiasbynens/punycode.js/blob/ef3505c8abb5143a00d53ce59077c9f7f4b2ac47/punycode.js
-
-Copyright Mathias Bynens <https://mathiasbynens.be/>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-/* eslint callback-return: 0, no-bitwise: 0, eqeqeq: 0, prefer-arrow-callback: 0, object-shorthand: 0 */
-
-'use strict';
-
-/** Highest positive signed 32-bit float value */
-const maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
-
-/** Bootstring parameters */
-const base = 36;
-const tMin = 1;
-const tMax = 26;
-const skew = 38;
-const damp = 700;
-const initialBias = 72;
-const initialN = 128; // 0x80
-const delimiter = '-'; // '\x2D'
-
-/** Regular expressions */
-const regexPunycode = /^xn--/;
-const regexNonASCII = /[^\0-\x7F]/; // Note: U+007F DEL is excluded too.
-const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
-
-/** Error messages */
-const errors = {
-    overflow: 'Overflow: input needs wider integers to process',
-    'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
-    'invalid-input': 'Invalid input'
-};
-
-/** Convenience shortcuts */
-const baseMinusTMin = base - tMin;
-const floor = Math.floor;
-const stringFromCharCode = String.fromCharCode;
-
-/*--------------------------------------------------------------------------*/
-
-/**
- * A generic error utility function.
- * @private
- * @param {String} type The error type.
- * @returns {Error} Throws a `RangeError` with the applicable error message.
- */
-function error(type) {
-    throw new RangeError(errors[type]);
-}
-
-/**
- * A generic `Array#map` utility function.
- * @private
- * @param {Array} array The array to iterate over.
- * @param {Function} callback The function that gets called for every array
- * item.
- * @returns {Array} A new array of values returned by the callback function.
- */
-function map(array, callback) {
-    const result = [];
-    let length = array.length;
-    while (length--) {
-        result[length] = callback(array[length]);
-    }
-    return result;
-}
-
-/**
- * A simple `Array#map`-like wrapper to work with domain name strings or email
- * addresses.
- * @private
- * @param {String} domain The domain name or email address.
- * @param {Function} callback The function that gets called for every
- * character.
- * @returns {String} A new string of characters returned by the callback
- * function.
- */
-function mapDomain(domain, callback) {
-    const parts = domain.split('@');
-    let result = '';
-    if (parts.length > 1) {
-        // In email addresses, only the domain name should be punycoded. Leave
-        // the local part (i.e. everything up to `@`) intact.
-        result = parts[0] + '@';
-        domain = parts[1];
-    }
-    // Avoid `split(regex)` for IE8 compatibility. See #17.
-    domain = domain.replace(regexSeparators, '\x2E');
-    const labels = domain.split('.');
-    const encoded = map(labels, callback).join('.');
-    return result + encoded;
-}
-
-/**
- * Creates an array containing the numeric code points of each Unicode
- * character in the string. While JavaScript uses UCS-2 internally,
- * this function will convert a pair of surrogate halves (each of which
- * UCS-2 exposes as separate characters) into a single code point,
- * matching UTF-16.
- * @see `punycode.ucs2.encode`
- * @see <https://mathiasbynens.be/notes/javascript-encoding>
- * @memberOf punycode.ucs2
- * @name decode
- * @param {String} string The Unicode input string (UCS-2).
- * @returns {Array} The new array of code points.
- */
-function ucs2decode(string) {
-    const output = [];
-    let counter = 0;
-    const length = string.length;
-    while (counter < length) {
-        const value = string.charCodeAt(counter++);
-        if (value >= 0xd800 && value <= 0xdbff && counter < length) {
-            // It's a high surrogate, and there is a next character.
-            const extra = string.charCodeAt(counter++);
-            if ((extra & 0xfc00) == 0xdc00) {
-                // Low surrogate.
-                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
-            } else {
-                // It's an unmatched surrogate; only append this code unit, in case the
-                // next code unit is the high surrogate of a surrogate pair.
-                output.push(value);
-                counter--;
-            }
-        } else {
-            output.push(value);
-        }
-    }
-    return output;
-}
-
-/**
- * Creates a string based on an array of numeric code points.
- * @see `punycode.ucs2.decode`
- * @memberOf punycode.ucs2
- * @name encode
- * @param {Array} codePoints The array of numeric code points.
- * @returns {String} The new Unicode string (UCS-2).
- */
-const ucs2encode = codePoints => String.fromCodePoint(...codePoints);
-
-/**
- * Converts a basic code point into a digit/integer.
- * @see `digitToBasic()`
- * @private
- * @param {Number} codePoint The basic numeric code point value.
- * @returns {Number} The numeric value of a basic code point (for use in
- * representing integers) in the range `0` to `base - 1`, or `base` if
- * the code point does not represent a value.
- */
-const basicToDigit = function (codePoint) {
-    if (codePoint >= 0x30 && codePoint < 0x3a) {
-        return 26 + (codePoint - 0x30);
-    }
-    if (codePoint >= 0x41 && codePoint < 0x5b) {
-        return codePoint - 0x41;
-    }
-    if (codePoint >= 0x61 && codePoint < 0x7b) {
-        return codePoint - 0x61;
-    }
-    return base;
-};
-
-/**
- * Converts a digit/integer into a basic code point.
- * @see `basicToDigit()`
- * @private
- * @param {Number} digit The numeric value of a basic code point.
- * @returns {Number} The basic code point whose value (when used for
- * representing integers) is `digit`, which needs to be in the range
- * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
- * used; else, the lowercase form is used. The behavior is undefined
- * if `flag` is non-zero and `digit` has no uppercase form.
- */
-const digitToBasic = function (digit, flag) {
-    //  0..25 map to ASCII a..z or A..Z
-    // 26..35 map to ASCII 0..9
-    return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
-};
-
-/**
- * Bias adaptation function as per section 3.4 of RFC 3492.
- * https://tools.ietf.org/html/rfc3492#section-3.4
- * @private
- */
-const adapt = function (delta, numPoints, firstTime) {
-    let k = 0;
-    delta = firstTime ? floor(delta / damp) : delta >> 1;
-    delta += floor(delta / numPoints);
-    for (; /* no initialization */ delta > (baseMinusTMin * tMax) >> 1; k += base) {
-        delta = floor(delta / baseMinusTMin);
-    }
-    return floor(k + ((baseMinusTMin + 1) * delta) / (delta + skew));
-};
-
-/**
- * Converts a Punycode string of ASCII-only symbols to a string of Unicode
- * symbols.
- * @memberOf punycode
- * @param {String} input The Punycode string of ASCII-only symbols.
- * @returns {String} The resulting string of Unicode symbols.
- */
-const decode = function (input) {
-    // Don't use UCS-2.
-    const output = [];
-    const inputLength = input.length;
-    let i = 0;
-    let n = initialN;
-    let bias = initialBias;
-
-    // Handle the basic code points: let `basic` be the number of input code
-    // points before the last delimiter, or `0` if there is none, then copy
-    // the first basic code points to the output.
-
-    let basic = input.lastIndexOf(delimiter);
-    if (basic < 0) {
-        basic = 0;
-    }
-
-    for (let j = 0; j < basic; ++j) {
-        // if it's not a basic code point
-        if (input.charCodeAt(j) >= 0x80) {
-            error('not-basic');
-        }
-        output.push(input.charCodeAt(j));
-    }
-
-    // Main decoding loop: start just after the last delimiter if any basic code
-    // points were copied; start at the beginning otherwise.
-
-    for (let index = basic > 0 ? basic + 1 : 0; index < inputLength /* no final expression */; ) {
-        // `index` is the index of the next character to be consumed.
-        // Decode a generalized variable-length integer into `delta`,
-        // which gets added to `i`. The overflow checking is easier
-        // if we increase `i` as we go, then subtract off its starting
-        // value at the end to obtain `delta`.
-        const oldi = i;
-        for (let w = 1, k = base /* no condition */; ; k += base) {
-            if (index >= inputLength) {
-                error('invalid-input');
-            }
-
-            const digit = basicToDigit(input.charCodeAt(index++));
-
-            if (digit >= base) {
-                error('invalid-input');
-            }
-            if (digit > floor((maxInt - i) / w)) {
-                error('overflow');
-            }
-
-            i += digit * w;
-            const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-
-            if (digit < t) {
-                break;
-            }
-
-            const baseMinusT = base - t;
-            if (w > floor(maxInt / baseMinusT)) {
-                error('overflow');
-            }
-
-            w *= baseMinusT;
-        }
-
-        const out = output.length + 1;
-        bias = adapt(i - oldi, out, oldi == 0);
-
-        // `i` was supposed to wrap around from `out` to `0`,
-        // incrementing `n` each time, so we'll fix that now:
-        if (floor(i / out) > maxInt - n) {
-            error('overflow');
-        }
-
-        n += floor(i / out);
-        i %= out;
-
-        // Insert `n` at position `i` of the output.
-        output.splice(i++, 0, n);
-    }
-
-    return String.fromCodePoint(...output);
-};
-
-/**
- * Converts a string of Unicode symbols (e.g. a domain name label) to a
- * Punycode string of ASCII-only symbols.
- * @memberOf punycode
- * @param {String} input The string of Unicode symbols.
- * @returns {String} The resulting Punycode string of ASCII-only symbols.
- */
-const encode = function (input) {
-    const output = [];
-
-    // Convert the input in UCS-2 to an array of Unicode code points.
-    input = ucs2decode(input);
-
-    // Cache the length.
-    const inputLength = input.length;
-
-    // Initialize the state.
-    let n = initialN;
-    let delta = 0;
-    let bias = initialBias;
-
-    // Handle the basic code points.
-    for (const currentValue of input) {
-        if (currentValue < 0x80) {
-            output.push(stringFromCharCode(currentValue));
-        }
-    }
-
-    const basicLength = output.length;
-    let handledCPCount = basicLength;
-
-    // `handledCPCount` is the number of code points that have been handled;
-    // `basicLength` is the number of basic code points.
-
-    // Finish the basic string with a delimiter unless it's empty.
-    if (basicLength) {
-        output.push(delimiter);
-    }
-
-    // Main encoding loop:
-    while (handledCPCount < inputLength) {
-        // All non-basic code points < n have been handled already. Find the next
-        // larger one:
-        let m = maxInt;
-        for (const currentValue of input) {
-            if (currentValue >= n && currentValue < m) {
-                m = currentValue;
-            }
-        }
-
-        // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
-        // but guard against overflow.
-        const handledCPCountPlusOne = handledCPCount + 1;
-        if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
-            error('overflow');
-        }
-
-        delta += (m - n) * handledCPCountPlusOne;
-        n = m;
-
-        for (const currentValue of input) {
-            if (currentValue < n && ++delta > maxInt) {
-                error('overflow');
-            }
-            if (currentValue === n) {
-                // Represent delta as a generalized variable-length integer.
-                let q = delta;
-                for (let k = base /* no condition */; ; k += base) {
-                    const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-                    if (q < t) {
-                        break;
-                    }
-                    const qMinusT = q - t;
-                    const baseMinusT = base - t;
-                    output.push(stringFromCharCode(digitToBasic(t + (qMinusT % baseMinusT), 0)));
-                    q = floor(qMinusT / baseMinusT);
-                }
-
-                output.push(stringFromCharCode(digitToBasic(q, 0)));
-                bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
-                delta = 0;
-                ++handledCPCount;
-            }
-        }
-
-        ++delta;
-        ++n;
-    }
-    return output.join('');
-};
-
-/**
- * Converts a Punycode string representing a domain name or an email address
- * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
- * it doesn't matter if you call it on a string that has already been
- * converted to Unicode.
- * @memberOf punycode
- * @param {String} input The Punycoded domain name or email address to
- * convert to Unicode.
- * @returns {String} The Unicode representation of the given Punycode
- * string.
- */
-const toUnicode = function (input) {
-    return mapDomain(input, function (string) {
-        return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
-    });
-};
-
-/**
- * Converts a Unicode string representing a domain name or an email address to
- * Punycode. Only the non-ASCII parts of the domain name will be converted,
- * i.e. it doesn't matter if you call it with a domain that's already in
- * ASCII.
- * @memberOf punycode
- * @param {String} input The domain name or email address to convert, as a
- * Unicode string.
- * @returns {String} The Punycode representation of the given domain name or
- * email address.
- */
-const toASCII = function (input) {
-    return mapDomain(input, function (string) {
-        return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;
-    });
-};
-
-/*--------------------------------------------------------------------------*/
-
-/** Define the public API */
-const punycode = {
-    /**
-     * A string representing the current Punycode.js version number.
-     * @memberOf punycode
-     * @type String
-     */
-    version: '2.3.1',
-    /**
-     * An object of methods to convert from JavaScript's internal character
-     * representation (UCS-2) to Unicode code points, and back.
-     * @see <https://mathiasbynens.be/notes/javascript-encoding>
-     * @memberOf punycode
-     * @type Object
-     */
-    ucs2: {
-        decode: ucs2decode,
-        encode: ucs2encode
-    },
-    decode: decode,
-    encode: encode,
-    toASCII: toASCII,
-    toUnicode: toUnicode
-};
-
-module.exports = punycode;

package/examples/full-example-typescript/node_modules/nodemailer/lib/qp/index.js

@@ -1,219 +0,0 @@
-'use strict';
-
-const Transform = require('stream').Transform;
-
-/**
- * Encodes a Buffer into a Quoted-Printable encoded string
- *
- * @param {Buffer} buffer Buffer to convert
- * @returns {String} Quoted-Printable encoded string
- */
-function encode(buffer) {
-    if (typeof buffer === 'string') {
-        buffer = Buffer.from(buffer, 'utf-8');
-    }
-
-    // usable characters that do not need encoding
-    let ranges = [
-        // https://tools.ietf.org/html/rfc2045#section-6.7
-        [0x09], // <TAB>
-        [0x0a], // <LF>
-        [0x0d], // <CR>
-        [0x20, 0x3c], // <SP>!"#$%&'()*+,-./0123456789:;
-        [0x3e, 0x7e] // >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
-    ];
-    let result = '';
-    let ord;
-
-    for (let i = 0, len = buffer.length; i < len; i++) {
-        ord = buffer[i];
-        // if the char is in allowed range, then keep as is, unless it is a WS in the end of a line
-        if (checkRanges(ord, ranges) && !((ord === 0x20 || ord === 0x09) && (i === len - 1 || buffer[i + 1] === 0x0a || buffer[i + 1] === 0x0d))) {
-            result += String.fromCharCode(ord);
-            continue;
-        }
-        result += '=' + (ord < 0x10 ? '0' : '') + ord.toString(16).toUpperCase();
-    }
-
-    return result;
-}
-
-/**
- * Adds soft line breaks to a Quoted-Printable string
- *
- * @param {String} str Quoted-Printable encoded string that might need line wrapping
- * @param {Number} [lineLength=76] Maximum allowed length for a line
- * @returns {String} Soft-wrapped Quoted-Printable encoded string
- */
-function wrap(str, lineLength) {
-    str = (str || '').toString();
-    lineLength = lineLength || 76;
-
-    if (str.length <= lineLength) {
-        return str;
-    }
-
-    let pos = 0;
-    let len = str.length;
-    let match, code, line;
-    let lineMargin = Math.floor(lineLength / 3);
-    let result = '';
-
-    // insert soft linebreaks where needed
-    while (pos < len) {
-        line = str.substr(pos, lineLength);
-        if ((match = line.match(/\r\n/))) {
-            line = line.substr(0, match.index + match[0].length);
-            result += line;
-            pos += line.length;
-            continue;
-        }
-
-        if (line.substr(-1) === '\n') {
-            // nothing to change here
-            result += line;
-            pos += line.length;
-            continue;
-        } else if ((match = line.substr(-lineMargin).match(/\n.*?$/))) {
-            // truncate to nearest line break
-            line = line.substr(0, line.length - (match[0].length - 1));
-            result += line;
-            pos += line.length;
-            continue;
-        } else if (line.length > lineLength - lineMargin && (match = line.substr(-lineMargin).match(/[ \t.,!?][^ \t.,!?]*$/))) {
-            // truncate to nearest space
-            line = line.substr(0, line.length - (match[0].length - 1));
-        } else if (line.match(/[=][\da-f]{0,2}$/i)) {
-            // push incomplete encoding sequences to the next line
-            if ((match = line.match(/[=][\da-f]{0,1}$/i))) {
-                line = line.substr(0, line.length - match[0].length);
-            }
-
-            // ensure that utf-8 sequences are not split
-            while (line.length > 3 && line.length < len - pos && !line.match(/^(?:=[\da-f]{2}){1,4}$/i) && (match = line.match(/[=][\da-f]{2}$/gi))) {
-                code = parseInt(match[0].substr(1, 2), 16);
-                if (code < 128) {
-                    break;
-                }
-
-                line = line.substr(0, line.length - 3);
-
-                if (code >= 0xc0) {
-                    break;
-                }
-            }
-        }
-
-        if (pos + line.length < len && line.substr(-1) !== '\n') {
-            if (line.length === lineLength && line.match(/[=][\da-f]{2}$/i)) {
-                line = line.substr(0, line.length - 3);
-            } else if (line.length === lineLength) {
-                line = line.substr(0, line.length - 1);
-            }
-            pos += line.length;
-            line += '=\r\n';
-        } else {
-            pos += line.length;
-        }
-
-        result += line;
-    }
-
-    return result;
-}
-
-/**
- * Helper function to check if a number is inside provided ranges
- *
- * @param {Number} nr Number to check for
- * @param {Array} ranges An Array of allowed values
- * @returns {Boolean} True if the value was found inside allowed ranges, false otherwise
- */
-function checkRanges(nr, ranges) {
-    for (let i = ranges.length - 1; i >= 0; i--) {
-        if (!ranges[i].length) {
-            continue;
-        }
-        if (ranges[i].length === 1 && nr === ranges[i][0]) {
-            return true;
-        }
-        if (ranges[i].length === 2 && nr >= ranges[i][0] && nr <= ranges[i][1]) {
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- * Creates a transform stream for encoding data to Quoted-Printable encoding
- *
- * @constructor
- * @param {Object} options Stream options
- * @param {Number} [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
- */
-class Encoder extends Transform {
-    constructor(options) {
-        super();
-
-        // init Transform
-        this.options = options || {};
-
-        if (this.options.lineLength !== false) {
-            this.options.lineLength = this.options.lineLength || 76;
-        }
-
-        this._curLine = '';
-
-        this.inputBytes = 0;
-        this.outputBytes = 0;
-    }
-
-    _transform(chunk, encoding, done) {
-        let qp;
-
-        if (encoding !== 'buffer') {
-            chunk = Buffer.from(chunk, encoding);
-        }
-
-        if (!chunk || !chunk.length) {
-            return done();
-        }
-
-        this.inputBytes += chunk.length;
-
-        if (this.options.lineLength) {
-            qp = this._curLine + encode(chunk);
-            qp = wrap(qp, this.options.lineLength);
-            qp = qp.replace(/(^|\n)([^\n]*)$/, (match, lineBreak, lastLine) => {
-                this._curLine = lastLine;
-                return lineBreak;
-            });
-
-            if (qp) {
-                this.outputBytes += qp.length;
-                this.push(qp);
-            }
-        } else {
-            qp = encode(chunk);
-            this.outputBytes += qp.length;
-            this.push(qp, 'ascii');
-        }
-
-        done();
-    }
-
-    _flush(done) {
-        if (this._curLine) {
-            this.outputBytes += this._curLine.length;
-            this.push(this._curLine, 'ascii');
-        }
-        done();
-    }
-}
-
-// expose to the world
-module.exports = {
-    encode,
-    wrap,
-    Encoder
-};