@nocobase/plugin-workflow-mailer 2.2.19 → 2.2.21

package/dist/node_modules/nodemailer/dist/esm/punycode/index.js

@@ -0,0 +1,405 @@
+/*
+
+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 */
+/** 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 type The error type.
+ * @returns 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 The array to iterate over.
+ * @param callback The function that gets called for every array
+ * item.
+ * @returns 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 domain The domain name or email address.
+ * @param callback The function that gets called for every
+ * character.
+ * @returns 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 The Unicode input string (UCS-2).
+ * @returns 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 codePoints The array of numeric code points.
+ * @returns 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 codePoint The basic numeric code point value.
+ * @returns 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 digit The numeric value of a basic code point.
+ * @param flag Non-zero to use the uppercase form of the code point.
+ * @returns 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 * Number(digit < 26) - (Number(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 input The Punycode string of ASCII-only symbols.
+ * @returns 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 input The string of Unicode symbols.
+ * @returns 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.
+    const codePoints = ucs2decode(input);
+    // Cache the length.
+    const inputLength = codePoints.length;
+    // Initialize the state.
+    let n = initialN;
+    let delta = 0;
+    let bias = initialBias;
+    // Handle the basic code points.
+    for (const currentValue of codePoints) {
+        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 codePoints) {
+            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 codePoints) {
+            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 input The Punycoded domain name or email address to
+ * convert to Unicode.
+ * @returns 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 input The domain name or email address to convert, as a
+ * Unicode string.
+ * @returns 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 */
+/**
+ * A string representing the current Punycode.js version number.
+ * @memberOf punycode
+ * @type String
+ */
+export const 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
+ */
+export const ucs2 = {
+    decode: ucs2decode,
+    encode: ucs2encode
+};
+export { decode, encode, toASCII, toUnicode };

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

@@ -0,0 +1,32 @@
+import { Transform } from 'node:stream';
+export declare function encode(buffer: Buffer | string): string;
+/**
+ * Adds soft line breaks to a Quoted-Printable string
+ *
+ * @param str Quoted-Printable encoded string that might need line wrapping
+ * @param [lineLength=76] Maximum allowed length for a line
+ * @returns Soft-wrapped Quoted-Printable encoded string
+ */
+export declare function wrap(str: string, lineLength?: number): string;
+/**
+ * Options for the Quoted-Printable encoder stream
+ */
+export interface QPEncoderOptions {
+    /** Maximum length for lines, set to false to disable wrapping */
+    lineLength?: number | false | undefined;
+}
+/** The name @types/nodemailer used for QPEncoderOptions */
+export type EncoderOptions = QPEncoderOptions;
+/**
+ * Creates a transform stream for encoding data to Quoted-Printable encoding
+ *
+ * @constructor
+ * @param options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
+ */
+export declare class Encoder extends Transform {
+    options: QPEncoderOptions;
+    inputBytes: number;
+    outputBytes: number;
+    constructor(options?: QPEncoderOptions);
+}

package/dist/node_modules/nodemailer/{lib → dist/esm}/qp/index.js

@@ -1,13 +1,12 @@
-'use strict';
-
-const { Transform } = require('stream');
-
+import { Transform } from 'node:stream';
 /**
  * Encodes a Buffer into a Quoted-Printable encoded string
  *
- * @param {Buffer} buffer Buffer to convert
- * @returns {String} Quoted-Printable encoded string
+ * @param buffer Buffer to convert
+ * @returns Quoted-Printable encoded string
  */
+// the shortest line wrap() can make progress with: a complete =XX sequence and the soft break
+const MIN_LINE_LENGTH = 4;
 // usable characters that do not need encoding
 // https://tools.ietf.org/html/rfc2045#section-6.7
 const QP_RANGES = [
@@ -17,52 +16,44 @@ const QP_RANGES = [
     [0x20, 0x3c], // <SP>!"#$%&'()*+,-./0123456789:;
     [0x3e, 0x7e] // >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
 ];
-
-function encode(buffer) {
+export function encode(buffer) {
     if (typeof buffer === 'string') {
         buffer = Buffer.from(buffer, 'utf-8');
     }
-
     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, QP_RANGES) &&
-            !((ord === 0x20 || ord === 0x09) && (i === len - 1 || buffer[i + 1] === 0x0a || buffer[i + 1] === 0x0d))
-        ) {
+        if (checkRanges(ord, QP_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
+ * @param str Quoted-Printable encoded string that might need line wrapping
+ * @param [lineLength=76] Maximum allowed length for a line
+ * @returns Soft-wrapped Quoted-Printable encoded string
  */
-function wrap(str, lineLength) {
+export function wrap(str, lineLength) {
     str = (str || '').toString();
-    lineLength = lineLength || 76;
-
+    // a line has to hold a complete =XX sequence plus the soft break, shorter lengths
+    // (or a negative one) would loop without consuming input
+    lineLength = Math.max(Number(lineLength) || 76, MIN_LINE_LENGTH);
     if (str.length <= lineLength) {
         return str;
     }
-
     let pos = 0;
     const len = str.length;
     let match, code, line;
     const lineMargin = Math.floor(lineLength / 3);
     let result = '';
-
     // insert soft linebreaks where needed
     while (pos < len) {
         line = str.substr(pos, lineLength);
@@ -72,13 +63,11 @@ function wrap(str, lineLength) {
             pos += line.length;
             continue;
         }
-
         if (line.substr(-1) === '\n') {
             result += line;
             pos += line.length;
             continue;
         }
-
         if ((match = line.substr(-lineMargin).match(/\n.*?$/))) {
             // truncate to nearest line break
             line = line.substr(0, line.length - (match[0].length - 1));
@@ -86,60 +75,58 @@ function wrap(str, lineLength) {
             pos += line.length;
             continue;
         }
-
         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)) {
+        }
+        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 &&
+            while (line.length > 3 &&
                 line.length < len - pos &&
                 !line.match(/^(?:=[\da-f]{2}){1,4}$/i) &&
-                (match = line.match(/[=][\da-f]{2}$/gi))
-            ) {
+                (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 (!line.length) {
+            // the trimming above emptied the line, which only happens for an incomplete
+            // escape at the very end of the input. Take it as is rather than loop on it
+            line = str.substr(pos, lineLength);
+        }
         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) {
+            }
+            else if (line.length === lineLength) {
                 line = line.substr(0, line.length - 1);
             }
             pos += line.length;
             line += '=\r\n';
-        } else {
+        }
+        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
+ * @param nr Number to check for
+ * @param ranges An Array of allowed values
+ * @returns True if the value was found inside allowed ranges, false otherwise
  */
 function checkRanges(nr, ranges) {
     for (let i = ranges.length - 1; i >= 0; i--) {
@@ -156,43 +143,34 @@ function checkRanges(nr, ranges) {
     }
     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
+ * @param options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
  */
-class Encoder extends Transform {
+export class Encoder extends Transform {
     constructor(options) {
         super();
-
         this.options = options || {};
-
         if (this.options.lineLength !== false) {
             this.options.lineLength = this.options.lineLength || 76;
         }
-
         this._curLine = '';
-
         this.inputBytes = 0;
         this.outputBytes = 0;
     }
-
+    /** @internal */
     _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);
@@ -200,20 +178,19 @@ class Encoder extends Transform {
                 this._curLine = lastLine;
                 return lineBreak;
             });
-
             if (qp) {
                 this.outputBytes += qp.length;
                 this.push(qp);
             }
-        } else {
+        }
+        else {
             qp = encode(chunk);
             this.outputBytes += qp.length;
             this.push(qp, 'ascii');
         }
-
         done();
     }
-
+    /** @internal */
     _flush(done) {
         if (this._curLine) {
             this.outputBytes += this._curLine.length;
@@ -222,9 +199,3 @@ class Encoder extends Transform {
         done();
     }
 }
-
-module.exports = {
-    encode,
-    wrap,
-    Encoder
-};