@nocobase/plugin-workflow-mailer 2.3.0-beta.13 → 2.3.0-beta.15

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

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

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

@@ -0,0 +1,7 @@
+"use strict";
+// Generated by scripts/build.js from package.json. Do not edit by hand.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.homepage = exports.version = exports.name = void 0;
+exports.name = 'nodemailer';
+exports.version = '10.0.14';
+exports.homepage = 'https://nodemailer.com/';

package/dist/node_modules/nodemailer/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/node_modules/nodemailer/dist/cjs/punycode/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+declare function ucs2decode(string: string): number[];
+/**
+ * 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.
+ */
+declare const decode: (input: string) => string;
+/**
+ * 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.
+ */
+declare const encode: (input: string) => string;
+/**
+ * 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.
+ */
+declare const toUnicode: (input: string) => 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.
+ */
+declare const toASCII: (input: string) => string;
+/** Define the public API */
+/**
+ * A string representing the current Punycode.js version number.
+ * @memberOf punycode
+ * @type String
+ */
+export declare 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 declare const ucs2: {
+    decode: typeof ucs2decode;
+    encode: (codePoints: number[]) => string;
+};
+export { decode, encode, toASCII, toUnicode };

package/dist/node_modules/nodemailer/{lib → dist/cjs}/punycode/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
 
 Copied from https://github.com/mathiasbynens/punycode.js/blob/ef3505c8abb5143a00d53ce59077c9f7f4b2ac47/punycode.js
@@ -24,13 +25,11 @@ 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';
-
+/* eslint callback-return: 0, no-bitwise: 0, eqeqeq: 0, prefer-arrow-callback: 0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUnicode = exports.toASCII = exports.encode = exports.decode = exports.ucs2 = exports.version = void 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;
@@ -40,43 +39,37 @@ 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.
+ * @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} array The array to iterate over.
- * @param {Function} callback The function that gets called for every array
+ * @param array The array to iterate over.
+ * @param callback The function that gets called for every array
  * item.
- * @returns {Array} A new array of values returned by the callback function.
+ * @returns A new array of values returned by the callback function.
  */
 function map(array, callback) {
     const result = [];
@@ -86,15 +79,14 @@ function map(array, callback) {
     }
     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
+ * @param domain The domain name or email address.
+ * @param callback The function that gets called for every
  * character.
- * @returns {String} A new string of characters returned by the callback
+ * @returns A new string of characters returned by the callback
  * function.
  */
 function mapDomain(domain, callback) {
@@ -112,7 +104,6 @@ function mapDomain(domain, callback) {
     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,
@@ -123,8 +114,8 @@ function mapDomain(domain, callback) {
  * @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.
+ * @param string The Unicode input string (UCS-2).
+ * @returns The new array of code points.
  */
 function ucs2decode(string) {
     const output = [];
@@ -138,35 +129,35 @@ function ucs2decode(string) {
             if ((extra & 0xfc00) == 0xdc00) {
                 // Low surrogate.
                 output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
-            } else {
+            }
+            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 {
+        }
+        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).
+ * @param codePoints The array of numeric code points.
+ * @returns The new Unicode string (UCS-2).
  */
-const ucs2encode = codePoints => String.fromCodePoint(...codePoints);
-
+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
+ * @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.
  */
@@ -182,13 +173,13 @@ const basicToDigit = function (codePoint) {
     }
     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
+ * @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
@@ -197,9 +188,8 @@ const basicToDigit = function (codePoint) {
 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);
+    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
@@ -214,13 +204,12 @@ const adapt = function (delta, numPoints, firstTime) {
     }
     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.
+ * @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.
@@ -229,16 +218,13 @@ const decode = function (input) {
     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) {
@@ -246,10 +232,8 @@ const decode = function (input) {
         }
         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`,
@@ -257,122 +241,100 @@ const decode = function (input) {
         // 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) {
+        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);
 };
-
+exports.decode = decode;
 /**
  * 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.
+ * @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.
-    input = ucs2decode(input);
-
+    const codePoints = ucs2decode(input);
     // Cache the length.
-    const inputLength = input.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 input) {
+    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 input) {
+        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 input) {
+        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) {
+                for (let k = base /* no condition */;; k += base) {
                     const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
                     if (q < t) {
                         break;
@@ -382,29 +344,27 @@ const encode = function (input) {
                     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('');
 };
-
+exports.encode = encode;
 /**
  * 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
+ * @param input The Punycoded domain name or email address to
  * convert to Unicode.
- * @returns {String} The Unicode representation of the given Punycode
+ * @returns The Unicode representation of the given Punycode
  * string.
  */
 const toUnicode = function (input) {
@@ -412,16 +372,16 @@ const toUnicode = function (input) {
         return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
     });
 };
-
+exports.toUnicode = toUnicode;
 /**
  * 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
+ * @param input The domain name or email address to convert, as a
  * Unicode string.
- * @returns {String} The Punycode representation of the given domain name or
+ * @returns The Punycode representation of the given domain name or
  * email address.
  */
 const toASCII = function (input) {
@@ -429,32 +389,23 @@ const toASCII = function (input) {
         return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;
     });
 };
-
+exports.toASCII = toASCII;
 /*--------------------------------------------------------------------------*/
-
 /** 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
+/**
+ * A string representing the current Punycode.js version number.
+ * @memberOf punycode
+ * @type String
+ */
+exports.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
+ */
+exports.ucs2 = {
+    decode: ucs2decode,
+    encode: ucs2encode
 };
-
-module.exports = punycode;

package/dist/node_modules/nodemailer/dist/cjs/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);
+}