@dereekb/nestjs 13.2.2 → 13.3.1

package/mailgun/index.esm.js

@@ -5,94 +5,208 @@ import Mailgun from 'mailgun.js';
 import FormData from 'form-data';
 import { ConfigService, ConfigModule } from '@nestjs/config';
 
-const DEFAULT_RECIPIENT_VARIABLE_PREFIX = 'recipient-';
-const MAILGUN_REPLY_TO_EMAIL_HEADER_DATA_VARIABLE_KEY = `h:Reply-To`;
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest();
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+var DEFAULT_RECIPIENT_VARIABLE_PREFIX = 'recipient-';
+var MAILGUN_REPLY_TO_EMAIL_HEADER_DATA_VARIABLE_KEY = "h:Reply-To";
 /**
  * The maximum number of recipients allowed in a single batch send request.
- */
-const MAX_BATCH_SEND_RECIPIENTS = 1000;
+ */ var MAX_BATCH_SEND_RECIPIENTS = 1000;
 /**
  * Converts a MailgunTemplateEmailRequest to a MailgunMessageData.
  *
  * @param config
  * @returns
- */
-function convertMailgunTemplateEmailRequestToMailgunMessageData(config) {
-    const { request, defaultSender, isTestingEnvironment: testEnvironment, recipientVariablePrefix: inputRecipientVariablePrefix = DEFAULT_RECIPIENT_VARIABLE_PREFIX, addRecipientVariablePrefixToAllMergedGlobalVariables: inputAddRecipientVariablePrefixToAllMergedGlobalVariables = true, addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables: inputAddCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables = false, addCopyOfTemplateVariablesWithRecipientVariablePrefix: inputAddCopyOfTemplateVariablesWithRecipientVariablePrefix = false } = config;
-    const { recipientVariablesConfig } = request;
-    const recipientVariablePrefix = recipientVariablesConfig?.recipientVariablePrefix ?? inputRecipientVariablePrefix;
-    const addRecipientVariablePrefixToAllMergedGlobalVariables = recipientVariablesConfig?.addRecipientVariablePrefixToAllMergedGlobalVariables ?? inputAddRecipientVariablePrefixToAllMergedGlobalVariables;
-    const addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables = recipientVariablesConfig?.addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables ?? inputAddCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables;
-    const addCopyOfTemplateVariablesWithRecipientVariablePrefix = recipientVariablesConfig?.addCopyOfTemplateVariablesWithRecipientVariablePrefix ?? inputAddCopyOfTemplateVariablesWithRecipientVariablePrefix;
-    const finalizeRecipientVariables = request.finalizeRecipientVariables ?? MAP_IDENTITY;
-    const allowBatchSending = request.batchSend ?? true;
-    const mergeRecipientVariablesIntoGlobalVariable = !allowBatchSending;
+ */ function convertMailgunTemplateEmailRequestToMailgunMessageData(config) {
+    var _ref, _ref1, _ref2, _ref3, _request_finalizeRecipientVariables, _request_batchSend;
+    var request = config.request, defaultSender = config.defaultSender, testEnvironment = config.isTestingEnvironment, tmp = config.recipientVariablePrefix, inputRecipientVariablePrefix = tmp === void 0 ? DEFAULT_RECIPIENT_VARIABLE_PREFIX : tmp, tmp1 = config.addRecipientVariablePrefixToAllMergedGlobalVariables, inputAddRecipientVariablePrefixToAllMergedGlobalVariables = tmp1 === void 0 ? true : tmp1, tmp2 = config.addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables, inputAddCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables = tmp2 === void 0 ? false : tmp2, tmp3 = config.addCopyOfTemplateVariablesWithRecipientVariablePrefix, inputAddCopyOfTemplateVariablesWithRecipientVariablePrefix = tmp3 === void 0 ? false : tmp3;
+    var recipientVariablesConfig = request.recipientVariablesConfig;
+    var recipientVariablePrefix = (_ref = recipientVariablesConfig === null || recipientVariablesConfig === void 0 ? void 0 : recipientVariablesConfig.recipientVariablePrefix) !== null && _ref !== void 0 ? _ref : inputRecipientVariablePrefix;
+    var addRecipientVariablePrefixToAllMergedGlobalVariables = (_ref1 = recipientVariablesConfig === null || recipientVariablesConfig === void 0 ? void 0 : recipientVariablesConfig.addRecipientVariablePrefixToAllMergedGlobalVariables) !== null && _ref1 !== void 0 ? _ref1 : inputAddRecipientVariablePrefixToAllMergedGlobalVariables;
+    var addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables = (_ref2 = recipientVariablesConfig === null || recipientVariablesConfig === void 0 ? void 0 : recipientVariablesConfig.addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables) !== null && _ref2 !== void 0 ? _ref2 : inputAddCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables;
+    var addCopyOfTemplateVariablesWithRecipientVariablePrefix = (_ref3 = recipientVariablesConfig === null || recipientVariablesConfig === void 0 ? void 0 : recipientVariablesConfig.addCopyOfTemplateVariablesWithRecipientVariablePrefix) !== null && _ref3 !== void 0 ? _ref3 : inputAddCopyOfTemplateVariablesWithRecipientVariablePrefix;
+    var finalizeRecipientVariables = (_request_finalizeRecipientVariables = request.finalizeRecipientVariables) !== null && _request_finalizeRecipientVariables !== void 0 ? _request_finalizeRecipientVariables : MAP_IDENTITY;
+    var allowBatchSending = (_request_batchSend = request.batchSend) !== null && _request_batchSend !== void 0 ? _request_batchSend : true;
+    var mergeRecipientVariablesIntoGlobalVariable = !allowBatchSending;
     function mapEmailToLowercase(x) {
-        return { ...x, email: x.email.toLowerCase() };
-    }
-    const toInput = asArray(request.to).map(mapEmailToLowercase);
-    const ccInput = request.cc ? asArray(request.cc).map(mapEmailToLowercase) : undefined;
-    const bccInput = request.bcc ? asArray(request.bcc).map(mapEmailToLowercase) : undefined;
-    const from = request.from ? convertMailgunRecipientToString(request.from) : defaultSender;
-    const to = convertMailgunRecipientsToStrings(toInput);
-    const cc = ccInput?.length ? convertMailgunRecipientsToStrings(ccInput) : undefined;
-    const bcc = bccInput?.length ? convertMailgunRecipientsToStrings(bccInput) : undefined;
+        return _object_spread_props$1(_object_spread$2({}, x), {
+            email: x.email.toLowerCase()
+        });
+    }
+    var toInput = asArray(request.to).map(mapEmailToLowercase);
+    var ccInput = request.cc ? asArray(request.cc).map(mapEmailToLowercase) : undefined;
+    var bccInput = request.bcc ? asArray(request.bcc).map(mapEmailToLowercase) : undefined;
+    var from = request.from ? convertMailgunRecipientToString(request.from) : defaultSender;
+    var to = convertMailgunRecipientsToStrings(toInput);
+    var cc = (ccInput === null || ccInput === void 0 ? void 0 : ccInput.length) ? convertMailgunRecipientsToStrings(ccInput) : undefined;
+    var bcc = (bccInput === null || bccInput === void 0 ? void 0 : bccInput.length) ? convertMailgunRecipientsToStrings(bccInput) : undefined;
     // throw an error if batchSend is not defined and cc or bcc is defined
     if (request.batchSend == null && (ccInput || bccInput)) {
         throw new Error('convertMailgunTemplateEmailRequestToMailgunMessageData(): batchSend must be false when either "cc" or "bcc" is defined.');
     }
     if (allowBatchSending && to.length > MAX_BATCH_SEND_RECIPIENTS) {
-        throw new Error(`convertMailgunTemplateEmailRequestToMailgunMessageData(): Can only batch send to a maximum of ${MAX_BATCH_SEND_RECIPIENTS} recipients.`);
+        throw new Error("convertMailgunTemplateEmailRequestToMailgunMessageData(): Can only batch send to a maximum of ".concat(MAX_BATCH_SEND_RECIPIENTS, " recipients."));
     }
-    const data = {
-        from,
-        to,
-        cc,
-        bcc,
+    var data = _object_spread$2({
+        from: from,
+        to: to,
+        cc: cc,
+        bcc: bcc,
         subject: request.subject,
-        template: request.template,
-        ...request.messageData
-    };
+        template: request.template
+    }, request.messageData);
     if (request.replyTo != null) {
         data[MAILGUN_REPLY_TO_EMAIL_HEADER_DATA_VARIABLE_KEY] = convertMailgunRecipientToString(request.replyTo);
     }
-    if (request.testEmail === true || ((testEnvironment ?? isTestNodeEnv()) && request.testEmail !== false)) {
+    if (request.testEmail === true || (testEnvironment !== null && testEnvironment !== void 0 ? testEnvironment : isTestNodeEnv()) && request.testEmail !== false) {
         data['o:testmode'] = true;
     }
     if (request.templateVariables) {
         forEachKeyValue(request.templateVariables, {
-            forEach: (x) => {
-                const [key, value] = x;
-                const encodedValue = encodeMailgunTemplateVariableValue(value);
+            forEach: function forEach(x) {
+                var _x = _sliced_to_array(x, 2), key = _x[0], value = _x[1];
+                var encodedValue = encodeMailgunTemplateVariableValue(value);
                 if (encodedValue != null) {
-                    data[`v:${key}`] = encodedValue;
+                    data["v:".concat(key)] = encodedValue;
                     if (recipientVariablePrefix && addCopyOfTemplateVariablesWithRecipientVariablePrefix) {
-                        data[`v:${recipientVariablePrefix}${key}`] = encodedValue;
+                        data["v:".concat(recipientVariablePrefix).concat(key)] = encodedValue;
                     }
                 }
             }
         });
     }
-    const hasUserVariables = Boolean(data['recipient-variables']) || toInput.findIndex((x) => x.userVariables != null) !== -1;
+    var hasUserVariables = Boolean(data['recipient-variables']) || toInput.findIndex(function(x) {
+        return x.userVariables != null;
+    }) !== -1;
     if (hasUserVariables) {
-        let recipientVariables = {};
-        const allRecipientVariableKeys = new Set();
-        toInput.forEach(({ email, userVariables }) => {
+        var _finalizeRecipientVariables;
+        var recipientVariables = {};
+        var allRecipientVariableKeys = new Set();
+        toInput.forEach(function(param) {
+            var email = param.email, userVariables = param.userVariables;
             if (userVariables != null && !objectIsEmpty(userVariables)) {
                 recipientVariables[email] = userVariables;
                 addToSet(allRecipientVariableKeys, Object.keys(userVariables));
             }
         });
         if (data['recipient-variables']) {
-            const decoded = JSON.parse(data['recipient-variables']);
+            var decoded = JSON.parse(data['recipient-variables']);
             forEachKeyValue(decoded, {
-                forEach: (x) => {
-                    const [recipientEmail, userVariables] = x;
-                    const email = recipientEmail.toLowerCase();
+                forEach: function forEach(x) {
+                    var _x = _sliced_to_array(x, 2), recipientEmail = _x[0], userVariables = _x[1];
+                    var email = recipientEmail.toLowerCase();
                     if (recipientVariables[email] != null) {
-                        overrideInObject(recipientVariables[email], { from: [userVariables], filter: { valueFilter: KeyValueTypleValueFilter.UNDEFINED } });
-                    }
-                    else {
+                        overrideInObject(recipientVariables[email], {
+                            from: [
+                                userVariables
+                            ],
+                            filter: {
+                                valueFilter: KeyValueTypleValueFilter.UNDEFINED
+                            }
+                        });
+                    } else {
                         recipientVariables[email] = userVariables;
                     }
                     addToSet(allRecipientVariableKeys, Object.keys(userVariables));
@@ -100,47 +214,45 @@ function convertMailgunTemplateEmailRequestToMailgunMessageData(config) {
             });
         }
         // Finalize the recipient variables before they are re-encoded back to JSON
-        recipientVariables =
-            finalizeRecipientVariables(recipientVariables, {
-                messageData: data,
-                config
-            }) ?? recipientVariables;
+        recipientVariables = (_finalizeRecipientVariables = finalizeRecipientVariables(recipientVariables, {
+            messageData: data,
+            config: config
+        })) !== null && _finalizeRecipientVariables !== void 0 ? _finalizeRecipientVariables : recipientVariables;
         if (mergeRecipientVariablesIntoGlobalVariable) {
-            const addRecipientPrefixVariable = recipientVariablePrefix && addRecipientVariablePrefixToAllMergedGlobalVariables;
+            var addRecipientPrefixVariable = recipientVariablePrefix && addRecipientVariablePrefixToAllMergedGlobalVariables;
             // iterate all recipient variables and merge them into the global variables
             forEachKeyValue(recipientVariables, {
-                forEach: (x) => {
-                    const [email, userVariables] = x;
+                forEach: function forEach(x) {
+                    var _x = _sliced_to_array(x, 2); _x[0]; var userVariables = _x[1];
                     forEachKeyValue(userVariables, {
-                        forEach: (y) => {
-                            const [key, value] = y;
-                            const encodedValue = encodeMailgunTemplateVariableValue(value);
+                        forEach: function forEach(y) {
+                            var _y = _sliced_to_array(y, 2), key = _y[0], value = _y[1];
+                            var encodedValue = encodeMailgunTemplateVariableValue(value);
                             if (encodedValue != null) {
                                 if (addRecipientPrefixVariable) {
                                     // also add the variable using the recipient variable prefix
-                                    const recipientVariableKey = `${recipientVariablePrefix}${key}`;
-                                    data[`v:${recipientVariableKey}`] = encodedValue;
+                                    var recipientVariableKey = "".concat(recipientVariablePrefix).concat(key);
+                                    data["v:".concat(recipientVariableKey)] = encodedValue;
                                 }
                                 // add if not adding the prefix variable, or if it was requested
                                 if (!addRecipientPrefixVariable || addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables) {
-                                    data[`v:${key}`] = encodedValue;
+                                    data["v:".concat(key)] = encodedValue;
                                 }
                             }
                         }
                     });
                 }
             });
-        }
-        else {
+        } else {
             // set back on the data object
             data['recipient-variables'] = JSON.stringify(recipientVariables);
             // add all recipient variable to the other variables so they can be used easily/directly in templates as variables too.
             // https://documentation.mailgun.com/en/latest/user_manual.html#attaching-data-to-messages
             if (recipientVariablePrefix) {
-                forEachInIterable(allRecipientVariableKeys, (key) => {
-                    const recipientVariableKey = `${recipientVariablePrefix}${key}`;
+                forEachInIterable(allRecipientVariableKeys, function(key) {
+                    var recipientVariableKey = "".concat(recipientVariablePrefix).concat(key);
                     // v:recipient-id=%recipient.id%
-                    data[`v:${recipientVariableKey}`] = `%recipient.${key}%`;
+                    data["v:".concat(recipientVariableKey)] = "%recipient.".concat(key, "%");
                 });
             }
         }
@@ -149,22 +261,24 @@ function convertMailgunTemplateEmailRequestToMailgunMessageData(config) {
     if (mergeRecipientVariablesIntoGlobalVariable) {
         delete data['recipient-variables'];
     }
-    const inputAttachments = request.attachments;
+    var inputAttachments = request.attachments;
     if (inputAttachments) {
         if (data.attachment) {
-            throw new Error(`Cannot specify attachments in both messageData and in the request's attachments field.`);
+            throw new Error("Cannot specify attachments in both messageData and in the request's attachments field.");
         }
         data.attachment = inputAttachments;
     }
     return data;
 }
 function convertMailgunRecipientsToStrings(recipients) {
-    return recipients.map((x) => convertMailgunRecipientToString(x));
+    return recipients.map(function(x) {
+        return convertMailgunRecipientToString(x);
+    });
 }
 function convertMailgunRecipientToString(recipient) {
-    let address = recipient.email;
+    var address = recipient.email;
     if (recipient.name) {
-        address = `${recipient.name} <${address}>`;
+        address = "".concat(recipient.name, " <").concat(address, ">");
     }
     return address;
 }
@@ -173,16 +287,14 @@ function convertMailgunRecipientToString(recipient) {
  *
  * @param value The value to encode.
  * @returns The encoded value, or undefined if the value is null or undefined.
- */
-function encodeMailgunTemplateVariableValue(value) {
-    let encodedValue;
-    switch (typeof value) {
+ */ function encodeMailgunTemplateVariableValue(value) {
+    var encodedValue;
+    switch(typeof value === "undefined" ? "undefined" : _type_of$1(value)){
         case 'object':
             if (value) {
-                if (value instanceof Date) {
+                if (_instanceof(value, Date)) {
                     encodedValue = value.toISOString();
-                }
-                else {
+                } else {
                     encodedValue = JSON.stringify(value);
                 }
             }
@@ -195,252 +307,624 @@ function encodeMailgunTemplateVariableValue(value) {
             break;
         default:
             if (value) {
-                throw new Error(`Invalid value "${value}" passed to encodeMailgunTemplateVariableValue().`);
+                throw new Error('Invalid value "'.concat(value, '" passed to encodeMailgunTemplateVariableValue().'));
             }
     }
     return encodedValue;
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ((typeof Reflect === "undefined" ? "undefined" : _type_of(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-class MailgunServiceConfig {
-    // Mailgun Config
-    mailgun;
-    /**
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$2(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var MailgunServiceConfig = /*#__PURE__*/ function() {
+    function MailgunServiceConfig() {
+        _class_call_check$3(this, MailgunServiceConfig);
+        // Mailgun Config
+        _define_property$3(this, "mailgun", void 0);
+        /**
      * Base URL to the client.
-     */
-    clientUrl;
-    /**
+     */ _define_property$3(this, "clientUrl", void 0);
+        /**
      * Main domain to send emails from.
-     */
-    domain;
-    /**
+     */ _define_property$3(this, "domain", void 0);
+        /**
      * Mailgun sender string.
-     */
-    sender;
-    /**
+     */ _define_property$3(this, "sender", void 0);
+        /**
      * Additional messages config
-     */
-    messages;
-    static assertValidConfig(config) {
-        if (!config.mailgun.username) {
-            throw new Error('No mailgun username specified.');
-        }
-        else if (!config.mailgun.key) {
-            throw new Error('No mailgun key specified.');
-        }
-        else if (!config.domain) {
-            throw new Error('No mailgun domain specified.');
-        }
-        else if (!config.clientUrl) {
-            throw new Error('No client url specified.');
-        }
-        else if (!config.sender) {
-            throw new Error('No mailgun sender specified.');
-        }
-        else if (!config.messages) {
-            throw new Error('No mailgun messages config specified.');
-        }
+     */ _define_property$3(this, "messages", void 0);
     }
-}
+    _create_class$2(MailgunServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.mailgun.username) {
+                    throw new Error('No mailgun username specified.');
+                } else if (!config.mailgun.key) {
+                    throw new Error('No mailgun key specified.');
+                } else if (!config.domain) {
+                    throw new Error('No mailgun domain specified.');
+                } else if (!config.clientUrl) {
+                    throw new Error('No client url specified.');
+                } else if (!config.sender) {
+                    throw new Error('No mailgun sender specified.');
+                } else if (!config.messages) {
+                    throw new Error('No mailgun messages config specified.');
+                }
+            }
+        }
+    ]);
+    return MailgunServiceConfig;
+} 
+();
 
-let MailgunApi = class MailgunApi {
-    config;
-    client;
-    constructor(config) {
-        this.config = config;
-        this.client = new Mailgun(FormData).client({
-            ...config.mailgun
-        });
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    get messages() {
-        return this.client.messages;
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    get clientUrl() {
-        return this.config.clientUrl;
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-    get domain() {
-        return this.config.domain;
+    return obj;
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$2(target, key, source[key]);
+        });
     }
-    get sender() {
-        return this.config.sender;
+    return target;
+}
+var MailgunApi = /*#__PURE__*/ function() {
+    function MailgunApi(config) {
+        _class_call_check$2(this, MailgunApi);
+        _define_property$2(this, "config", void 0);
+        _define_property$2(this, "client", void 0);
+        this.config = config;
+        this.client = new Mailgun(FormData).client(_object_spread$1({}, config.mailgun));
     }
-};
+    _create_class$1(MailgunApi, [
+        {
+            key: "messages",
+            get: function get() {
+                return this.client.messages;
+            }
+        },
+        {
+            key: "clientUrl",
+            get: function get() {
+                return this.config.clientUrl;
+            }
+        },
+        {
+            key: "domain",
+            get: function get() {
+                return this.config.domain;
+            }
+        },
+        {
+            key: "sender",
+            get: function get() {
+                return this.config.sender;
+            }
+        }
+    ]);
+    return MailgunApi;
+}();
 MailgunApi = __decorate([
     Injectable(),
     __param(0, Inject(MailgunServiceConfig))
 ], MailgunApi);
 
-let MailgunService = class MailgunService {
-    _mailgunApi;
-    _serverEnvironmentService;
-    constructor(mailgunApi, serverEnvironmentService) {
-        this._mailgunApi = mailgunApi;
-        this._serverEnvironmentService = serverEnvironmentService;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
     }
-    get mailgunApi() {
-        return this._mailgunApi;
-    }
-    get serverEnvironmentService() {
-        return this._serverEnvironmentService;
-    }
-    async sendTemplateEmail(request) {
-        const domain = this.mailgunApi.domain;
-        const sender = this.mailgunApi.sender;
-        const isTestingEnvironment = this.serverEnvironmentService.isTestingEnv;
-        const { recipientVariablePrefix } = this.mailgunApi.config.messages;
-        const data = convertMailgunTemplateEmailRequestToMailgunMessageData({ request, defaultSender: sender, recipientVariablePrefix, isTestingEnvironment });
-        let result;
-        const shouldSend = !isTestingEnvironment || request.sendTestEmails || this.mailgunApi.config.messages.sendTestEmails;
-        if (shouldSend) {
-            try {
-                result = await this.mailgunApi.messages.create(domain, data);
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
             }
-            catch (e) {
-                console.error('Failed sending email: ', e);
-                throw e;
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
             }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
         }
-        else {
-            result = {
-                status: 200,
-                message: 'Success. Env prevented sending email.'
-            };
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
         }
-        return result;
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
     }
-};
+}
+var MailgunService = /*#__PURE__*/ function() {
+    function MailgunService(mailgunApi, serverEnvironmentService) {
+        _class_call_check$1(this, MailgunService);
+        _define_property$1(this, "_mailgunApi", void 0);
+        _define_property$1(this, "_serverEnvironmentService", void 0);
+        this._mailgunApi = mailgunApi;
+        this._serverEnvironmentService = serverEnvironmentService;
+    }
+    _create_class(MailgunService, [
+        {
+            key: "mailgunApi",
+            get: function get() {
+                return this._mailgunApi;
+            }
+        },
+        {
+            key: "serverEnvironmentService",
+            get: function get() {
+                return this._serverEnvironmentService;
+            }
+        },
+        {
+            key: "sendTemplateEmail",
+            value: function sendTemplateEmail(request) {
+                return _async_to_generator(function() {
+                    var domain, sender, isTestingEnvironment, recipientVariablePrefix, data, result, shouldSend, e;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                domain = this.mailgunApi.domain;
+                                sender = this.mailgunApi.sender;
+                                isTestingEnvironment = this.serverEnvironmentService.isTestingEnv;
+                                recipientVariablePrefix = this.mailgunApi.config.messages.recipientVariablePrefix;
+                                data = convertMailgunTemplateEmailRequestToMailgunMessageData({
+                                    request: request,
+                                    defaultSender: sender,
+                                    recipientVariablePrefix: recipientVariablePrefix,
+                                    isTestingEnvironment: isTestingEnvironment
+                                });
+                                shouldSend = !isTestingEnvironment || request.sendTestEmails || this.mailgunApi.config.messages.sendTestEmails;
+                                if (!shouldSend) return [
+                                    3,
+                                    5
+                                ];
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    this.mailgunApi.messages.create(domain, data)
+                                ];
+                            case 2:
+                                result = _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                e = _state.sent();
+                                console.error('Failed sending email: ', e);
+                                throw e;
+                            case 4:
+                                return [
+                                    3,
+                                    6
+                                ];
+                            case 5:
+                                result = {
+                                    status: 200,
+                                    message: 'Success. Env prevented sending email.'
+                                };
+                                _state.label = 6;
+                            case 6:
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return MailgunService;
+}();
 MailgunService = __decorate([
     Injectable(),
     __param(0, Inject(MailgunApi)),
     __param(1, Inject(ServerEnvironmentService))
 ], MailgunService);
 
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
 function mailgunServiceConfigFactory(configService, serverEnvironmentService) {
-    const isTestingEnv = serverEnvironmentService.isTestingEnv;
-    const useSandbox = configService.get('USE_MAILGUN_SANDBOX') === 'true' || isTestingEnv;
-    const sendTestEmails = configService.get('MAILGUN_SEND_TEST_EMAILS') === 'true';
-    let key = configService.get('MAILGUN_API_KEY');
-    let domain = configService.get('MAILGUN_DOMAIN');
+    var _configService_get, _configService_get1, _configService_get2;
+    var isTestingEnv = serverEnvironmentService.isTestingEnv;
+    var useSandbox = configService.get('USE_MAILGUN_SANDBOX') === 'true' || isTestingEnv;
+    var sendTestEmails = configService.get('MAILGUN_SEND_TEST_EMAILS') === 'true';
+    var key = configService.get('MAILGUN_API_KEY');
+    var domain = configService.get('MAILGUN_DOMAIN');
     if (useSandbox) {
         key = configService.get('MAILGUN_SANDBOX_API_KEY');
         domain = configService.get('MAILGUN_SANDBOX_DOMAIN');
         if (!key || !domain) {
             throw new Error('USE_MAILGUN_SANDBOX is set to "true" (or current environment is a testing environment), but no environment variables for the sandbox (MAILGUN_SANDBOX_API_KEY, MAILGUN_SANDBOX_DOMAIN) are provided.');
-        }
-        else if (!serverEnvironmentService.isTestingEnv) {
+        } else if (!serverEnvironmentService.isTestingEnv) {
             console.log('Using Mailgun Sandbox Domain: ', domain);
         }
-    }
-    else if (!serverEnvironmentService.isTestingEnv) {
+    } else if (!serverEnvironmentService.isTestingEnv) {
         console.log('Using Mailgun Production Domain: ', domain);
     }
-    const name = configService.get('MAILGUN_SENDER_NAME');
-    const email = configService.get('MAILGUN_SENDER_EMAIL');
-    const url = configService.get('MAILGUN_API_URL');
-    const recipientVariablePrefix = configService.get('MAILGUN_MESSAGES_RECIPIENT_VARIABLE_PREFIX') ?? undefined;
+    var name = configService.get('MAILGUN_SENDER_NAME');
+    var email = configService.get('MAILGUN_SENDER_EMAIL');
+    var url = configService.get('MAILGUN_API_URL');
+    var recipientVariablePrefix = (_configService_get = configService.get('MAILGUN_MESSAGES_RECIPIENT_VARIABLE_PREFIX')) !== null && _configService_get !== void 0 ? _configService_get : undefined;
     if (!email) {
         throw new Error('MAILGUN_SENDER_EMAIL is required but was not configured.');
-    }
-    else if (!key) {
+    } else if (!key) {
         throw new Error('MAILGUN_API_KEY (or MAILGUN_SANDBOX_API_KEY for tests) is required but was not configured.');
-    }
-    else if (!domain) {
+    } else if (!domain) {
         throw new Error('MAILGUN_DOMAIN (or MAILGUN_SANDBOX_DOMAIN for tests) is required but was not configured.');
     }
-    const clientUrl = configService.get('CLIENT_APP_URL') ?? domain;
-    const config = {
+    var clientUrl = (_configService_get1 = configService.get('CLIENT_APP_URL')) !== null && _configService_get1 !== void 0 ? _configService_get1 : domain;
+    var config = {
         mailgun: {
-            username: configService.get('MAILGUN_USERNAME') ?? 'api',
-            key,
-            url
+            username: (_configService_get2 = configService.get('MAILGUN_USERNAME')) !== null && _configService_get2 !== void 0 ? _configService_get2 : 'api',
+            key: key,
+            url: url
         },
-        domain,
-        clientUrl,
+        domain: domain,
+        clientUrl: clientUrl,
         sender: convertMailgunRecipientToString({
-            name,
-            email
+            name: name,
+            email: email
         }),
         messages: {
-            sendTestEmails,
-            recipientVariablePrefix
+            sendTestEmails: sendTestEmails,
+            recipientVariablePrefix: recipientVariablePrefix
         }
     };
     MailgunServiceConfig.assertValidConfig(config);
     return config;
 }
-let MailgunServiceModule = class MailgunServiceModule {
+var MailgunServiceModule = function MailgunServiceModule() {
+    _class_call_check(this, MailgunServiceModule);
 };
 MailgunServiceModule = __decorate([
     Module({
-        imports: [ConfigModule],
+        imports: [
+            ConfigModule
+        ],
         providers: [
             {
                 provide: MailgunServiceConfig,
-                inject: [ConfigService, ServerEnvironmentService],
+                inject: [
+                    ConfigService,
+                    ServerEnvironmentService
+                ],
                 useFactory: mailgunServiceConfigFactory
             },
             MailgunApi,
             MailgunService
         ],
-        exports: [MailgunApi, MailgunService]
+        exports: [
+            MailgunApi,
+            MailgunService
+        ]
     })
 ], MailgunServiceModule);
 
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 /**
  * The default template subject to use when batch sending emails.
  *
  * This pulls the subject from each recipient's user variables.
- */
-const MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE = `%recipient.subject%`;
+ */ var MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE = "%recipient.subject%";
 /**
  * Creates a composite key from the from/replyTo email addresses used to group MailgunRecipientBatchSendTarget values.
- */
-function mailgunRecipientBatchSendTargetFromReplyToBatchGroupKey(recipient) {
-    const fromEmail = (recipient.from?.email ?? '').toLowerCase();
-    const replyToEmail = (recipient.replyTo?.email ?? '').toLowerCase();
-    return `f:${fromEmail}|r:${replyToEmail}`;
+ */ function mailgunRecipientBatchSendTargetFromReplyToBatchGroupKey(recipient) {
+    var _ref, _ref1;
+    var _recipient_from, _recipient_replyTo;
+    var fromEmail = ((_ref = (_recipient_from = recipient.from) === null || _recipient_from === void 0 ? void 0 : _recipient_from.email) !== null && _ref !== void 0 ? _ref : '').toLowerCase();
+    var replyToEmail = ((_ref1 = (_recipient_replyTo = recipient.replyTo) === null || _recipient_replyTo === void 0 ? void 0 : _recipient_replyTo.email) !== null && _ref1 !== void 0 ? _ref1 : '').toLowerCase();
+    return "f:".concat(fromEmail, "|r:").concat(replyToEmail);
 }
 /**
  * Creates a ExpandMailgunRecipientBatchSendTargetRequestFactory from the input config.
  *
  * @param config
  * @returns
- */
-function expandMailgunRecipientBatchSendTargetRequestFactory(config) {
-    const { request: inputBaseRequest, useSubjectFromRecipientUserVariables, allowSingleRecipientBatchSendRequests, recipientVariablesConfig, mailgunRecipientBatchSendTargetEntityKeyRecipientLookup, overrideCarbonCopyVariablesWithCarbonCopyKeyRecipients } = config;
-    const defaultSubject = inputBaseRequest.subject;
+ */ function expandMailgunRecipientBatchSendTargetRequestFactory(config) {
+    var _inputBaseRequest_from, _inputBaseRequest_replyTo;
+    var inputBaseRequest = config.request, useSubjectFromRecipientUserVariables = config.useSubjectFromRecipientUserVariables, allowSingleRecipientBatchSendRequests = config.allowSingleRecipientBatchSendRequests, recipientVariablesConfig = config.recipientVariablesConfig, mailgunRecipientBatchSendTargetEntityKeyRecipientLookup = config.mailgunRecipientBatchSendTargetEntityKeyRecipientLookup, overrideCarbonCopyVariablesWithCarbonCopyKeyRecipients = config.overrideCarbonCopyVariablesWithCarbonCopyKeyRecipients;
+    var defaultSubject = inputBaseRequest.subject;
     if (!defaultSubject && !useSubjectFromRecipientUserVariables) {
         throw new Error('defaultSubject must be set when "useSubjectFromRecipientUserVariables" is false');
     }
@@ -451,48 +935,45 @@ function expandMailgunRecipientBatchSendTargetRequestFactory(config) {
      *
      * @param input
      * @returns
-     */
-    function determineCarbonCopyRecipients(input) {
-        const { baseRequestCarbonCopyRecipients, carbonCopyRecipients, carbonCopyRecipientsKeys } = input;
-        let cc = carbonCopyRecipients ? asArray(carbonCopyRecipients) : baseRequestCarbonCopyRecipients;
-        const resolvedCc = mailgunRecipientBatchSendTargetEntityKeyRecipientLookup?.getRecipientsForKeys(carbonCopyRecipientsKeys);
-        if (resolvedCc?.length) {
+     */ function determineCarbonCopyRecipients(input) {
+        var baseRequestCarbonCopyRecipients = input.baseRequestCarbonCopyRecipients, carbonCopyRecipients = input.carbonCopyRecipients, carbonCopyRecipientsKeys = input.carbonCopyRecipientsKeys;
+        var cc = carbonCopyRecipients ? asArray(carbonCopyRecipients) : baseRequestCarbonCopyRecipients;
+        var resolvedCc = mailgunRecipientBatchSendTargetEntityKeyRecipientLookup === null || mailgunRecipientBatchSendTargetEntityKeyRecipientLookup === void 0 ? void 0 : mailgunRecipientBatchSendTargetEntityKeyRecipientLookup.getRecipientsForKeys(carbonCopyRecipientsKeys);
+        if (resolvedCc === null || resolvedCc === void 0 ? void 0 : resolvedCc.length) {
             if (overrideCarbonCopyVariablesWithCarbonCopyKeyRecipients) {
                 cc = resolvedCc;
-            }
-            else {
-                cc = [...(cc ?? []), ...resolvedCc];
+            } else {
+                cc = _to_consumable_array(cc !== null && cc !== void 0 ? cc : []).concat(_to_consumable_array(resolvedCc));
             }
         }
-        return cc?.length ? cc : undefined;
+        return (cc === null || cc === void 0 ? void 0 : cc.length) ? cc : undefined;
     }
-    const baseRequestCc = determineCarbonCopyRecipients({
+    var baseRequestCc = determineCarbonCopyRecipients({
         carbonCopyRecipients: inputBaseRequest.cc,
         carbonCopyRecipientsKeys: inputBaseRequest.ccKeys
     });
-    const baseRequestBcc = determineCarbonCopyRecipients({
+    var baseRequestBcc = determineCarbonCopyRecipients({
         carbonCopyRecipients: inputBaseRequest.bcc,
         carbonCopyRecipientsKeys: inputBaseRequest.bccKeys
     });
-    const baseRequestFrom = inputBaseRequest.from ?? mailgunRecipientBatchSendTargetEntityKeyRecipientLookup?.getRecipientOrDefaultForKey(inputBaseRequest.fromKey);
-    const baseRequestReplyTo = inputBaseRequest.replyTo ?? mailgunRecipientBatchSendTargetEntityKeyRecipientLookup?.getRecipientOrDefaultForKey(inputBaseRequest.replyToKey);
-    const baseRequest = {
-        ...inputBaseRequest,
+    var baseRequestFrom = (_inputBaseRequest_from = inputBaseRequest.from) !== null && _inputBaseRequest_from !== void 0 ? _inputBaseRequest_from : mailgunRecipientBatchSendTargetEntityKeyRecipientLookup === null || mailgunRecipientBatchSendTargetEntityKeyRecipientLookup === void 0 ? void 0 : mailgunRecipientBatchSendTargetEntityKeyRecipientLookup.getRecipientOrDefaultForKey(inputBaseRequest.fromKey);
+    var baseRequestReplyTo = (_inputBaseRequest_replyTo = inputBaseRequest.replyTo) !== null && _inputBaseRequest_replyTo !== void 0 ? _inputBaseRequest_replyTo : mailgunRecipientBatchSendTargetEntityKeyRecipientLookup === null || mailgunRecipientBatchSendTargetEntityKeyRecipientLookup === void 0 ? void 0 : mailgunRecipientBatchSendTargetEntityKeyRecipientLookup.getRecipientOrDefaultForKey(inputBaseRequest.replyToKey);
+    var baseRequest = _object_spread_props(_object_spread({}, inputBaseRequest), {
         from: baseRequestFrom,
         replyTo: baseRequestReplyTo,
         cc: baseRequestCc,
         bcc: baseRequestBcc
-    };
+    });
     delete baseRequest.fromKey;
     delete baseRequest.replyToKey;
     delete baseRequest.ccKeys;
     delete baseRequest.bccKeys;
-    const configAllowBatchSend = baseRequest.batchSend !== false;
-    return (inputRecipients) => {
+    var configAllowBatchSend = baseRequest.batchSend !== false;
+    return function(inputRecipients) {
         // Process recipients to resolve keys
-        const recipients = inputRecipients.map((recipient) => {
-            let from = recipient.from;
-            let replyTo = recipient.replyTo;
+        var recipients = inputRecipients.map(function(recipient) {
+            var from = recipient.from;
+            var replyTo = recipient.replyTo;
             if (mailgunRecipientBatchSendTargetEntityKeyRecipientLookup) {
                 // try the fromKey, otherwise use the baseRequest.from
                 if (!from) {
@@ -502,8 +983,7 @@ function expandMailgunRecipientBatchSendTargetRequestFactory(config) {
                 if (!replyTo) {
                     replyTo = mailgunRecipientBatchSendTargetEntityKeyRecipientLookup.getRecipientOrDefaultForKey(recipient.replyToKey, baseRequest.replyTo);
                 }
-            }
-            else {
+            } else {
                 // use defaults from base request
                 if (!from) {
                     from = baseRequest.from;
@@ -512,76 +992,76 @@ function expandMailgunRecipientBatchSendTargetRequestFactory(config) {
                     replyTo = baseRequest.replyTo;
                 }
             }
-            const cc = determineCarbonCopyRecipients({
+            var cc = determineCarbonCopyRecipients({
                 baseRequestCarbonCopyRecipients: baseRequestCc,
                 carbonCopyRecipients: recipient.cc,
                 carbonCopyRecipientsKeys: recipient.ccKeys
             });
-            const bcc = determineCarbonCopyRecipients({
+            var bcc = determineCarbonCopyRecipients({
                 baseRequestCarbonCopyRecipients: baseRequestBcc,
                 carbonCopyRecipients: recipient.bcc,
                 carbonCopyRecipientsKeys: recipient.bccKeys
             });
-            const result = {
-                ...recipient,
-                from,
-                replyTo,
-                cc,
-                bcc
-            };
+            var result = _object_spread_props(_object_spread({}, recipient), {
+                from: from,
+                replyTo: replyTo,
+                cc: cc,
+                bcc: bcc
+            });
             return result;
         });
-        const allowBatchSend = configAllowBatchSend && (allowSingleRecipientBatchSendRequests || recipients.length > 1);
-        const nonBatchSendRequests = [];
-        const batchSendRequestRecipients = [];
-        recipients.forEach((recipient) => {
-            const recipientHasCarbonCopy = Boolean(recipient.cc?.length || recipient.bcc?.length);
+        var allowBatchSend = configAllowBatchSend && (allowSingleRecipientBatchSendRequests || recipients.length > 1);
+        var nonBatchSendRequests = [];
+        var batchSendRequestRecipients = [];
+        recipients.forEach(function(recipient) {
+            var _recipient_cc, _recipient_bcc;
+            var recipientHasCarbonCopy = Boolean(((_recipient_cc = recipient.cc) === null || _recipient_cc === void 0 ? void 0 : _recipient_cc.length) || ((_recipient_bcc = recipient.bcc) === null || _recipient_bcc === void 0 ? void 0 : _recipient_bcc.length));
             if (allowBatchSend && !recipientHasCarbonCopy) {
                 // add to batch send recipients
                 batchSendRequestRecipients.push(recipient);
-            }
-            else {
+            } else {
+                var _ref, _ref1, _recipient_from, _recipient_replyTo, _baseRequest_recipientVariablesConfig;
+                var _recipient_userVariables, _recipient_userVariables1;
                 // add to non-batch send requests
                 // use the subject from the recipient's user variables if available as a default
-                const cc = recipient.cc;
-                const bcc = recipient.bcc;
-                const subject = (useSubjectFromRecipientUserVariables ? recipient.userVariables?.['subject'] : undefined) ?? defaultSubject ?? recipient.userVariables?.['subject'];
-                const request = {
-                    ...baseRequest,
-                    from: recipient.from ?? baseRequest.from,
-                    replyTo: recipient.replyTo ?? baseRequest.replyTo,
-                    recipientVariablesConfig: baseRequest.recipientVariablesConfig ?? recipientVariablesConfig,
+                var cc = recipient.cc;
+                var bcc = recipient.bcc;
+                var subject = (_ref = (_ref1 = useSubjectFromRecipientUserVariables ? (_recipient_userVariables = recipient.userVariables) === null || _recipient_userVariables === void 0 ? void 0 : _recipient_userVariables['subject'] : undefined) !== null && _ref1 !== void 0 ? _ref1 : defaultSubject) !== null && _ref !== void 0 ? _ref : (_recipient_userVariables1 = recipient.userVariables) === null || _recipient_userVariables1 === void 0 ? void 0 : _recipient_userVariables1['subject'];
+                var request = _object_spread_props(_object_spread({}, baseRequest), {
+                    from: (_recipient_from = recipient.from) !== null && _recipient_from !== void 0 ? _recipient_from : baseRequest.from,
+                    replyTo: (_recipient_replyTo = recipient.replyTo) !== null && _recipient_replyTo !== void 0 ? _recipient_replyTo : baseRequest.replyTo,
+                    recipientVariablesConfig: (_baseRequest_recipientVariablesConfig = baseRequest.recipientVariablesConfig) !== null && _baseRequest_recipientVariablesConfig !== void 0 ? _baseRequest_recipientVariablesConfig : recipientVariablesConfig,
                     to: recipient,
-                    cc,
-                    bcc,
-                    subject,
+                    cc: cc,
+                    bcc: bcc,
+                    subject: subject,
                     batchSend: false // explicitly disable batch send for non-batch requests
-                };
+                });
                 nonBatchSendRequests.push(request);
             }
         });
         // create batch send request(s)
-        const batchSendRequests = [];
+        var batchSendRequests = [];
         if (batchSendRequestRecipients.length > 0) {
-            const subject = useSubjectFromRecipientUserVariables ? MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE : defaultSubject;
+            var subject = useSubjectFromRecipientUserVariables ? MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE : defaultSubject;
             // Group recipients by their from/replyTo values
-            const batchSendRecipientGroups = makeValuesGroupMap(batchSendRequestRecipients, mailgunRecipientBatchSendTargetFromReplyToBatchGroupKey);
-            batchSendRecipientGroups.forEach((groupRecipients) => {
+            var batchSendRecipientGroups = makeValuesGroupMap(batchSendRequestRecipients, mailgunRecipientBatchSendTargetFromReplyToBatchGroupKey);
+            batchSendRecipientGroups.forEach(function(groupRecipients) {
+                var _baseRequest_recipientVariablesConfig;
                 // All recipients in this group should share the same from/replyTo values
-                const firstRecipient = groupRecipients[0];
-                const batchRequest = {
-                    ...baseRequest,
+                var firstRecipient = groupRecipients[0];
+                var batchRequest = _object_spread_props(_object_spread({}, baseRequest), {
                     from: firstRecipient.from,
                     replyTo: firstRecipient.replyTo,
-                    recipientVariablesConfig: baseRequest.recipientVariablesConfig ?? recipientVariablesConfig,
+                    recipientVariablesConfig: (_baseRequest_recipientVariablesConfig = baseRequest.recipientVariablesConfig) !== null && _baseRequest_recipientVariablesConfig !== void 0 ? _baseRequest_recipientVariablesConfig : recipientVariablesConfig,
                     to: groupRecipients,
-                    subject,
+                    subject: subject,
                     batchSend: true
-                };
+                });
                 batchSendRequests.push(batchRequest);
             });
         }
-        return filterMaybeArrayValues([...batchSendRequests, ...nonBatchSendRequests]);
+        return filterMaybeArrayValues(_to_consumable_array(batchSendRequests).concat(_to_consumable_array(nonBatchSendRequests)));
     };
 }
 /**
@@ -589,21 +1069,23 @@ function expandMailgunRecipientBatchSendTargetRequestFactory(config) {
  *
  * @param config The configuration for the lookup.
  * @returns The lookup.
- */
-function mailgunRecipientBatchSendTargetEntityKeyRecipientLookup(config) {
-    const { recipientsMap } = config;
+ */ function mailgunRecipientBatchSendTargetEntityKeyRecipientLookup(config) {
+    var recipientsMap = config.recipientsMap;
     function getRecipientOrDefaultForKey(input, defaultRecipient) {
-        let result = defaultRecipient;
+        var result = defaultRecipient;
         if (input) {
-            result = recipientsMap.get(input) ?? defaultRecipient;
+            var _recipientsMap_get;
+            result = (_recipientsMap_get = recipientsMap.get(input)) !== null && _recipientsMap_get !== void 0 ? _recipientsMap_get : defaultRecipient;
         }
         return result;
     }
     function getRecipientsForKeys(input) {
-        let result = undefined;
+        var result = undefined;
         if (input) {
-            const keysArray = asArray(input);
-            const recipients = filterMaybeArrayValues(keysArray.map((key) => recipientsMap.get(key)));
+            var keysArray = asArray(input);
+            var recipients = filterMaybeArrayValues(keysArray.map(function(key) {
+                return recipientsMap.get(key);
+            }));
             if (recipients.length > 0) {
                 result = recipients;
             }
@@ -611,9 +1093,9 @@ function mailgunRecipientBatchSendTargetEntityKeyRecipientLookup(config) {
         return result;
     }
     return {
-        recipientsMap,
-        getRecipientOrDefaultForKey,
-        getRecipientsForKeys
+        recipientsMap: recipientsMap,
+        getRecipientOrDefaultForKey: getRecipientOrDefaultForKey,
+        getRecipientsForKeys: getRecipientsForKeys
     };
 }