@dereekb/model 12.7.0 → 13.0.1

package/index.cjs.js

@@ -3,6 +3,7 @@
 var util = require('@dereekb/util');
 var classTransformer = require('class-transformer');
 var classValidator = require('class-validator');
+var makeError = require('make-error');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -44,37 +45,67 @@ const ADDRESS_STATE_CODE_MAX_LENGTH = 2;
 const ADDRESS_ZIP_MAX_LENGTH = 11;
 const ADDRESS_COUNTRY_MAX_LENGTH = 80;
 class AbstractUnitedStatesAddressWithoutStateParams {
-  constructor() {
-    this.line1 = void 0;
-    this.line2 = void 0;
-    this.city = void 0;
-    this.zip = void 0;
-  }
-}
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line1", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line2", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(ADDRESS_CITY_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "city", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.Matches(util.ZIP_CODE_STRING_REGEX), classValidator.MaxLength(ADDRESS_ZIP_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "zip", void 0);
+    line1;
+    line2;
+    city;
+    zip;
+}
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line1", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line2", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(ADDRESS_CITY_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "city", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.Matches(util.ZIP_CODE_STRING_REGEX),
+    classValidator.MaxLength(ADDRESS_ZIP_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "zip", void 0);
 /**
  * UnitedStatesAddress that enforces a StateCode for the state value.
  */
 class UnitedStatesAddressWithStateCodeParams extends AbstractUnitedStatesAddressWithoutStateParams {
-  constructor(...args) {
-    super(...args);
-    this.state = void 0;
-  }
-}
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.Matches(util.US_STATE_CODE_STRING_REGEX), classValidator.MinLength(ADDRESS_STATE_CODE_MAX_LENGTH), classValidator.MaxLength(ADDRESS_STATE_CODE_MAX_LENGTH), __metadata("design:type", String)], UnitedStatesAddressWithStateCodeParams.prototype, "state", void 0);
+    state;
+}
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.Matches(util.US_STATE_CODE_STRING_REGEX),
+    classValidator.MinLength(ADDRESS_STATE_CODE_MAX_LENGTH),
+    classValidator.MaxLength(ADDRESS_STATE_CODE_MAX_LENGTH),
+    __metadata("design:type", String)
+], UnitedStatesAddressWithStateCodeParams.prototype, "state", void 0);
 /**
  * UnitedStatesAddress that enforces a State for the state value.
  */
 class UnitedStatesAddressWithStateStringParams extends AbstractUnitedStatesAddressWithoutStateParams {
-  constructor(...args) {
-    super(...args);
-    this.state = void 0;
-  }
+    state;
 }
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(ADDRESS_STATE_MAX_LENGTH), __metadata("design:type", String)], UnitedStatesAddressWithStateStringParams.prototype, "state", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(ADDRESS_STATE_MAX_LENGTH),
+    __metadata("design:type", String)
+], UnitedStatesAddressWithStateStringParams.prototype, "state", void 0);
 
 const UNKNOWN_WEBSITE_LINK_TYPE = 'u';
 /**
@@ -86,24 +117,37 @@ const WEBSITE_LINK_TYPE_MAX_LENGTH = 32;
  */
 const WEBSITE_LINK_TYPE_REGEX = /^[a-zA-Z0-9]{1,32}$/;
 function isValidWebsiteLinkType(input) {
-  return WEBSITE_LINK_TYPE_REGEX.test(input);
+    return WEBSITE_LINK_TYPE_REGEX.test(input);
 }
 /**
  * Default max length of WebsiteLink's data string.
  */
 const WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH = 1000;
 class WebsiteLink {
-  constructor(template) {
-    this.t = void 0;
-    this.d = void 0;
-    if (template != null) {
-      this.t = template.t;
-      this.d = template.d;
+    t;
+    d;
+    constructor(template) {
+        if (template != null) {
+            this.t = template.t;
+            this.d = template.d;
+        }
     }
-  }
 }
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.Matches(WEBSITE_LINK_TYPE_REGEX), classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH), __metadata("design:type", String)], WebsiteLink.prototype, "t", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH), __metadata("design:type", String)], WebsiteLink.prototype, "d", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.Matches(WEBSITE_LINK_TYPE_REGEX),
+    classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteLink.prototype, "t", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteLink.prototype, "d", void 0);
 
 /**
  * Max length of WebsiteLink's data type.
@@ -131,47 +175,73 @@ const WEBSITE_FILE_LINK_NAME_MAX_LENGTH = 128;
 const WEBSITE_FILE_LINK_DATA_MAX_LENGTH = WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH - 3 - WEBSITE_FILE_LINK_TYPE_MAX_LENGTH - WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH - WEBSITE_FILE_LINK_NAME_MAX_LENGTH;
 const WEBSITE_FILE_LINK_DATA_REGEX = /^[^|]+$/;
 class WebsiteFileLink {
-  constructor(template) {
-    this.type = void 0;
-    this.mime = void 0;
-    this.name = void 0;
-    this.data = void 0;
-    if (template != null) {
-      this.type = template.type;
-      this.mime = template.mime;
-      this.name = template.name;
-      this.data = template.data;
+    type;
+    mime;
+    name;
+    data;
+    constructor(template) {
+        if (template != null) {
+            this.type = template.type;
+            this.mime = template.mime;
+            this.name = template.name;
+            this.data = template.data;
+        }
     }
-  }
 }
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.Matches(WEBSITE_FILE_LINK_TYPE_REGEX), classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "type", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.Matches(WEBSITE_FILE_LINK_MIME_TYPE_REGEX), classValidator.MaxLength(WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "mime", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.MaxLength(WEBSITE_FILE_LINK_NAME_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "name", void 0);
-__decorate([classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.Matches(WEBSITE_FILE_LINK_DATA_REGEX), classValidator.MaxLength(WEBSITE_FILE_LINK_DATA_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "data", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.Matches(WEBSITE_FILE_LINK_TYPE_REGEX),
+    classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "type", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.Matches(WEBSITE_FILE_LINK_MIME_TYPE_REGEX),
+    classValidator.MaxLength(WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "mime", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.MaxLength(WEBSITE_FILE_LINK_NAME_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "name", void 0);
+__decorate([
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.Matches(WEBSITE_FILE_LINK_DATA_REGEX),
+    classValidator.MaxLength(WEBSITE_FILE_LINK_DATA_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "data", void 0);
 const WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE = 'f';
 function websiteFileLinkToWebsiteLink(input) {
-  return {
-    t: WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE,
-    d: encodeWebsiteFileLinkToWebsiteLinkEncodedData(input)
-  };
+    return {
+        t: WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE,
+        d: encodeWebsiteFileLinkToWebsiteLinkEncodedData(input)
+    };
 }
 function websiteLinkToWebsiteLinkFile(input) {
-  const encodedData = input.d;
-  return decodeWebsiteLinkEncodedDataToWebsiteFileLink(encodedData);
+    const encodedData = input.d;
+    return decodeWebsiteLinkEncodedDataToWebsiteFileLink(encodedData);
 }
 const WEBSITE_FILE_LINK_ENCODE_SEPARATOR = '|';
 function encodeWebsiteFileLinkToWebsiteLinkEncodedData(input) {
-  const encoded = [input.type, input.mime, input.data, input.name].map(x => x || '').join(WEBSITE_FILE_LINK_ENCODE_SEPARATOR);
-  return encoded;
+    const encoded = [input.type, input.mime, input.data, input.name].map((x) => x || '').join(WEBSITE_FILE_LINK_ENCODE_SEPARATOR);
+    return encoded;
 }
 function decodeWebsiteLinkEncodedDataToWebsiteFileLink(input) {
-  const [type, mime, data, name] = util.splitJoinRemainder(input, WEBSITE_FILE_LINK_ENCODE_SEPARATOR, 4);
-  return util.filterFalsyAndEmptyValues({
-    type,
-    mime,
-    name,
-    data
-  });
+    const [type, mime, data, name] = util.splitJoinRemainder(input, WEBSITE_FILE_LINK_ENCODE_SEPARATOR, 4);
+    return util.filterFalsyAndEmptyValues({
+        type,
+        mime,
+        name,
+        data
+    });
 }
 
 /**
@@ -181,193 +251,194 @@ function decodeWebsiteLinkEncodedDataToWebsiteFileLink(input) {
  * - https://facebook.com/facebook
  */
 const WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID = util.isolateWebsitePathFunction({
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, prefix) {
-  const username = util.toRelativeSlashPathStartType(WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID(usernameOrWebsiteUrlToWebsiteUrl(input)));
-  if (prefix) {
-    return util.addPrefix(prefix, username);
-  } else {
-    return username;
-  }
+    const username = util.toRelativeSlashPathStartType(WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID(usernameOrWebsiteUrlToWebsiteUrl(input)));
+    if (prefix) {
+        return util.addPrefix(prefix, username);
+    }
+    else {
+        return username;
+    }
 }
 function usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, isolateFn) {
-  return util.toRelativeSlashPathStartType(isolateFn(usernameOrWebsiteUrlToWebsiteUrl(input)));
+    return util.toRelativeSlashPathStartType(isolateFn(usernameOrWebsiteUrlToWebsiteUrl(input)));
 }
 function usernameOrWebsiteUrlToWebsiteUrl(input) {
-  return util.hasWebsiteDomain(input) ? input : util.toAbsoluteSlashPathStartType(util.removeHttpFromUrl(input));
+    return util.hasWebsiteDomain(input) ? input : util.toAbsoluteSlashPathStartType(util.removeHttpFromUrl(input));
 }
 // MARK: Website
 const WEBSITE_URL_WEBSITE_LINK_TYPE = 'w';
 function websiteUrlToWebsiteLink(input) {
-  return {
-    t: WEBSITE_URL_WEBSITE_LINK_TYPE,
-    d: util.removeHttpFromUrl(input) // website urls are stored as-is without http/https
-  };
+    return {
+        t: WEBSITE_URL_WEBSITE_LINK_TYPE,
+        d: util.removeHttpFromUrl(input) // website urls are stored as-is without http/https
+    };
 }
 // MARK: Email
 const EMAIL_URL_WEBSITE_LINK_TYPE = 'e';
 function emailAddressToWebsiteLink(input) {
-  return {
-    t: EMAIL_URL_WEBSITE_LINK_TYPE,
-    d: input
-  };
+    return {
+        t: EMAIL_URL_WEBSITE_LINK_TYPE,
+        d: input
+    };
 }
 // MARK: Phone
 const PHONE_URL_WEBSITE_LINK_TYPE = 'p';
 function phoneNumberToWebsiteLink(input) {
-  return {
-    t: PHONE_URL_WEBSITE_LINK_TYPE,
-    d: input
-  };
+    return {
+        t: PHONE_URL_WEBSITE_LINK_TYPE,
+        d: input
+    };
 }
 // MARK: Facebook
 const FACEBOOK_BASE_URL = `https://www.facebook.com`;
 const FACEBOOK_WEBSITE_LINK_TYPE = 'fb';
 function facebookProfileUrlToWebsiteLink(input) {
-  return {
-    t: FACEBOOK_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: FACEBOOK_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function facebookProfileUrl(profileId) {
-  return `${FACEBOOK_BASE_URL}/${profileId}`;
+    return `${FACEBOOK_BASE_URL}/${profileId}`;
 }
 // MARK: Instagram
 const INSTAGRAM_BASE_URL = `https://www.instagram.com`;
 const INSTAGRAM_WEBSITE_LINK_TYPE = 'ig';
 function instagramProfileUrlToWebsiteLink(input) {
-  return {
-    t: INSTAGRAM_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: INSTAGRAM_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function instagramProfileUrl(profileId) {
-  return `${INSTAGRAM_BASE_URL}/${profileId}`;
+    return `${INSTAGRAM_BASE_URL}/${profileId}`;
 }
 // MARK: Twitter
 const TWITTER_BASE_URL = `https://www.twitter.com`;
 const TWITTER_WEBSITE_LINK_TYPE = 'tw';
 function twitterProfileUrlToWebsiteLink(input) {
-  return {
-    t: TWITTER_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: TWITTER_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function twitterProfileUrl(profileId) {
-  return `${TWITTER_BASE_URL}/${profileId}`;
+    return `${TWITTER_BASE_URL}/${profileId}`;
 }
 // MARK: Tiktok
 const TIKTOK_BASE_URL = `https://tiktok.com`;
 const TIKTOK_USERNAME_PREFIX = '@';
 const TIKTOK_WEBSITE_LINK_TYPE = 'tt';
 function tiktokProfileUrlToWebsiteLink(input) {
-  return {
-    t: TIKTOK_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, TIKTOK_USERNAME_PREFIX)
-  };
+    return {
+        t: TIKTOK_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, TIKTOK_USERNAME_PREFIX)
+    };
 }
 function tiktokProfileUrl(profileId) {
-  return `${TIKTOK_BASE_URL}/@${profileId}`;
+    return `${TIKTOK_BASE_URL}/@${profileId}`;
 }
 // MARK: Snapchat
 const SNAPCHAT_BASE_URL = `https://snapchat.com`;
 const SNAPCHAT_WEBSITE_LINK_TYPE = 'sc';
 const SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'add',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'add',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function snapchatProfileUrlToWebsiteLink(input) {
-  return {
-    t: SNAPCHAT_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: SNAPCHAT_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function snapchatProfileUrl(profileId) {
-  return `${SNAPCHAT_BASE_URL}/add/${profileId}`;
+    return `${SNAPCHAT_BASE_URL}/add/${profileId}`;
 }
 // MARK: YouTube
 const YOUTUBE_BASE_URL = `https://youtube.com`;
 const YOUTUBE_WEBSITE_LINK_TYPE = 'yt';
 const YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'c',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'c',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function youtubeProfileUrlToWebsiteLink(input) {
-  return {
-    t: YOUTUBE_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: YOUTUBE_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function youtubeProfileUrl(profileId) {
-  return `${YOUTUBE_BASE_URL}/c/${profileId}`;
+    return `${YOUTUBE_BASE_URL}/c/${profileId}`;
 }
 // MARK: PayPal
 const PAYPAL_BASE_URL = `https://paypal.me`;
 const PAYPAL_WEBSITE_LINK_TYPE = 'pp';
 function paypalProfileUrlToWebsiteLink(input) {
-  return {
-    t: PAYPAL_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: PAYPAL_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function paypalProfileUrl(profileId) {
-  return `${PAYPAL_BASE_URL}/${profileId}`;
+    return `${PAYPAL_BASE_URL}/${profileId}`;
 }
 // MARK: Cashapp
 const CASHAPP_BASE_URL = `https://cash.app`;
 const CASHAPP_USERNAME_PREFIX = '$';
 const CASHAPP_WEBSITE_LINK_TYPE = 'ca';
 function cashappProfileUrlToWebsiteLink(input) {
-  return {
-    t: CASHAPP_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, CASHAPP_USERNAME_PREFIX)
-  };
+    return {
+        t: CASHAPP_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, CASHAPP_USERNAME_PREFIX)
+    };
 }
 function cashappProfileUrl(profileId) {
-  return `${CASHAPP_BASE_URL}/$${profileId}`;
+    return `${CASHAPP_BASE_URL}/$${profileId}`;
 }
 // MARK: Venmo
 const VENMO_BASE_URL = `https://account.venmo.com`;
 const VENMO_WEBSITE_LINK_TYPE = 'vn';
 const VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'u',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'u',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function venmoProfileUrlToWebsiteLink(input) {
-  return {
-    t: VENMO_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: VENMO_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function venmoProfileUrl(profileId) {
-  return `${VENMO_BASE_URL}/u/${profileId}`;
+    return `${VENMO_BASE_URL}/u/${profileId}`;
 }
 // MARK: Spotify
 const SPOTIFY_BASE_URL = `https://open.spotify.com/`;
 const SPOTIFY_WEBSITE_LINK_TYPE = 'sp';
 const SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'user',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'user',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function spotifyProfileUrlToWebsiteLink(input) {
-  return {
-    t: SPOTIFY_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: SPOTIFY_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function spotifyProfileUrl(profileId) {
-  return `${SPOTIFY_BASE_URL}/user/${profileId}`;
+    return `${SPOTIFY_BASE_URL}/user/${profileId}`;
 }
 
 const GRANTED_SYS_ADMIN_ROLE_KEY = 'sysadmin';
@@ -380,7 +451,7 @@ const GRANTED_ADMIN_ROLE_KEY = 'admin';
  * @returns
  */
 function isGrantedAdminLevelRole(role) {
-  return role === GRANTED_ADMIN_ROLE_KEY || role === GRANTED_OWNER_ROLE_KEY;
+    return role === GRANTED_ADMIN_ROLE_KEY || role === GRANTED_OWNER_ROLE_KEY;
 }
 const GRANTED_READ_ROLE_KEY = 'read';
 const GRANTED_UPDATE_ROLE_KEY = 'update';
@@ -388,20 +459,20 @@ const GRANTED_DELETE_ROLE_KEY = 'delete';
 const FULL_ACCESS_ROLE_KEY = '__FULL__';
 const NO_ACCESS_ROLE_KEY = '__EMPTY__';
 function noAccessRoleMap() {
-  return {
-    [NO_ACCESS_ROLE_KEY]: true
-  };
+    return {
+        [NO_ACCESS_ROLE_KEY]: true
+    };
 }
 function isNoAccessRoleMap(input) {
-  return input[NO_ACCESS_ROLE_KEY] === true;
+    return input[NO_ACCESS_ROLE_KEY] === true;
 }
 function fullAccessRoleMap() {
-  return {
-    [FULL_ACCESS_ROLE_KEY]: true
-  };
+    return {
+        [FULL_ACCESS_ROLE_KEY]: true
+    };
 }
 function isFullAccessRoleMap(input) {
-  return input[FULL_ACCESS_ROLE_KEY] === true;
+    return input[FULL_ACCESS_ROLE_KEY] === true;
 }
 /**
  * Creates a GrantedRoleMapReader.
@@ -410,61 +481,63 @@ function isFullAccessRoleMap(input) {
  * @returns
  */
 function grantedRoleMapReader(map) {
-  return new GrantedRoleMapReaderInstance(map);
+    return new GrantedRoleMapReaderInstance(map);
 }
 class GrantedRoleMapReaderInstance {
-  constructor(map) {
-    this._map = void 0;
-    this._map = map;
-  }
-  hasNoAccess() {
-    return this._map[NO_ACCESS_ROLE_KEY];
-  }
-  truthMap(input) {
-    const result = {};
-    util.forEachKeyValue(input, {
-      forEach: ([role, value]) => {
-        if (this.hasRole(role)) {
-          result[role] = value;
-        }
-      }
-    });
-    return result;
-  }
-  hasRole(role) {
-    return this.hasRoles('any', role);
-  }
-  hasRoles(setIncludes, inputRoles) {
-    if (this._map[FULL_ACCESS_ROLE_KEY]) {
-      return true;
-    } else {
-      return this.containsRoles(setIncludes, inputRoles);
+    _map;
+    constructor(map) {
+        this._map = map;
     }
-  }
-  containsRoles(setIncludes, inputRoles) {
-    const roles = util.iterableToArray(inputRoles);
-    if (setIncludes === 'any') {
-      return this.containsAnyRole(roles);
-    } else {
-      return this.containsEachRole(roles);
+    hasNoAccess() {
+        return this._map[NO_ACCESS_ROLE_KEY];
     }
-  }
-  containsAnyRole(roles) {
-    for (const role of roles) {
-      if (this._map[role]) {
-        return true;
-      }
+    truthMap(input) {
+        const result = {};
+        util.forEachKeyValue(input, {
+            forEach: ([role, value]) => {
+                if (this.hasRole(role)) {
+                    result[role] = value;
+                }
+            }
+        });
+        return result;
+    }
+    hasRole(role) {
+        return this.hasRoles('any', role);
+    }
+    hasRoles(setIncludes, inputRoles) {
+        if (this._map[FULL_ACCESS_ROLE_KEY]) {
+            return true;
+        }
+        else {
+            return this.containsRoles(setIncludes, inputRoles);
+        }
+    }
+    containsRoles(setIncludes, inputRoles) {
+        const roles = util.iterableToArray(inputRoles);
+        if (setIncludes === 'any') {
+            return this.containsAnyRole(roles);
+        }
+        else {
+            return this.containsEachRole(roles);
+        }
     }
-    return false;
-  }
-  containsEachRole(roles) {
-    for (const role of roles) {
-      if (!this._map[role]) {
+    containsAnyRole(roles) {
+        for (const role of roles) {
+            if (this._map[role]) {
+                return true;
+            }
+        }
         return false;
-      }
     }
-    return true;
-  }
+    containsEachRole(roles) {
+        for (const role of roles) {
+            if (!this._map[role]) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 /**
  * Converts the input array of roles to a GrantedRoleKeysMap.
@@ -473,74 +546,77 @@ class GrantedRoleMapReaderInstance {
  * @returns
  */
 function grantedRoleKeysMapFromArray(roles, value = true) {
-  return util.arrayToObject(roles, x => x, () => value);
+    return util.arrayToObject(roles, (x) => x, () => value);
 }
 
 function noAccessContextGrantedModelRoles(context, data) {
-  return contextGrantedModelRoles(context, data, noAccessRoleMap());
+    return contextGrantedModelRoles(context, data, noAccessRoleMap());
 }
 function fullAccessGrantedModelRoles(context, data) {
-  return contextGrantedModelRoles(context, data, fullAccessRoleMap());
+    return contextGrantedModelRoles(context, data, fullAccessRoleMap());
 }
 function contextGrantedModelRoles(context, data, roles) {
-  return {
-    data,
-    context,
-    roleMap: roles
-  };
+    return {
+        data,
+        context,
+        roleMap: roles
+    };
 }
 
 /**
  * Abstract ModelPermissionService implementation.
  */
 class AbstractModelPermissionService {
-  constructor(modelLoader) {
-    this._modelLoader = void 0;
-    this._modelLoader = modelLoader;
-  }
-  get modelLoader() {
-    return this._modelLoader;
-  }
-  async roleMapForKeyContext(key, context) {
-    const model = await this.modelLoader.loadModelForKey(key, context);
-    let result;
-    if (model != null) {
-      result = await this.roleMapForModelContext(model, context);
-    } else {
-      result = noAccessContextGrantedModelRoles(context);
+    _modelLoader;
+    constructor(modelLoader) {
+        this._modelLoader = modelLoader;
     }
-    return result;
-  }
-  async roleMapForModelContext(model, context) {
-    const output = await this.outputForModel(model, context);
-    let result;
-    if (output != null && this.isUsableOutputForRoles(output, context)) {
-      result = await this.getRoleMapForOutput(output, context, model);
-    } else {
-      result = noAccessContextGrantedModelRoles(context, output);
+    get modelLoader() {
+        return this._modelLoader;
+    }
+    async roleMapForKeyContext(key, context) {
+        const model = await this.modelLoader.loadModelForKey(key, context);
+        let result;
+        if (model != null) {
+            result = await this.roleMapForModelContext(model, context);
+        }
+        else {
+            result = noAccessContextGrantedModelRoles(context);
+        }
+        return result;
+    }
+    async roleMapForModelContext(model, context) {
+        const output = await this.outputForModel(model, context);
+        let result;
+        if (output != null && this.isUsableOutputForRoles(output, context)) {
+            result = await this.getRoleMapForOutput(output, context, model);
+        }
+        else {
+            result = noAccessContextGrantedModelRoles(context, output);
+        }
+        return result;
+    }
+    async getRoleMapForOutput(output, context, model) {
+        const roleMap = await this.roleMapForModel(output, context, model);
+        return contextGrantedModelRoles(context, output, roleMap);
+    }
+    isUsableOutputForRoles(output, context) {
+        return true; // can override in parent functions to further filter roles.
     }
-    return result;
-  }
-  async getRoleMapForOutput(output, context, model) {
-    const roleMap = await this.roleMapForModel(output, context, model);
-    return contextGrantedModelRoles(context, output, roleMap);
-  }
-  isUsableOutputForRoles(output, context) {
-    return true; // can override in parent functions to further filter roles.
-  }
 }
 
 function syncEntityCommonTypeIdPairFactory(commonType) {
-  return input => {
-    if (typeof input === 'string') {
-      return {
-        commonType,
-        commonId: input
-      };
-    } else {
-      return input;
-    }
-  };
+    return (input) => {
+        if (typeof input === 'string') {
+            return {
+                commonType,
+                commonId: input
+            };
+        }
+        else {
+            return input;
+        }
+    };
 }
 /**
  * Creates a SyncEntityFactory.
@@ -549,2215 +625,552 @@ function syncEntityCommonTypeIdPairFactory(commonType) {
  * @returns
  */
 function syncEntityFactory(config) {
-  const {
-    idFactory: inputIdFactory,
-    sourceInfo
-  } = config;
-  const idFactory = inputIdFactory ?? util.MAP_IDENTITY;
-  return input => {
-    const {
-      commonType,
-      commonId
-    } = input;
-    const id = idFactory(commonId);
-    return {
-      commonType,
-      commonId,
-      id,
-      sourceInfo
+    const { idFactory: inputIdFactory, sourceInfo } = config;
+    const idFactory = inputIdFactory ?? util.MAP_IDENTITY;
+    return (input) => {
+        const { commonType, commonId } = input;
+        const id = idFactory(commonId);
+        return {
+            commonType,
+            commonId,
+            id,
+            sourceInfo
+        };
     };
-  };
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+/**
+ * Error thrown when the common type is not known/registered.
+ */
+class UnregisteredSyncEntityCommonTypeError extends makeError.BaseError {
+    commonType;
+    constructor(commonType) {
+        super(`The common type "${commonType}" is not registered.`);
+        this.commonType = commonType;
+    }
+}
+/**
+ * Error thrown when no primary sync source is found for an entity.
+ */
+class NoPrimarySyncSourceError extends makeError.BaseError {
+    entity;
+    constructor(entity) {
+        super(`No primary sync source found for entity "${entity.commonType}:${entity.commonId}".`);
+        this.entity = entity;
+    }
+}
+/**
+ * Error thrown when multiple primary sync sources are found for an entity.
+ */
+class MultiplePrimarySyncSourceError extends makeError.BaseError {
+    entity;
+    constructor(entity) {
+        super(`Multiple primary sync sources found for entity "${entity.commonType}:${entity.commonId}".`);
+        this.entity = entity;
+    }
+}
+/**
+ * Error thrown when a synchronization fails for an entity.
+ */
+class SynchronizationFailedError extends makeError.BaseError {
+    entity;
+    error;
+    constructor(entity, error) {
+        super(`Synchronization failed for entity "${entity.commonType}:${entity.commonId}". Error: ${error}`);
+        this.entity = entity;
+        this.error = error;
+    }
+}
 
-var check = function (it) {
-  return it && it.Math === Math && it;
-};
+function syncEntitySynchronizer(config) {
+    const map = new Map(config.commonTypeSynchronizers.map((x) => [x.commonType, x]));
+    const commonTypes = Array.from(map.keys());
+    const commonTypeSynchronizer = (input) => {
+        const synchronizer = map.get(input);
+        if (!synchronizer) {
+            throw new UnregisteredSyncEntityCommonTypeError(input);
+        }
+        return synchronizer;
+    };
+    return {
+        commonTypes,
+        commonTypeSynchronizer,
+        synchronizeInstance: (input) => {
+            const synchronizer = commonTypeSynchronizer(input.commonType);
+            return synchronizer.synchronizeInstance(input);
+        }
+    };
+}
 
-// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
-var global$b =
-  // eslint-disable-next-line es/no-global-this -- safe
-  check(typeof globalThis == 'object' && globalThis) ||
-  check(typeof window == 'object' && window) ||
-  // eslint-disable-next-line no-restricted-globals -- safe
-  check(typeof self == 'object' && self) ||
-  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
-  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
-  // eslint-disable-next-line no-new-func -- fallback
-  (function () { return this; })() || Function('return this')();
+function basicSyncEntityCommonTypeSynchronizerInstanceFactory(config) {
+    const { commonType, sources, entitySourceContextLoader, dynamicSources = false } = config;
+    const syncEntityCommonTypeIdPairForType = syncEntityCommonTypeIdPairFactory(commonType);
+    const sourcesByContextType = util.makeValuesGroupMap(sources, (x) => x.contextType);
+    const allGlobalSources = sourcesByContextType.get('global') ?? [];
+    const allContextSources = sourcesByContextType.get('context') ?? [];
+    /**
+     * Loads the relevant sources for the given entity and context.
+     *
+     * @param entitySourceContext The contextual information for the entity.
+     * @returns The relevant sources for the entity.
+     */
+    function loadSources(entityCommonTypeIdPair, entitySourceContext) {
+        const { globalSources, contextSources } = entitySourceContext;
+        // load/filter global sources
+        const globalMap = new Map(globalSources.map((x) => {
+            let sourceId;
+            let flowType;
+            if (typeof x === 'string') {
+                sourceId = x;
+                flowType = 'unset';
+            }
+            else {
+                sourceId = x.sourceId;
+                flowType = x.flowType;
+            }
+            return [sourceId, { sourceId, flowType }];
+        }));
+        const relevantGlobalSources = util.filterMaybeArrayValues(allGlobalSources.map((x) => {
+            const sourceContext = globalMap.get(x.info.id);
+            let result;
+            if (sourceContext != null) {
+                result = {
+                    entityCommonTypeIdPair,
+                    flowType: sourceContext.flowType ?? x.defaultFlowType ?? 'unset',
+                    source: x
+                };
+            }
+            return result;
+        }));
+        // load/filter context sources
+        const contextMap = new Map(contextSources.map((x) => [x.sourceId, x]));
+        const relevantContextSources = util.filterMaybeArrayValues(allContextSources.map((x) => {
+            const sourceContext = contextMap.get(x.info.id);
+            let result;
+            if (sourceContext != null) {
+                const flowType = sourceContext.flowType ?? x.defaultFlowType ?? 'unset';
+                result = {
+                    entityCommonTypeIdPair,
+                    flowType,
+                    source: x,
+                    context: sourceContext
+                };
+            }
+            return result;
+        }));
+        const allSources = [...relevantGlobalSources, ...relevantContextSources];
+        // sort by order, with primary first
+        allSources.sort(util.sortByNumberFunction((x) => {
+            let result;
+            switch (x.flowType) {
+                case 'primary':
+                    result = 1;
+                    break;
+                case 'secondary':
+                    result = 2;
+                    break;
+                case 'unset':
+                default:
+                    result = 3;
+                    break;
+            }
+            return result;
+        }));
+        return allSources;
+    }
+    const synchronizeInstance = async (input) => {
+        const syncEntityCommonTypeIdPair = syncEntityCommonTypeIdPairForType(input);
+        const _loadRelevantSources = async () => {
+            const entitySourceContext = await entitySourceContextLoader(syncEntityCommonTypeIdPair);
+            const relevantSources = loadSources(syncEntityCommonTypeIdPair, entitySourceContext);
+            return relevantSources;
+        };
+        let loadRelevantSources;
+        if (dynamicSources) {
+            // if dynamic, reload each time and do not cache
+            loadRelevantSources = _loadRelevantSources;
+        }
+        else {
+            // if not dynamic, make a cached getter
+            loadRelevantSources = util.cachedGetter(_loadRelevantSources);
+        }
+        /**
+         * Performs the synchonization
+         */
+        const synchronize = async (context) => {
+            const relevantSources = await loadRelevantSources();
+            const syncEntityInstances = await Promise.all(relevantSources.map((x) => x.source.syncEntityInstance(x).then((y) => [x, y])));
+            const sourcesByFlowType = util.makeValuesGroupMap(syncEntityInstances, (x) => x[0].flowType);
+            const primarySources = sourcesByFlowType.get('primary') ?? [];
+            const secondarySources = sourcesByFlowType.get('secondary') ?? [];
+            const replicaSources = sourcesByFlowType.get('replica') ?? [];
+            // assert primary sources count
+            switch (primarySources.length) {
+                case 0:
+                    throw new NoPrimarySyncSourceError(syncEntityCommonTypeIdPair);
+                case 1:
+                    break;
+                default:
+                    throw new MultiplePrimarySyncSourceError(syncEntityCommonTypeIdPair);
+            }
+            function synchronizeInstance(source, deleted) {
+                const [input, sourceInstance] = source;
+                const promise = deleted ? sourceInstance.synchronizeDelete() : sourceInstance.synchronize();
+                return promise.catch((error) => {
+                    const errorResult = {
+                        type: 'error',
+                        error,
+                        entity: {
+                            ...syncEntityCommonTypeIdPair,
+                            sourceInfo: input.source.info,
+                            id: ''
+                        }
+                    };
+                    return errorResult;
+                });
+            }
+            async function performSynchronizationOfSources(input) {
+                const { secondaryFlaggedDelete } = input;
+                let result;
+                // synchronize the primary source
+                const primarySource = primarySources[0];
+                const primarySyncResult = await synchronizeInstance(primarySource, secondaryFlaggedDelete ?? false);
+                const synchronizedEntityResults = [primarySyncResult];
+                let primaryFlaggedDelete = false;
+                switch (primarySyncResult.type) {
+                    case 'deleted':
+                        primaryFlaggedDelete = true;
+                        break;
+                    case 'failed':
+                    case 'error':
+                        throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, primarySyncResult.error);
+                }
+                // synchronize all secondary sources, one after the other. If any secondary source returns deleted and the primary source was not flagged as deleted, then the synchronization will be restarted.
+                for (const secondarySource of secondarySources) {
+                    const secondarySyncResult = await synchronizeInstance(secondarySource, primaryFlaggedDelete);
+                    synchronizedEntityResults.push(secondarySyncResult);
+                    switch (secondarySyncResult.type) {
+                        case 'deleted':
+                            if (primaryFlaggedDelete === false) {
+                                break;
+                            }
+                            break;
+                        case 'failed':
+                        case 'error':
+                            throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, secondarySyncResult.error);
+                    }
+                }
+                // if result was already set, then it was completed in a recursive result
+                if (result == null) {
+                    // synchronize all replica sources concurrently
+                    const replicaTaskResults = await util.performAsyncTasks(replicaSources, (x) => synchronizeInstance(x, primaryFlaggedDelete), {
+                        sequential: false,
+                        maxParallelTasks: 3
+                    });
+                    // add all the results
+                    util.pushArrayItemsIntoArray(synchronizedEntityResults, replicaTaskResults.results.map((x) => x[1]));
+                    // compute final result
+                    result = {
+                        synchronizedEntityResults
+                    };
+                }
+                return result;
+            }
+            const result = await performSynchronizationOfSources({ });
+            return {
+                targetPair: syncEntityCommonTypeIdPair,
+                entitiesSynchronized: result.synchronizedEntityResults
+            };
+        };
+        const instance = {
+            entityPair: syncEntityCommonTypeIdPair,
+            synchronize
+        };
+        return instance;
+    };
+    const result = {
+        commonType,
+        synchronizeInstance
+    };
+    return result;
+}
 
-var objectGetOwnPropertyDescriptor = {};
+// MARK: String
+function transformStringToBoolean(defaultValue) {
+    return (params) => util.stringToBoolean(params.value, defaultValue);
+}
+// MARK: Comma Separated Values
+function transformCommaSeparatedValueToArray(mapFn) {
+    return (params) => {
+        let result;
+        if (params.value) {
+            if (Array.isArray(params.value)) {
+                result = params.value;
+            }
+            else {
+                result = util.splitCommaSeparatedString(params.value, mapFn);
+            }
+        }
+        return result;
+    };
+}
+const transformCommaSeparatedNumberValueToArray = transformCommaSeparatedValueToArray((x) => Number(x));
+const transformCommaSeparatedStringValueToArray = transformCommaSeparatedValueToArray((x) => x);
 
-var fails$b = function (exec) {
-  try {
-    return !!exec();
-  } catch (error) {
-    return true;
-  }
-};
+// MARK: Transform Annotations
+function TransformCommaSeparatedValueToArray(mapFn) {
+    return classTransformer.Transform(transformCommaSeparatedValueToArray(mapFn));
+}
+const TransformCommaSeparatedStringValueToArray = () => classTransformer.Transform(transformCommaSeparatedStringValueToArray);
+const TransformCommaSeparatedNumberValueToArray = () => classTransformer.Transform(transformCommaSeparatedNumberValueToArray);
+const TransformStringValueToBoolean = () => classTransformer.Transform(transformStringToBoolean());
 
-var fails$a = fails$b;
+function transformAndValidateObject(config) {
+    const transformToResult = transformAndValidateObjectResult(config);
+    const { handleValidationError } = config;
+    return (input, context) => transformToResult(input, context).then(async (x) => {
+        const object = x.object;
+        let result;
+        if (x.success) {
+            result = x.result;
+        }
+        else {
+            result = await handleValidationError(x.validationErrors);
+        }
+        return {
+            object,
+            result
+        };
+    });
+}
+/**
+ * Creates a new TransformAndValidateObjectFactory.
+ *
+ * @param defaults
+ * @returns
+ */
+function transformAndValidateObjectFactory(defaults) {
+    const { handleValidationError: defaultHandleValidationError, optionsForContext, defaultValidationOptions } = defaults;
+    return (classType, fn, handleValidationError) => {
+        const config = {
+            classType,
+            fn,
+            handleValidationError: handleValidationError ?? defaultHandleValidationError,
+            optionsForContext,
+            defaultValidationOptions
+        };
+        return transformAndValidateObject(config);
+    };
+}
+/**
+ * Factory function that wraps the input class type and handler function to first transform the input object to a the given class, and then validate it.
+ *
+ * @param classType
+ * @param fn
+ * @returns
+ */
+function transformAndValidateObjectResult(config) {
+    const { defaultValidationOptions, classType, fn, optionsForContext: inputOptionsForContext } = config;
+    const optionsForContext = inputOptionsForContext ?? (() => ({}));
+    return async (input, context) => {
+        const { transform: transformOptions, validate: validateOptions } = optionsForContext(context);
+        const object = classTransformer.plainToInstance(classType, input, {
+            ...transformOptions,
+            // Note: Each variable on the target class must be marked with the @Expose() annotation.
+            excludeExtraneousValues: true
+        });
+        const validationErrors = await classValidator.validate(object, {
+            forbidUnknownValues: false, // allow classes without annotations by default
+            ...defaultValidationOptions,
+            ...validateOptions
+        });
+        if (validationErrors.length) {
+            return { object, validationErrors, success: false };
+        }
+        else {
+            const result = await fn(object);
+            return { object, result, success: true };
+        }
+    };
+}
 
-// Detect IE8's incomplete defineProperty implementation
-var descriptors = !fails$a(function () {
-  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
-  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
-});
+function transformAndValidateFunctionResultFactory(defaults) {
+    return toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory(defaults));
+}
+function toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory) {
+    return (classType, fn, handleValidationError) => {
+        const transformAndValidateObjectFn = transformAndValidateObjectFactory(classType, fn, handleValidationError);
+        return (input, context) => {
+            return toTransformAndValidateFunctionResult(transformAndValidateObjectFn(input, context));
+        };
+    };
+}
+function toTransformAndValidateFunctionResult(objectOutput) {
+    return util.mapPromiseOrValue(objectOutput, (x) => {
+        const { object, result } = x;
+        const fnResult = result;
+        fnResult.params = object;
+        return fnResult;
+    });
+}
 
-var fails$9 = fails$b;
+function transformAndValidateResultFactory(defaults) {
+    const factory = transformAndValidateObjectFactory(defaults);
+    return (classType, fn, handleValidationError) => {
+        const transformAndValidateObjectFn = factory(classType, fn, handleValidationError);
+        return async (input, context) => {
+            const { result } = await transformAndValidateObjectFn(input, context);
+            return result;
+        };
+    };
+}
 
-var functionBindNative = !fails$9(function () {
-  // eslint-disable-next-line es/no-function-prototype-bind -- safe
-  var test = (function () { /* empty */ }).bind();
-  // eslint-disable-next-line no-prototype-builtins -- safe
-  return typeof test != 'function' || test.hasOwnProperty('prototype');
-});
+/**
+ * isISO8601DayString validator
+ */
+function IsISO8601DayString(validationOptions) {
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isISO8601DayString',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isISO8601DayString,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a ISO8601DayString.`, validationOptions)
+            }
+        });
+    };
+}
 
-var NATIVE_BIND$1 = functionBindNative;
+/**
+ * isMinuteOfDay validator
+ */
+function IsMinuteOfDay(validationOptions) {
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isMinuteOfDay',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isMinuteOfDay,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid minute of the day.`, validationOptions)
+            }
+        });
+    };
+}
 
-var call$7 = Function.prototype.call;
+/**
+ * isE164PhoneNumber validator that does not allowed extensions.
+ */
+function IsE164PhoneNumber(validationOptions) {
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isE164PhoneNumber',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: (x) => util.isE164PhoneNumber(x, false),
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumber with no extension.`, validationOptions)
+            }
+        });
+    };
+}
+/**
+ * isE164PhoneNumber validator that allows extensions.
+ *
+ * @param validationOptions
+ * @returns
+ */
+function IsE164PhoneNumberWithOptionalExtension(validationOptions) {
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isE164PhoneNumber',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: (x) => util.isE164PhoneNumber(x, true),
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not an E164PhoneNumber or has an invalid extension.`, validationOptions)
+            }
+        });
+    };
+}
+/**
+ * isE164PhoneNumberWithExtension validator
+ *
+ * @param validationOptions
+ * @returns
+ */
+function IsE164PhoneNumberWithExtension(validationOptions) {
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isE164PhoneNumberWithExtension',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isE164PhoneNumberWithExtension,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumberWithExtension.`, validationOptions)
+            }
+        });
+    };
+}
 
-var functionCall = NATIVE_BIND$1 ? call$7.bind(call$7) : function () {
-  return call$7.apply(call$7, arguments);
-};
+/**
+ * isUniqueKeyedFunction validator
+ */
+function IsUniqueKeyed(readKey, validationOptions) {
+    const isUniqueKeyed = util.isUniqueKeyedFunction(readKey);
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isUniqueKeyed',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: isUniqueKeyed,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value has one or more values with the same key. Keys must be unique.`, validationOptions)
+            }
+        });
+    };
+}
 
-var objectPropertyIsEnumerable = {};
-
-var $propertyIsEnumerable = {}.propertyIsEnumerable;
-// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
-
-// Nashorn ~ JDK8 bug
-var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
-
-// `Object.prototype.propertyIsEnumerable` method implementation
-// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
-objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
-  var descriptor = getOwnPropertyDescriptor$1(this, V);
-  return !!descriptor && descriptor.enumerable;
-} : $propertyIsEnumerable;
-
-var createPropertyDescriptor$3 = function (bitmap, value) {
-  return {
-    enumerable: !(bitmap & 1),
-    configurable: !(bitmap & 2),
-    writable: !(bitmap & 4),
-    value: value
-  };
-};
-
-var NATIVE_BIND = functionBindNative;
-
-var FunctionPrototype$1 = Function.prototype;
-var call$6 = FunctionPrototype$1.call;
-var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype$1.bind.bind(call$6, call$6);
-
-var functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
-  return function () {
-    return call$6.apply(fn, arguments);
-  };
-};
-
-var uncurryThis$8 = functionUncurryThis;
-
-var toString$1 = uncurryThis$8({}.toString);
-var stringSlice$1 = uncurryThis$8(''.slice);
-
-var classofRaw = function (it) {
-  return stringSlice$1(toString$1(it), 8, -1);
-};
-
-var uncurryThis$7 = functionUncurryThis;
-var fails$8 = fails$b;
-var classof = classofRaw;
-
-var $Object$3 = Object;
-var split = uncurryThis$7(''.split);
-
-// fallback for non-array-like ES3 and non-enumerable old V8 strings
-var indexedObject = fails$8(function () {
-  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
-  // eslint-disable-next-line no-prototype-builtins -- safe
-  return !$Object$3('z').propertyIsEnumerable(0);
-}) ? function (it) {
-  return classof(it) === 'String' ? split(it, '') : $Object$3(it);
-} : $Object$3;
-
-// we can't use just `it == null` since of `document.all` special case
-// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
-var isNullOrUndefined$2 = function (it) {
-  return it === null || it === undefined;
-};
-
-var isNullOrUndefined$1 = isNullOrUndefined$2;
-
-var $TypeError$7 = TypeError;
-
-// `RequireObjectCoercible` abstract operation
-// https://tc39.es/ecma262/#sec-requireobjectcoercible
-var requireObjectCoercible$2 = function (it) {
-  if (isNullOrUndefined$1(it)) throw new $TypeError$7("Can't call method on " + it);
-  return it;
-};
-
-// toObject with fallback for non-array-like ES3 strings
-var IndexedObject = indexedObject;
-var requireObjectCoercible$1 = requireObjectCoercible$2;
-
-var toIndexedObject$4 = function (it) {
-  return IndexedObject(requireObjectCoercible$1(it));
-};
-
-// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
-var documentAll = typeof document == 'object' && document.all;
-
-// `IsCallable` abstract operation
-// https://tc39.es/ecma262/#sec-iscallable
-// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
-var isCallable$d = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
-  return typeof argument == 'function' || argument === documentAll;
-} : function (argument) {
-  return typeof argument == 'function';
-};
-
-var isCallable$c = isCallable$d;
-
-var isObject$6 = function (it) {
-  return typeof it == 'object' ? it !== null : isCallable$c(it);
-};
-
-var global$a = global$b;
-var isCallable$b = isCallable$d;
-
-var aFunction = function (argument) {
-  return isCallable$b(argument) ? argument : undefined;
-};
-
-var getBuiltIn$3 = function (namespace, method) {
-  return arguments.length < 2 ? aFunction(global$a[namespace]) : global$a[namespace] && global$a[namespace][method];
-};
-
-var uncurryThis$6 = functionUncurryThis;
-
-var objectIsPrototypeOf = uncurryThis$6({}.isPrototypeOf);
-
-var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
-
-var global$9 = global$b;
-var userAgent = engineUserAgent;
-
-var process = global$9.process;
-var Deno = global$9.Deno;
-var versions = process && process.versions || Deno && Deno.version;
-var v8 = versions && versions.v8;
-var match, version;
-
-if (v8) {
-  match = v8.split('.');
-  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
-  // but their correct versions are not interesting for us
-  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
-}
-
-// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
-// so check `userAgent` even if `.v8` exists, but 0
-if (!version && userAgent) {
-  match = userAgent.match(/Edge\/(\d+)/);
-  if (!match || match[1] >= 74) {
-    match = userAgent.match(/Chrome\/(\d+)/);
-    if (match) version = +match[1];
-  }
-}
-
-var engineV8Version = version;
-
-/* eslint-disable es/no-symbol -- required for testing */
-var V8_VERSION = engineV8Version;
-var fails$7 = fails$b;
-var global$8 = global$b;
-
-var $String$3 = global$8.String;
-
-// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
-var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$7(function () {
-  var symbol = Symbol('symbol detection');
-  // Chrome 38 Symbol has incorrect toString conversion
-  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
-  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
-  // of course, fail.
-  return !$String$3(symbol) || !(Object(symbol) instanceof Symbol) ||
-    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
-    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
-});
-
-/* eslint-disable es/no-symbol -- required for testing */
-var NATIVE_SYMBOL$1 = symbolConstructorDetection;
-
-var useSymbolAsUid = NATIVE_SYMBOL$1
-  && !Symbol.sham
-  && typeof Symbol.iterator == 'symbol';
-
-var getBuiltIn$2 = getBuiltIn$3;
-var isCallable$a = isCallable$d;
-var isPrototypeOf$1 = objectIsPrototypeOf;
-var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
-
-var $Object$2 = Object;
-
-var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
-  return typeof it == 'symbol';
-} : function (it) {
-  var $Symbol = getBuiltIn$2('Symbol');
-  return isCallable$a($Symbol) && isPrototypeOf$1($Symbol.prototype, $Object$2(it));
-};
-
-var $String$2 = String;
-
-var tryToString$1 = function (argument) {
-  try {
-    return $String$2(argument);
-  } catch (error) {
-    return 'Object';
-  }
-};
-
-var isCallable$9 = isCallable$d;
-var tryToString = tryToString$1;
-
-var $TypeError$6 = TypeError;
-
-// `Assert: IsCallable(argument) is true`
-var aCallable$2 = function (argument) {
-  if (isCallable$9(argument)) return argument;
-  throw new $TypeError$6(tryToString(argument) + ' is not a function');
-};
-
-var aCallable$1 = aCallable$2;
-var isNullOrUndefined = isNullOrUndefined$2;
-
-// `GetMethod` abstract operation
-// https://tc39.es/ecma262/#sec-getmethod
-var getMethod$3 = function (V, P) {
-  var func = V[P];
-  return isNullOrUndefined(func) ? undefined : aCallable$1(func);
-};
-
-var call$5 = functionCall;
-var isCallable$8 = isCallable$d;
-var isObject$5 = isObject$6;
-
-var $TypeError$5 = TypeError;
-
-// `OrdinaryToPrimitive` abstract operation
-// https://tc39.es/ecma262/#sec-ordinarytoprimitive
-var ordinaryToPrimitive$1 = function (input, pref) {
-  var fn, val;
-  if (pref === 'string' && isCallable$8(fn = input.toString) && !isObject$5(val = call$5(fn, input))) return val;
-  if (isCallable$8(fn = input.valueOf) && !isObject$5(val = call$5(fn, input))) return val;
-  if (pref !== 'string' && isCallable$8(fn = input.toString) && !isObject$5(val = call$5(fn, input))) return val;
-  throw new $TypeError$5("Can't convert object to primitive value");
-};
-
-var sharedStore = {exports: {}};
-
-var isPure = false;
-
-var global$7 = global$b;
-
-// eslint-disable-next-line es/no-object-defineproperty -- safe
-var defineProperty$2 = Object.defineProperty;
-
-var defineGlobalProperty$3 = function (key, value) {
-  try {
-    defineProperty$2(global$7, key, { value: value, configurable: true, writable: true });
-  } catch (error) {
-    global$7[key] = value;
-  } return value;
-};
-
-var globalThis$1 = global$b;
-var defineGlobalProperty$2 = defineGlobalProperty$3;
-
-var SHARED = '__core-js_shared__';
-var store$3 = sharedStore.exports = globalThis$1[SHARED] || defineGlobalProperty$2(SHARED, {});
-
-(store$3.versions || (store$3.versions = [])).push({
-  version: '3.36.1',
-  mode: 'global',
-  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
-  license: 'https://github.com/zloirock/core-js/blob/v3.36.1/LICENSE',
-  source: 'https://github.com/zloirock/core-js'
-});
-
-var sharedStoreExports = sharedStore.exports;
-
-var store$2 = sharedStoreExports;
-
-var shared$3 = function (key, value) {
-  return store$2[key] || (store$2[key] = value || {});
-};
-
-var requireObjectCoercible = requireObjectCoercible$2;
-
-var $Object$1 = Object;
-
-// `ToObject` abstract operation
-// https://tc39.es/ecma262/#sec-toobject
-var toObject$2 = function (argument) {
-  return $Object$1(requireObjectCoercible(argument));
-};
-
-var uncurryThis$5 = functionUncurryThis;
-var toObject$1 = toObject$2;
-
-var hasOwnProperty = uncurryThis$5({}.hasOwnProperty);
-
-// `HasOwnProperty` abstract operation
-// https://tc39.es/ecma262/#sec-hasownproperty
-// eslint-disable-next-line es/no-object-hasown -- safe
-var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
-  return hasOwnProperty(toObject$1(it), key);
-};
-
-var uncurryThis$4 = functionUncurryThis;
-
-var id = 0;
-var postfix = Math.random();
-var toString = uncurryThis$4(1.0.toString);
-
-var uid$2 = function (key) {
-  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
-};
-
-var global$6 = global$b;
-var shared$2 = shared$3;
-var hasOwn$8 = hasOwnProperty_1;
-var uid$1 = uid$2;
-var NATIVE_SYMBOL = symbolConstructorDetection;
-var USE_SYMBOL_AS_UID = useSymbolAsUid;
-
-var Symbol$1 = global$6.Symbol;
-var WellKnownSymbolsStore = shared$2('wks');
-var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
-
-var wellKnownSymbol$4 = function (name) {
-  if (!hasOwn$8(WellKnownSymbolsStore, name)) {
-    WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$8(Symbol$1, name)
-      ? Symbol$1[name]
-      : createWellKnownSymbol('Symbol.' + name);
-  } return WellKnownSymbolsStore[name];
-};
-
-var call$4 = functionCall;
-var isObject$4 = isObject$6;
-var isSymbol$1 = isSymbol$2;
-var getMethod$2 = getMethod$3;
-var ordinaryToPrimitive = ordinaryToPrimitive$1;
-var wellKnownSymbol$3 = wellKnownSymbol$4;
-
-var $TypeError$4 = TypeError;
-var TO_PRIMITIVE = wellKnownSymbol$3('toPrimitive');
-
-// `ToPrimitive` abstract operation
-// https://tc39.es/ecma262/#sec-toprimitive
-var toPrimitive$1 = function (input, pref) {
-  if (!isObject$4(input) || isSymbol$1(input)) return input;
-  var exoticToPrim = getMethod$2(input, TO_PRIMITIVE);
-  var result;
-  if (exoticToPrim) {
-    if (pref === undefined) pref = 'default';
-    result = call$4(exoticToPrim, input, pref);
-    if (!isObject$4(result) || isSymbol$1(result)) return result;
-    throw new $TypeError$4("Can't convert object to primitive value");
-  }
-  if (pref === undefined) pref = 'number';
-  return ordinaryToPrimitive(input, pref);
-};
-
-var toPrimitive = toPrimitive$1;
-var isSymbol = isSymbol$2;
-
-// `ToPropertyKey` abstract operation
-// https://tc39.es/ecma262/#sec-topropertykey
-var toPropertyKey$2 = function (argument) {
-  var key = toPrimitive(argument, 'string');
-  return isSymbol(key) ? key : key + '';
-};
-
-var global$5 = global$b;
-var isObject$3 = isObject$6;
-
-var document$1 = global$5.document;
-// typeof document.createElement is 'object' in old IE
-var EXISTS$1 = isObject$3(document$1) && isObject$3(document$1.createElement);
-
-var documentCreateElement$1 = function (it) {
-  return EXISTS$1 ? document$1.createElement(it) : {};
-};
-
-var DESCRIPTORS$9 = descriptors;
-var fails$6 = fails$b;
-var createElement = documentCreateElement$1;
-
-// Thanks to IE8 for its funny defineProperty
-var ie8DomDefine = !DESCRIPTORS$9 && !fails$6(function () {
-  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
-  return Object.defineProperty(createElement('div'), 'a', {
-    get: function () { return 7; }
-  }).a !== 7;
-});
-
-var DESCRIPTORS$8 = descriptors;
-var call$3 = functionCall;
-var propertyIsEnumerableModule = objectPropertyIsEnumerable;
-var createPropertyDescriptor$2 = createPropertyDescriptor$3;
-var toIndexedObject$3 = toIndexedObject$4;
-var toPropertyKey$1 = toPropertyKey$2;
-var hasOwn$7 = hasOwnProperty_1;
-var IE8_DOM_DEFINE$1 = ie8DomDefine;
-
-// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
-
-// `Object.getOwnPropertyDescriptor` method
-// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
-objectGetOwnPropertyDescriptor.f = DESCRIPTORS$8 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
-  O = toIndexedObject$3(O);
-  P = toPropertyKey$1(P);
-  if (IE8_DOM_DEFINE$1) try {
-    return $getOwnPropertyDescriptor$1(O, P);
-  } catch (error) { /* empty */ }
-  if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$3(propertyIsEnumerableModule.f, O, P), O[P]);
-};
-
-var objectDefineProperty = {};
-
-var DESCRIPTORS$7 = descriptors;
-var fails$5 = fails$b;
-
-// V8 ~ Chrome 36-
-// https://bugs.chromium.org/p/v8/issues/detail?id=3334
-var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$5(function () {
-  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
-  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
-    value: 42,
-    writable: false
-  }).prototype !== 42;
-});
-
-var isObject$2 = isObject$6;
-
-var $String$1 = String;
-var $TypeError$3 = TypeError;
-
-// `Assert: Type(argument) is Object`
-var anObject$8 = function (argument) {
-  if (isObject$2(argument)) return argument;
-  throw new $TypeError$3($String$1(argument) + ' is not an object');
-};
-
-var DESCRIPTORS$6 = descriptors;
-var IE8_DOM_DEFINE = ie8DomDefine;
-var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
-var anObject$7 = anObject$8;
-var toPropertyKey = toPropertyKey$2;
-
-var $TypeError$2 = TypeError;
-// eslint-disable-next-line es/no-object-defineproperty -- safe
-var $defineProperty = Object.defineProperty;
-// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-var ENUMERABLE = 'enumerable';
-var CONFIGURABLE$1 = 'configurable';
-var WRITABLE = 'writable';
-
-// `Object.defineProperty` method
-// https://tc39.es/ecma262/#sec-object.defineproperty
-objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
-  anObject$7(O);
-  P = toPropertyKey(P);
-  anObject$7(Attributes);
-  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
-    var current = $getOwnPropertyDescriptor(O, P);
-    if (current && current[WRITABLE]) {
-      O[P] = Attributes.value;
-      Attributes = {
-        configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
-        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
-        writable: false
-      };
-    }
-  } return $defineProperty(O, P, Attributes);
-} : $defineProperty : function defineProperty(O, P, Attributes) {
-  anObject$7(O);
-  P = toPropertyKey(P);
-  anObject$7(Attributes);
-  if (IE8_DOM_DEFINE) try {
-    return $defineProperty(O, P, Attributes);
-  } catch (error) { /* empty */ }
-  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$2('Accessors not supported');
-  if ('value' in Attributes) O[P] = Attributes.value;
-  return O;
-};
-
-var DESCRIPTORS$5 = descriptors;
-var definePropertyModule$4 = objectDefineProperty;
-var createPropertyDescriptor$1 = createPropertyDescriptor$3;
-
-var createNonEnumerableProperty$3 = DESCRIPTORS$5 ? function (object, key, value) {
-  return definePropertyModule$4.f(object, key, createPropertyDescriptor$1(1, value));
-} : function (object, key, value) {
-  object[key] = value;
-  return object;
-};
-
-var makeBuiltIn$3 = {exports: {}};
-
-var DESCRIPTORS$4 = descriptors;
-var hasOwn$6 = hasOwnProperty_1;
-
-var FunctionPrototype = Function.prototype;
-// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-var getDescriptor = DESCRIPTORS$4 && Object.getOwnPropertyDescriptor;
-
-var EXISTS = hasOwn$6(FunctionPrototype, 'name');
-// additional protection from minified / mangled / dropped function names
-var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
-var CONFIGURABLE = EXISTS && (!DESCRIPTORS$4 || (DESCRIPTORS$4 && getDescriptor(FunctionPrototype, 'name').configurable));
-
-var functionName = {
-  EXISTS: EXISTS,
-  PROPER: PROPER,
-  CONFIGURABLE: CONFIGURABLE
-};
-
-var uncurryThis$3 = functionUncurryThis;
-var isCallable$7 = isCallable$d;
-var store$1 = sharedStoreExports;
-
-var functionToString = uncurryThis$3(Function.toString);
-
-// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
-if (!isCallable$7(store$1.inspectSource)) {
-  store$1.inspectSource = function (it) {
-    return functionToString(it);
-  };
-}
-
-var inspectSource$1 = store$1.inspectSource;
-
-var global$4 = global$b;
-var isCallable$6 = isCallable$d;
-
-var WeakMap$1 = global$4.WeakMap;
-
-var weakMapBasicDetection = isCallable$6(WeakMap$1) && /native code/.test(String(WeakMap$1));
-
-var shared$1 = shared$3;
-var uid = uid$2;
-
-var keys = shared$1('keys');
-
-var sharedKey$3 = function (key) {
-  return keys[key] || (keys[key] = uid(key));
-};
-
-var hiddenKeys$4 = {};
-
-var NATIVE_WEAK_MAP = weakMapBasicDetection;
-var global$3 = global$b;
-var isObject$1 = isObject$6;
-var createNonEnumerableProperty$2 = createNonEnumerableProperty$3;
-var hasOwn$5 = hasOwnProperty_1;
-var shared = sharedStoreExports;
-var sharedKey$2 = sharedKey$3;
-var hiddenKeys$3 = hiddenKeys$4;
-
-var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
-var TypeError$1 = global$3.TypeError;
-var WeakMap = global$3.WeakMap;
-var set, get, has;
-
-var enforce = function (it) {
-  return has(it) ? get(it) : set(it, {});
-};
-
-var getterFor = function (TYPE) {
-  return function (it) {
-    var state;
-    if (!isObject$1(it) || (state = get(it)).type !== TYPE) {
-      throw new TypeError$1('Incompatible receiver, ' + TYPE + ' required');
-    } return state;
-  };
-};
-
-if (NATIVE_WEAK_MAP || shared.state) {
-  var store = shared.state || (shared.state = new WeakMap());
-  /* eslint-disable no-self-assign -- prototype methods protection */
-  store.get = store.get;
-  store.has = store.has;
-  store.set = store.set;
-  /* eslint-enable no-self-assign -- prototype methods protection */
-  set = function (it, metadata) {
-    if (store.has(it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
-    metadata.facade = it;
-    store.set(it, metadata);
-    return metadata;
-  };
-  get = function (it) {
-    return store.get(it) || {};
-  };
-  has = function (it) {
-    return store.has(it);
-  };
-} else {
-  var STATE = sharedKey$2('state');
-  hiddenKeys$3[STATE] = true;
-  set = function (it, metadata) {
-    if (hasOwn$5(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
-    metadata.facade = it;
-    createNonEnumerableProperty$2(it, STATE, metadata);
-    return metadata;
-  };
-  get = function (it) {
-    return hasOwn$5(it, STATE) ? it[STATE] : {};
-  };
-  has = function (it) {
-    return hasOwn$5(it, STATE);
-  };
-}
-
-var internalState = {
-  set: set,
-  get: get,
-  has: has,
-  enforce: enforce,
-  getterFor: getterFor
-};
-
-var uncurryThis$2 = functionUncurryThis;
-var fails$4 = fails$b;
-var isCallable$5 = isCallable$d;
-var hasOwn$4 = hasOwnProperty_1;
-var DESCRIPTORS$3 = descriptors;
-var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
-var inspectSource = inspectSource$1;
-var InternalStateModule$1 = internalState;
-
-var enforceInternalState = InternalStateModule$1.enforce;
-var getInternalState = InternalStateModule$1.get;
-var $String = String;
-// eslint-disable-next-line es/no-object-defineproperty -- safe
-var defineProperty$1 = Object.defineProperty;
-var stringSlice = uncurryThis$2(''.slice);
-var replace = uncurryThis$2(''.replace);
-var join = uncurryThis$2([].join);
-
-var CONFIGURABLE_LENGTH = DESCRIPTORS$3 && !fails$4(function () {
-  return defineProperty$1(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
-});
-
-var TEMPLATE = String(String).split('String');
-
-var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
-  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
-    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
-  }
-  if (options && options.getter) name = 'get ' + name;
-  if (options && options.setter) name = 'set ' + name;
-  if (!hasOwn$4(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
-    if (DESCRIPTORS$3) defineProperty$1(value, 'name', { value: name, configurable: true });
-    else value.name = name;
-  }
-  if (CONFIGURABLE_LENGTH && options && hasOwn$4(options, 'arity') && value.length !== options.arity) {
-    defineProperty$1(value, 'length', { value: options.arity });
-  }
-  try {
-    if (options && hasOwn$4(options, 'constructor') && options.constructor) {
-      if (DESCRIPTORS$3) defineProperty$1(value, 'prototype', { writable: false });
-    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
-    } else if (value.prototype) value.prototype = undefined;
-  } catch (error) { /* empty */ }
-  var state = enforceInternalState(value);
-  if (!hasOwn$4(state, 'source')) {
-    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
-  } return value;
-};
-
-// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
-// eslint-disable-next-line no-extend-native -- required
-Function.prototype.toString = makeBuiltIn$2(function toString() {
-  return isCallable$5(this) && getInternalState(this).source || inspectSource(this);
-}, 'toString');
-
-var makeBuiltInExports = makeBuiltIn$3.exports;
-
-var isCallable$4 = isCallable$d;
-var definePropertyModule$3 = objectDefineProperty;
-var makeBuiltIn$1 = makeBuiltInExports;
-var defineGlobalProperty$1 = defineGlobalProperty$3;
-
-var defineBuiltIn$3 = function (O, key, value, options) {
-  if (!options) options = {};
-  var simple = options.enumerable;
-  var name = options.name !== undefined ? options.name : key;
-  if (isCallable$4(value)) makeBuiltIn$1(value, name, options);
-  if (options.global) {
-    if (simple) O[key] = value;
-    else defineGlobalProperty$1(key, value);
-  } else {
-    try {
-      if (!options.unsafe) delete O[key];
-      else if (O[key]) simple = true;
-    } catch (error) { /* empty */ }
-    if (simple) O[key] = value;
-    else definePropertyModule$3.f(O, key, {
-      value: value,
-      enumerable: false,
-      configurable: !options.nonConfigurable,
-      writable: !options.nonWritable
-    });
-  } return O;
-};
-
-var objectGetOwnPropertyNames = {};
-
-var ceil = Math.ceil;
-var floor = Math.floor;
-
-// `Math.trunc` method
-// https://tc39.es/ecma262/#sec-math.trunc
-// eslint-disable-next-line es/no-math-trunc -- safe
-var mathTrunc = Math.trunc || function trunc(x) {
-  var n = +x;
-  return (n > 0 ? floor : ceil)(n);
-};
-
-var trunc = mathTrunc;
-
-// `ToIntegerOrInfinity` abstract operation
-// https://tc39.es/ecma262/#sec-tointegerorinfinity
-var toIntegerOrInfinity$2 = function (argument) {
-  var number = +argument;
-  // eslint-disable-next-line no-self-compare -- NaN check
-  return number !== number || number === 0 ? 0 : trunc(number);
-};
-
-var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
-
-var max = Math.max;
-var min$1 = Math.min;
-
-// Helper for a popular repeating case of the spec:
-// Let integer be ? ToInteger(index).
-// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
-var toAbsoluteIndex$1 = function (index, length) {
-  var integer = toIntegerOrInfinity$1(index);
-  return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
-};
-
-var toIntegerOrInfinity = toIntegerOrInfinity$2;
-
-var min = Math.min;
-
-// `ToLength` abstract operation
-// https://tc39.es/ecma262/#sec-tolength
-var toLength$1 = function (argument) {
-  var len = toIntegerOrInfinity(argument);
-  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
-};
-
-var toLength = toLength$1;
-
-// `LengthOfArrayLike` abstract operation
-// https://tc39.es/ecma262/#sec-lengthofarraylike
-var lengthOfArrayLike$1 = function (obj) {
-  return toLength(obj.length);
-};
-
-var toIndexedObject$2 = toIndexedObject$4;
-var toAbsoluteIndex = toAbsoluteIndex$1;
-var lengthOfArrayLike = lengthOfArrayLike$1;
-
-// `Array.prototype.{ indexOf, includes }` methods implementation
-var createMethod = function (IS_INCLUDES) {
-  return function ($this, el, fromIndex) {
-    var O = toIndexedObject$2($this);
-    var length = lengthOfArrayLike(O);
-    if (length === 0) return !IS_INCLUDES && -1;
-    var index = toAbsoluteIndex(fromIndex, length);
-    var value;
-    // Array#includes uses SameValueZero equality algorithm
-    // eslint-disable-next-line no-self-compare -- NaN check
-    if (IS_INCLUDES && el !== el) while (length > index) {
-      value = O[index++];
-      // eslint-disable-next-line no-self-compare -- NaN check
-      if (value !== value) return true;
-    // Array#indexOf ignores holes, Array#includes - not
-    } else for (;length > index; index++) {
-      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
-    } return !IS_INCLUDES && -1;
-  };
-};
-
-var arrayIncludes = {
-  // `Array.prototype.includes` method
-  // https://tc39.es/ecma262/#sec-array.prototype.includes
-  includes: createMethod(true),
-  // `Array.prototype.indexOf` method
-  // https://tc39.es/ecma262/#sec-array.prototype.indexof
-  indexOf: createMethod(false)
-};
-
-var uncurryThis$1 = functionUncurryThis;
-var hasOwn$3 = hasOwnProperty_1;
-var toIndexedObject$1 = toIndexedObject$4;
-var indexOf = arrayIncludes.indexOf;
-var hiddenKeys$2 = hiddenKeys$4;
-
-var push = uncurryThis$1([].push);
-
-var objectKeysInternal = function (object, names) {
-  var O = toIndexedObject$1(object);
-  var i = 0;
-  var result = [];
-  var key;
-  for (key in O) !hasOwn$3(hiddenKeys$2, key) && hasOwn$3(O, key) && push(result, key);
-  // Don't enum bug & hidden keys
-  while (names.length > i) if (hasOwn$3(O, key = names[i++])) {
-    ~indexOf(result, key) || push(result, key);
-  }
-  return result;
-};
-
-// IE8- don't enum bug keys
-var enumBugKeys$3 = [
-  'constructor',
-  'hasOwnProperty',
-  'isPrototypeOf',
-  'propertyIsEnumerable',
-  'toLocaleString',
-  'toString',
-  'valueOf'
-];
-
-var internalObjectKeys$1 = objectKeysInternal;
-var enumBugKeys$2 = enumBugKeys$3;
-
-var hiddenKeys$1 = enumBugKeys$2.concat('length', 'prototype');
-
-// `Object.getOwnPropertyNames` method
-// https://tc39.es/ecma262/#sec-object.getownpropertynames
-// eslint-disable-next-line es/no-object-getownpropertynames -- safe
-objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
-  return internalObjectKeys$1(O, hiddenKeys$1);
-};
-
-var objectGetOwnPropertySymbols = {};
-
-// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
-objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
-
-var getBuiltIn$1 = getBuiltIn$3;
-var uncurryThis = functionUncurryThis;
-var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
-var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
-var anObject$6 = anObject$8;
-
-var concat = uncurryThis([].concat);
-
-// all object keys, includes non-enumerable and symbols
-var ownKeys$1 = getBuiltIn$1('Reflect', 'ownKeys') || function ownKeys(it) {
-  var keys = getOwnPropertyNamesModule.f(anObject$6(it));
-  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
-  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
-};
-
-var hasOwn$2 = hasOwnProperty_1;
-var ownKeys = ownKeys$1;
-var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
-var definePropertyModule$2 = objectDefineProperty;
-
-var copyConstructorProperties$1 = function (target, source, exceptions) {
-  var keys = ownKeys(source);
-  var defineProperty = definePropertyModule$2.f;
-  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i];
-    if (!hasOwn$2(target, key) && !(exceptions && hasOwn$2(exceptions, key))) {
-      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
-    }
-  }
-};
-
-var fails$3 = fails$b;
-var isCallable$3 = isCallable$d;
-
-var replacement = /#|\.prototype\./;
-
-var isForced$1 = function (feature, detection) {
-  var value = data[normalize(feature)];
-  return value === POLYFILL ? true
-    : value === NATIVE ? false
-    : isCallable$3(detection) ? fails$3(detection)
-    : !!detection;
-};
-
-var normalize = isForced$1.normalize = function (string) {
-  return String(string).replace(replacement, '.').toLowerCase();
-};
-
-var data = isForced$1.data = {};
-var NATIVE = isForced$1.NATIVE = 'N';
-var POLYFILL = isForced$1.POLYFILL = 'P';
-
-var isForced_1 = isForced$1;
-
-var global$2 = global$b;
-var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
-var createNonEnumerableProperty$1 = createNonEnumerableProperty$3;
-var defineBuiltIn$2 = defineBuiltIn$3;
-var defineGlobalProperty = defineGlobalProperty$3;
-var copyConstructorProperties = copyConstructorProperties$1;
-var isForced = isForced_1;
-
-/*
-  options.target         - name of the target object
-  options.global         - target is the global object
-  options.stat           - export as static methods of target
-  options.proto          - export as prototype methods of target
-  options.real           - real prototype method for the `pure` version
-  options.forced         - export even if the native feature is available
-  options.bind           - bind methods to the target, required for the `pure` version
-  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
-  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
-  options.sham           - add a flag to not completely full polyfills
-  options.enumerable     - export as enumerable property
-  options.dontCallGetSet - prevent calling a getter on target
-  options.name           - the .name of the function if it does not match the key
-*/
-var _export = function (options, source) {
-  var TARGET = options.target;
-  var GLOBAL = options.global;
-  var STATIC = options.stat;
-  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
-  if (GLOBAL) {
-    target = global$2;
-  } else if (STATIC) {
-    target = global$2[TARGET] || defineGlobalProperty(TARGET, {});
-  } else {
-    target = global$2[TARGET] && global$2[TARGET].prototype;
-  }
-  if (target) for (key in source) {
-    sourceProperty = source[key];
-    if (options.dontCallGetSet) {
-      descriptor = getOwnPropertyDescriptor(target, key);
-      targetProperty = descriptor && descriptor.value;
-    } else targetProperty = target[key];
-    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
-    // contained in target
-    if (!FORCED && targetProperty !== undefined) {
-      if (typeof sourceProperty == typeof targetProperty) continue;
-      copyConstructorProperties(sourceProperty, targetProperty);
-    }
-    // add a flag to not completely full polyfills
-    if (options.sham || (targetProperty && targetProperty.sham)) {
-      createNonEnumerableProperty$1(sourceProperty, 'sham', true);
-    }
-    defineBuiltIn$2(target, key, sourceProperty, options);
-  }
-};
-
-var isPrototypeOf = objectIsPrototypeOf;
-
-var $TypeError$1 = TypeError;
-
-var anInstance$1 = function (it, Prototype) {
-  if (isPrototypeOf(Prototype, it)) return it;
-  throw new $TypeError$1('Incorrect invocation');
-};
-
-var fails$2 = fails$b;
-
-var correctPrototypeGetter = !fails$2(function () {
-  function F() { /* empty */ }
-  F.prototype.constructor = null;
-  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
-  return Object.getPrototypeOf(new F()) !== F.prototype;
-});
-
-var hasOwn$1 = hasOwnProperty_1;
-var isCallable$2 = isCallable$d;
-var toObject = toObject$2;
-var sharedKey$1 = sharedKey$3;
-var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
-
-var IE_PROTO$1 = sharedKey$1('IE_PROTO');
-var $Object = Object;
-var ObjectPrototype = $Object.prototype;
-
-// `Object.getPrototypeOf` method
-// https://tc39.es/ecma262/#sec-object.getprototypeof
-// eslint-disable-next-line es/no-object-getprototypeof -- safe
-var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
-  var object = toObject(O);
-  if (hasOwn$1(object, IE_PROTO$1)) return object[IE_PROTO$1];
-  var constructor = object.constructor;
-  if (isCallable$2(constructor) && object instanceof constructor) {
-    return constructor.prototype;
-  } return object instanceof $Object ? ObjectPrototype : null;
-};
-
-var makeBuiltIn = makeBuiltInExports;
-var defineProperty = objectDefineProperty;
-
-var defineBuiltInAccessor$1 = function (target, name, descriptor) {
-  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
-  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
-  return defineProperty.f(target, name, descriptor);
-};
-
-var DESCRIPTORS$2 = descriptors;
-var definePropertyModule$1 = objectDefineProperty;
-var createPropertyDescriptor = createPropertyDescriptor$3;
-
-var createProperty$1 = function (object, key, value) {
-  if (DESCRIPTORS$2) definePropertyModule$1.f(object, key, createPropertyDescriptor(0, value));
-  else object[key] = value;
-};
-
-var objectDefineProperties = {};
-
-var internalObjectKeys = objectKeysInternal;
-var enumBugKeys$1 = enumBugKeys$3;
-
-// `Object.keys` method
-// https://tc39.es/ecma262/#sec-object.keys
-// eslint-disable-next-line es/no-object-keys -- safe
-var objectKeys$1 = Object.keys || function keys(O) {
-  return internalObjectKeys(O, enumBugKeys$1);
-};
-
-var DESCRIPTORS$1 = descriptors;
-var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
-var definePropertyModule = objectDefineProperty;
-var anObject$5 = anObject$8;
-var toIndexedObject = toIndexedObject$4;
-var objectKeys = objectKeys$1;
-
-// `Object.defineProperties` method
-// https://tc39.es/ecma262/#sec-object.defineproperties
-// eslint-disable-next-line es/no-object-defineproperties -- safe
-objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
-  anObject$5(O);
-  var props = toIndexedObject(Properties);
-  var keys = objectKeys(Properties);
-  var length = keys.length;
-  var index = 0;
-  var key;
-  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
-  return O;
-};
-
-var getBuiltIn = getBuiltIn$3;
-
-var html$1 = getBuiltIn('document', 'documentElement');
-
-/* global ActiveXObject -- old IE, WSH */
-var anObject$4 = anObject$8;
-var definePropertiesModule = objectDefineProperties;
-var enumBugKeys = enumBugKeys$3;
-var hiddenKeys = hiddenKeys$4;
-var html = html$1;
-var documentCreateElement = documentCreateElement$1;
-var sharedKey = sharedKey$3;
-
-var GT = '>';
-var LT = '<';
-var PROTOTYPE = 'prototype';
-var SCRIPT = 'script';
-var IE_PROTO = sharedKey('IE_PROTO');
-
-var EmptyConstructor = function () { /* empty */ };
-
-var scriptTag = function (content) {
-  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
-};
-
-// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
-var NullProtoObjectViaActiveX = function (activeXDocument) {
-  activeXDocument.write(scriptTag(''));
-  activeXDocument.close();
-  var temp = activeXDocument.parentWindow.Object;
-  activeXDocument = null; // avoid memory leak
-  return temp;
-};
-
-// Create object with fake `null` prototype: use iframe Object with cleared prototype
-var NullProtoObjectViaIFrame = function () {
-  // Thrash, waste and sodomy: IE GC bug
-  var iframe = documentCreateElement('iframe');
-  var JS = 'java' + SCRIPT + ':';
-  var iframeDocument;
-  iframe.style.display = 'none';
-  html.appendChild(iframe);
-  // https://github.com/zloirock/core-js/issues/475
-  iframe.src = String(JS);
-  iframeDocument = iframe.contentWindow.document;
-  iframeDocument.open();
-  iframeDocument.write(scriptTag('document.F=Object'));
-  iframeDocument.close();
-  return iframeDocument.F;
-};
-
-// Check for document.domain and active x support
-// No need to use active x approach when document.domain is not set
-// see https://github.com/es-shims/es5-shim/issues/150
-// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
-// avoid IE GC bug
-var activeXDocument;
-var NullProtoObject = function () {
-  try {
-    activeXDocument = new ActiveXObject('htmlfile');
-  } catch (error) { /* ignore */ }
-  NullProtoObject = typeof document != 'undefined'
-    ? document.domain && activeXDocument
-      ? NullProtoObjectViaActiveX(activeXDocument) // old IE
-      : NullProtoObjectViaIFrame()
-    : NullProtoObjectViaActiveX(activeXDocument); // WSH
-  var length = enumBugKeys.length;
-  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
-  return NullProtoObject();
-};
-
-hiddenKeys[IE_PROTO] = true;
-
-// `Object.create` method
-// https://tc39.es/ecma262/#sec-object.create
-// eslint-disable-next-line es/no-object-create -- safe
-var objectCreate = Object.create || function create(O, Properties) {
-  var result;
-  if (O !== null) {
-    EmptyConstructor[PROTOTYPE] = anObject$4(O);
-    result = new EmptyConstructor();
-    EmptyConstructor[PROTOTYPE] = null;
-    // add "__proto__" for Object.getPrototypeOf polyfill
-    result[IE_PROTO] = O;
-  } else result = NullProtoObject();
-  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
-};
-
-var fails$1 = fails$b;
-var isCallable$1 = isCallable$d;
-var isObject = isObject$6;
-var getPrototypeOf$1 = objectGetPrototypeOf;
-var defineBuiltIn$1 = defineBuiltIn$3;
-var wellKnownSymbol$2 = wellKnownSymbol$4;
-
-var ITERATOR$1 = wellKnownSymbol$2('iterator');
-var BUGGY_SAFARI_ITERATORS = false;
-
-// `%IteratorPrototype%` object
-// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
-var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator;
-
-/* eslint-disable es/no-array-prototype-keys -- safe */
-if ([].keys) {
-  arrayIterator = [].keys();
-  // Safari 8 has buggy iterators w/o `next`
-  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
-  else {
-    PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator));
-    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype;
-  }
-}
-
-var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype$2) || fails$1(function () {
-  var test = {};
-  // FF44- legacy iterators case
-  return IteratorPrototype$2[ITERATOR$1].call(test) !== test;
-});
-
-if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
-
-// `%IteratorPrototype%[@@iterator]()` method
-// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
-if (!isCallable$1(IteratorPrototype$2[ITERATOR$1])) {
-  defineBuiltIn$1(IteratorPrototype$2, ITERATOR$1, function () {
-    return this;
-  });
-}
-
-var iteratorsCore = {
-  IteratorPrototype: IteratorPrototype$2,
-  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
-};
-
-var $$1 = _export;
-var global$1 = global$b;
-var anInstance = anInstance$1;
-var anObject$3 = anObject$8;
-var isCallable = isCallable$d;
-var getPrototypeOf = objectGetPrototypeOf;
-var defineBuiltInAccessor = defineBuiltInAccessor$1;
-var createProperty = createProperty$1;
-var fails = fails$b;
-var hasOwn = hasOwnProperty_1;
-var wellKnownSymbol$1 = wellKnownSymbol$4;
-var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
-var DESCRIPTORS = descriptors;
-
-var CONSTRUCTOR = 'constructor';
-var ITERATOR = 'Iterator';
-var TO_STRING_TAG$1 = wellKnownSymbol$1('toStringTag');
-
-var $TypeError = TypeError;
-var NativeIterator = global$1[ITERATOR];
-
-// FF56- have non-standard global helper `Iterator`
-var FORCED = !isCallable(NativeIterator)
-  || NativeIterator.prototype !== IteratorPrototype$1
-  // FF44- non-standard `Iterator` passes previous tests
-  || !fails(function () { NativeIterator({}); });
-
-var IteratorConstructor = function Iterator() {
-  anInstance(this, IteratorPrototype$1);
-  if (getPrototypeOf(this) === IteratorPrototype$1) throw new $TypeError('Abstract class Iterator not directly constructable');
-};
-
-var defineIteratorPrototypeAccessor = function (key, value) {
-  if (DESCRIPTORS) {
-    defineBuiltInAccessor(IteratorPrototype$1, key, {
-      configurable: true,
-      get: function () {
-        return value;
-      },
-      set: function (replacement) {
-        anObject$3(this);
-        if (this === IteratorPrototype$1) throw new $TypeError("You can't redefine this property");
-        if (hasOwn(this, key)) this[key] = replacement;
-        else createProperty(this, key, replacement);
-      }
-    });
-  } else IteratorPrototype$1[key] = value;
-};
-
-if (!hasOwn(IteratorPrototype$1, TO_STRING_TAG$1)) defineIteratorPrototypeAccessor(TO_STRING_TAG$1, ITERATOR);
-
-if (FORCED || !hasOwn(IteratorPrototype$1, CONSTRUCTOR) || IteratorPrototype$1[CONSTRUCTOR] === Object) {
-  defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor);
-}
-
-IteratorConstructor.prototype = IteratorPrototype$1;
-
-// `Iterator` constructor
-// https://github.com/tc39/proposal-iterator-helpers
-$$1({ global: true, constructor: true, forced: FORCED }, {
-  Iterator: IteratorConstructor
-});
-
-// `GetIteratorDirect(obj)` abstract operation
-// https://tc39.es/proposal-iterator-helpers/#sec-getiteratordirect
-var getIteratorDirect$1 = function (obj) {
-  return {
-    iterator: obj,
-    next: obj.next,
-    done: false
-  };
-};
-
-var defineBuiltIn = defineBuiltIn$3;
-
-var defineBuiltIns$1 = function (target, src, options) {
-  for (var key in src) defineBuiltIn(target, key, src[key], options);
-  return target;
-};
-
-// `CreateIterResultObject` abstract operation
-// https://tc39.es/ecma262/#sec-createiterresultobject
-var createIterResultObject$1 = function (value, done) {
-  return { value: value, done: done };
-};
-
-var call$2 = functionCall;
-var anObject$2 = anObject$8;
-var getMethod$1 = getMethod$3;
-
-var iteratorClose$2 = function (iterator, kind, value) {
-  var innerResult, innerError;
-  anObject$2(iterator);
-  try {
-    innerResult = getMethod$1(iterator, 'return');
-    if (!innerResult) {
-      if (kind === 'throw') throw value;
-      return value;
-    }
-    innerResult = call$2(innerResult, iterator);
-  } catch (error) {
-    innerError = true;
-    innerResult = error;
-  }
-  if (kind === 'throw') throw value;
-  if (innerError) throw innerResult;
-  anObject$2(innerResult);
-  return value;
-};
-
-var call$1 = functionCall;
-var create = objectCreate;
-var createNonEnumerableProperty = createNonEnumerableProperty$3;
-var defineBuiltIns = defineBuiltIns$1;
-var wellKnownSymbol = wellKnownSymbol$4;
-var InternalStateModule = internalState;
-var getMethod = getMethod$3;
-var IteratorPrototype = iteratorsCore.IteratorPrototype;
-var createIterResultObject = createIterResultObject$1;
-var iteratorClose$1 = iteratorClose$2;
-
-var TO_STRING_TAG = wellKnownSymbol('toStringTag');
-var ITERATOR_HELPER = 'IteratorHelper';
-var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
-var setInternalState = InternalStateModule.set;
-
-var createIteratorProxyPrototype = function (IS_ITERATOR) {
-  var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
-
-  return defineBuiltIns(create(IteratorPrototype), {
-    next: function next() {
-      var state = getInternalState(this);
-      // for simplification:
-      //   for `%WrapForValidIteratorPrototype%.next` our `nextHandler` returns `IterResultObject`
-      //   for `%IteratorHelperPrototype%.next` - just a value
-      if (IS_ITERATOR) return state.nextHandler();
-      try {
-        var result = state.done ? undefined : state.nextHandler();
-        return createIterResultObject(result, state.done);
-      } catch (error) {
-        state.done = true;
-        throw error;
-      }
-    },
-    'return': function () {
-      var state = getInternalState(this);
-      var iterator = state.iterator;
-      state.done = true;
-      if (IS_ITERATOR) {
-        var returnMethod = getMethod(iterator, 'return');
-        return returnMethod ? call$1(returnMethod, iterator) : createIterResultObject(undefined, true);
-      }
-      if (state.inner) try {
-        iteratorClose$1(state.inner.iterator, 'normal');
-      } catch (error) {
-        return iteratorClose$1(iterator, 'throw', error);
-      }
-      iteratorClose$1(iterator, 'normal');
-      return createIterResultObject(undefined, true);
-    }
-  });
-};
-
-var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
-var IteratorHelperPrototype = createIteratorProxyPrototype(false);
-
-createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');
-
-var iteratorCreateProxy = function (nextHandler, IS_ITERATOR) {
-  var IteratorProxy = function Iterator(record, state) {
-    if (state) {
-      state.iterator = record.iterator;
-      state.next = record.next;
-    } else state = record;
-    state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
-    state.nextHandler = nextHandler;
-    state.counter = 0;
-    state.done = false;
-    setInternalState(this, state);
-  };
-
-  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
-
-  return IteratorProxy;
-};
-
-var anObject$1 = anObject$8;
-var iteratorClose = iteratorClose$2;
-
-// call something on iterator step with safe closing on error
-var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) {
-  try {
-    return ENTRIES ? fn(anObject$1(value)[0], value[1]) : fn(value);
-  } catch (error) {
-    iteratorClose(iterator, 'throw', error);
-  }
-};
-
-var call = functionCall;
-var aCallable = aCallable$2;
-var anObject = anObject$8;
-var getIteratorDirect = getIteratorDirect$1;
-var createIteratorProxy = iteratorCreateProxy;
-var callWithSafeIterationClosing = callWithSafeIterationClosing$1;
-
-var IteratorProxy = createIteratorProxy(function () {
-  var iterator = this.iterator;
-  var result = anObject(call(this.next, iterator));
-  var done = this.done = !!result.done;
-  if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true);
-});
-
-// `Iterator.prototype.map` method
-// https://github.com/tc39/proposal-iterator-helpers
-var iteratorMap = function map(mapper) {
-  anObject(this);
-  aCallable(mapper);
-  return new IteratorProxy(getIteratorDirect(this), {
-    mapper: mapper
-  });
-};
-
-var $ = _export;
-var map = iteratorMap;
-var IS_PURE = isPure;
-
-// `Iterator.prototype.map` method
-// https://github.com/tc39/proposal-iterator-helpers
-$({ target: 'Iterator', proto: true, real: true, forced: IS_PURE }, {
-  map: map
-});
-
-var makeError = {exports: {}};
-
-(function (module, exports) {
-
-	// ===================================================================
-
-	var construct = typeof Reflect !== "undefined" ? Reflect.construct : undefined;
-	var defineProperty = Object.defineProperty;
-
-	// -------------------------------------------------------------------
-
-	var captureStackTrace = Error.captureStackTrace;
-	if (captureStackTrace === undefined) {
-	  captureStackTrace = function captureStackTrace(error) {
-	    var container = new Error();
-
-	    defineProperty(error, "stack", {
-	      configurable: true,
-	      get: function getStack() {
-	        var stack = container.stack;
-
-	        // Replace property with value for faster future accesses.
-	        defineProperty(this, "stack", {
-	          configurable: true,
-	          value: stack,
-	          writable: true,
-	        });
-
-	        return stack;
-	      },
-	      set: function setStack(stack) {
-	        defineProperty(error, "stack", {
-	          configurable: true,
-	          value: stack,
-	          writable: true,
-	        });
-	      },
-	    });
-	  };
-	}
-
-	// -------------------------------------------------------------------
-
-	function BaseError(message) {
-	  if (message !== undefined) {
-	    defineProperty(this, "message", {
-	      configurable: true,
-	      value: message,
-	      writable: true,
-	    });
-	  }
-
-	  var cname = this.constructor.name;
-	  if (cname !== undefined && cname !== this.name) {
-	    defineProperty(this, "name", {
-	      configurable: true,
-	      value: cname,
-	      writable: true,
-	    });
-	  }
-
-	  captureStackTrace(this, this.constructor);
-	}
-
-	BaseError.prototype = Object.create(Error.prototype, {
-	  // See: https://github.com/JsCommunity/make-error/issues/4
-	  constructor: {
-	    configurable: true,
-	    value: BaseError,
-	    writable: true,
-	  },
-	});
-
-	// -------------------------------------------------------------------
-
-	// Sets the name of a function if possible (depends of the JS engine).
-	var setFunctionName = (function() {
-	  function setFunctionName(fn, name) {
-	    return defineProperty(fn, "name", {
-	      configurable: true,
-	      value: name,
-	    });
-	  }
-	  try {
-	    var f = function() {};
-	    setFunctionName(f, "foo");
-	    if (f.name === "foo") {
-	      return setFunctionName;
-	    }
-	  } catch (_) {}
-	})();
-
-	// -------------------------------------------------------------------
-
-	function makeError(constructor, super_) {
-	  if (super_ == null || super_ === Error) {
-	    super_ = BaseError;
-	  } else if (typeof super_ !== "function") {
-	    throw new TypeError("super_ should be a function");
-	  }
-
-	  var name;
-	  if (typeof constructor === "string") {
-	    name = constructor;
-	    constructor =
-	      construct !== undefined
-	        ? function() {
-	            return construct(super_, arguments, this.constructor);
-	          }
-	        : function() {
-	            super_.apply(this, arguments);
-	          };
-
-	    // If the name can be set, do it once and for all.
-	    if (setFunctionName !== undefined) {
-	      setFunctionName(constructor, name);
-	      name = undefined;
-	    }
-	  } else if (typeof constructor !== "function") {
-	    throw new TypeError("constructor should be either a string or a function");
-	  }
-
-	  // Also register the super constructor also as `constructor.super_` just
-	  // like Node's `util.inherits()`.
-	  //
-	  // eslint-disable-next-line dot-notation
-	  constructor.super_ = constructor["super"] = super_;
-
-	  var properties = {
-	    constructor: {
-	      configurable: true,
-	      value: constructor,
-	      writable: true,
-	    },
-	  };
-
-	  // If the name could not be set on the constructor, set it on the
-	  // prototype.
-	  if (name !== undefined) {
-	    properties.name = {
-	      configurable: true,
-	      value: name,
-	      writable: true,
-	    };
-	  }
-	  constructor.prototype = Object.create(super_.prototype, properties);
-
-	  return constructor;
-	}
-	exports = module.exports = makeError;
-	exports.BaseError = BaseError; 
-} (makeError, makeError.exports));
-
-var makeErrorExports = makeError.exports;
-
-/**
- * Error thrown when the common type is not known/registered.
- */
-class UnregisteredSyncEntityCommonTypeError extends makeErrorExports.BaseError {
-  constructor(commonType) {
-    super(`The common type "${commonType}" is not registered.`);
-    this.commonType = void 0;
-    this.commonType = commonType;
-  }
-}
-/**
- * Error thrown when no primary sync source is found for an entity.
- */
-class NoPrimarySyncSourceError extends makeErrorExports.BaseError {
-  constructor(entity) {
-    super(`No primary sync source found for entity "${entity.commonType}:${entity.commonId}".`);
-    this.entity = void 0;
-    this.entity = entity;
-  }
-}
 /**
- * Error thrown when multiple primary sync sources are found for an entity.
- */
-class MultiplePrimarySyncSourceError extends makeErrorExports.BaseError {
-  constructor(entity) {
-    super(`Multiple primary sync sources found for entity "${entity.commonType}:${entity.commonId}".`);
-    this.entity = void 0;
-    this.entity = entity;
-  }
-}
-/**
- * Error thrown when a synchronization fails for an entity.
+ * isWebsiteUrl validator
  */
-class SynchronizationFailedError extends makeErrorExports.BaseError {
-  constructor(entity, error) {
-    super(`Synchronization failed for entity "${entity.commonType}:${entity.commonId}". Error: ${error}`);
-    this.entity = void 0;
-    this.error = void 0;
-    this.entity = entity;
-    this.error = error;
-  }
-}
-
-function syncEntitySynchronizer(config) {
-  const map = new Map(config.commonTypeSynchronizers.map(x => [x.commonType, x]));
-  const commonTypes = Array.from(map.keys());
-  const commonTypeSynchronizer = input => {
-    const synchronizer = map.get(input);
-    if (!synchronizer) {
-      throw new UnregisteredSyncEntityCommonTypeError(input);
-    }
-    return synchronizer;
-  };
-  return {
-    commonTypes,
-    commonTypeSynchronizer,
-    synchronizeInstance: input => {
-      const synchronizer = commonTypeSynchronizer(input.commonType);
-      return synchronizer.synchronizeInstance(input);
-    }
-  };
-}
-
-function basicSyncEntityCommonTypeSynchronizerInstanceFactory(config) {
-  const {
-    commonType,
-    sources,
-    entitySourceContextLoader,
-    dynamicSources = false
-  } = config;
-  const syncEntityCommonTypeIdPairForType = syncEntityCommonTypeIdPairFactory(commonType);
-  const sourcesByContextType = util.makeValuesGroupMap(sources, x => x.contextType);
-  const allGlobalSources = sourcesByContextType.get('global') ?? [];
-  const allContextSources = sourcesByContextType.get('context') ?? [];
-  /**
-   * Loads the relevant sources for the given entity and context.
-   *
-   * @param entitySourceContext The contextual information for the entity.
-   * @returns The relevant sources for the entity.
-   */
-  function loadSources(entityCommonTypeIdPair, entitySourceContext) {
-    const {
-      globalSources,
-      contextSources
-    } = entitySourceContext;
-    // load/filter global sources
-    const globalMap = new Map(globalSources.map(x => {
-      let sourceId;
-      let flowType;
-      if (typeof x === 'string') {
-        sourceId = x;
-        flowType = 'unset';
-      } else {
-        sourceId = x.sourceId;
-        flowType = x.flowType;
-      }
-      return [sourceId, {
-        sourceId,
-        flowType
-      }];
-    }));
-    const relevantGlobalSources = util.filterMaybeArrayValues(allGlobalSources.map(x => {
-      const sourceContext = globalMap.get(x.info.id);
-      let result;
-      if (sourceContext != null) {
-        result = {
-          entityCommonTypeIdPair,
-          flowType: sourceContext.flowType ?? x.defaultFlowType ?? 'unset',
-          source: x
-        };
-      }
-      return result;
-    }));
-    // load/filter context sources
-    const contextMap = new Map(contextSources.map(x => [x.sourceId, x]));
-    const relevantContextSources = util.filterMaybeArrayValues(allContextSources.map(x => {
-      const sourceContext = contextMap.get(x.info.id);
-      let result;
-      if (sourceContext != null) {
-        const flowType = sourceContext.flowType ?? x.defaultFlowType ?? 'unset';
-        result = {
-          entityCommonTypeIdPair,
-          flowType,
-          source: x,
-          context: sourceContext
-        };
-      }
-      return result;
-    }));
-    const allSources = [...relevantGlobalSources, ...relevantContextSources];
-    // sort by order, with primary first
-    allSources.sort(util.sortByNumberFunction(x => {
-      let result;
-      switch (x.flowType) {
-        case 'primary':
-          result = 1;
-          break;
-        case 'secondary':
-          result = 2;
-          break;
-        case 'unset':
-        default:
-          result = 3;
-          break;
-      }
-      return result;
-    }));
-    return allSources;
-  }
-  const synchronizeInstance = async input => {
-    const syncEntityCommonTypeIdPair = syncEntityCommonTypeIdPairForType(input);
-    const _loadRelevantSources = async () => {
-      const entitySourceContext = await entitySourceContextLoader(syncEntityCommonTypeIdPair);
-      const relevantSources = loadSources(syncEntityCommonTypeIdPair, entitySourceContext);
-      return relevantSources;
-    };
-    let loadRelevantSources;
-    if (dynamicSources) {
-      // if dynamic, reload each time and do not cache
-      loadRelevantSources = _loadRelevantSources;
-    } else {
-      // if not dynamic, make a cached getter
-      loadRelevantSources = util.cachedGetter(_loadRelevantSources);
-    }
-    /**
-     * Performs the synchonization
-     */
-    const synchronize = async context => {
-      const relevantSources = await loadRelevantSources();
-      const syncEntityInstances = await Promise.all(relevantSources.map(x => x.source.syncEntityInstance(x).then(y => [x, y])));
-      const sourcesByFlowType = util.makeValuesGroupMap(syncEntityInstances, x => x[0].flowType);
-      const primarySources = sourcesByFlowType.get('primary') ?? [];
-      const secondarySources = sourcesByFlowType.get('secondary') ?? [];
-      const replicaSources = sourcesByFlowType.get('replica') ?? [];
-      // assert primary sources count
-      switch (primarySources.length) {
-        case 0:
-          throw new NoPrimarySyncSourceError(syncEntityCommonTypeIdPair);
-        case 1:
-          break;
-        default:
-          throw new MultiplePrimarySyncSourceError(syncEntityCommonTypeIdPair);
-      }
-      function synchronizeInstance(source, deleted) {
-        const [input, sourceInstance] = source;
-        const promise = deleted ? sourceInstance.synchronizeDelete() : sourceInstance.synchronize();
-        return promise.catch(error => {
-          const errorResult = {
-            type: 'error',
-            error,
-            entity: {
-              ...syncEntityCommonTypeIdPair,
-              sourceInfo: input.source.info,
-              id: ''
+function IsWebsiteUrl(validationOptions) {
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isWebsiteUrl',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isWebsiteUrl,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url.`, validationOptions)
             }
-          };
-          return errorResult;
         });
-      }
-      async function performSynchronizationOfSources(input) {
-        const {
-          syncRecursionDepth,
-          secondaryFlaggedDelete
-        } = input;
-        let result;
-        // synchronize the primary source
-        const primarySource = primarySources[0];
-        const primarySyncResult = await synchronizeInstance(primarySource, secondaryFlaggedDelete ?? false);
-        const synchronizedEntityResults = [primarySyncResult];
-        let primaryFlaggedDelete = false;
-        switch (primarySyncResult.type) {
-          case 'deleted':
-            primaryFlaggedDelete = true;
-            break;
-          case 'failed':
-          case 'error':
-            throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, primarySyncResult.error);
-        }
-        // synchronize all secondary sources, one after the other. If any secondary source returns deleted and the primary source was not flagged as deleted, then the synchronization will be restarted.
-        for (const secondarySource of secondarySources) {
-          const secondarySyncResult = await synchronizeInstance(secondarySource, primaryFlaggedDelete);
-          synchronizedEntityResults.push(secondarySyncResult);
-          switch (secondarySyncResult.type) {
-            case 'deleted':
-              if (primaryFlaggedDelete === false) {
-                if (syncRecursionDepth === 1) {
-                  result = await performSynchronizationOfSources({
-                    syncRecursionDepth: syncRecursionDepth + 1,
-                    secondaryFlaggedDelete: true
-                  });
-                }
-                break;
-              }
-              break;
-            case 'failed':
-            case 'error':
-              throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, secondarySyncResult.error);
-          }
-        }
-        // if result was already set, then it was completed in a recursive result
-        if (result == null) {
-          // synchronize all replica sources concurrently
-          const replicaTaskResults = await util.performAsyncTasks(replicaSources, x => synchronizeInstance(x, primaryFlaggedDelete), {
-            sequential: false,
-            maxParallelTasks: 3
-          });
-          // add all the results
-          util.pushArrayItemsIntoArray(synchronizedEntityResults, replicaTaskResults.results.map(x => x[1]));
-          // compute final result
-          result = {
-            synchronizedEntityResults
-          };
-        }
-        return result;
-      }
-      const result = await performSynchronizationOfSources({
-        syncRecursionDepth: 0
-      });
-      return {
-        targetPair: syncEntityCommonTypeIdPair,
-        entitiesSynchronized: result.synchronizedEntityResults
-      };
-    };
-    const instance = {
-      entityPair: syncEntityCommonTypeIdPair,
-      synchronize
-    };
-    return instance;
-  };
-  const result = {
-    commonType,
-    synchronizeInstance
-  };
-  return result;
-}
-
-// MARK: String
-function transformStringToBoolean(defaultValue) {
-  return params => util.stringToBoolean(params.value, defaultValue);
-}
-// MARK: Comma Separated Values
-function transformCommaSeparatedValueToArray(mapFn) {
-  return params => {
-    let result;
-    if (params.value) {
-      if (Array.isArray(params.value)) {
-        result = params.value;
-      } else {
-        result = util.splitCommaSeparatedString(params.value, mapFn);
-      }
-    }
-    return result;
-  };
-}
-const transformCommaSeparatedNumberValueToArray = transformCommaSeparatedValueToArray(x => Number(x));
-const transformCommaSeparatedStringValueToArray = transformCommaSeparatedValueToArray(x => x);
-
-// MARK: Transform Annotations
-function TransformCommaSeparatedValueToArray(mapFn) {
-  return classTransformer.Transform(transformCommaSeparatedValueToArray(mapFn));
-}
-const TransformCommaSeparatedStringValueToArray = () => classTransformer.Transform(transformCommaSeparatedStringValueToArray);
-const TransformCommaSeparatedNumberValueToArray = () => classTransformer.Transform(transformCommaSeparatedNumberValueToArray);
-const TransformStringValueToBoolean = () => classTransformer.Transform(transformStringToBoolean());
-
-function transformAndValidateObject(config) {
-  const transformToResult = transformAndValidateObjectResult(config);
-  const {
-    handleValidationError
-  } = config;
-  return (input, context) => transformToResult(input, context).then(async x => {
-    const object = x.object;
-    let result;
-    if (x.success) {
-      result = x.result;
-    } else {
-      result = await handleValidationError(x.validationErrors);
-    }
-    return {
-      object,
-      result
-    };
-  });
-}
-/**
- * Creates a new TransformAndValidateObjectFactory.
- *
- * @param defaults
- * @returns
- */
-function transformAndValidateObjectFactory(defaults) {
-  const {
-    handleValidationError: defaultHandleValidationError,
-    optionsForContext,
-    defaultValidationOptions
-  } = defaults;
-  return (classType, fn, handleValidationError) => {
-    const config = {
-      classType,
-      fn,
-      handleValidationError: handleValidationError ?? defaultHandleValidationError,
-      optionsForContext,
-      defaultValidationOptions
-    };
-    return transformAndValidateObject(config);
-  };
-}
-/**
- * Factory function that wraps the input class type and handler function to first transform the input object to a the given class, and then validate it.
- *
- * @param classType
- * @param fn
- * @returns
- */
-function transformAndValidateObjectResult(config) {
-  const {
-    defaultValidationOptions,
-    classType,
-    fn,
-    optionsForContext: inputOptionsForContext
-  } = config;
-  const optionsForContext = inputOptionsForContext ?? (() => ({}));
-  return async (input, context) => {
-    const {
-      transform: transformOptions,
-      validate: validateOptions
-    } = optionsForContext(context);
-    const object = classTransformer.plainToInstance(classType, input, {
-      ...transformOptions,
-      // Note: Each variable on the target class must be marked with the @Expose() annotation.
-      excludeExtraneousValues: true
-    });
-    const validationErrors = await classValidator.validate(object, {
-      forbidUnknownValues: false,
-      // allow classes without annotations by default
-      ...defaultValidationOptions,
-      ...validateOptions
-    });
-    if (validationErrors.length) {
-      return {
-        object,
-        validationErrors,
-        success: false
-      };
-    } else {
-      const result = await fn(object);
-      return {
-        object,
-        result,
-        success: true
-      };
-    }
-  };
-}
-
-function transformAndValidateFunctionResultFactory(defaults) {
-  return toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory(defaults));
-}
-function toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory) {
-  return (classType, fn, handleValidationError) => {
-    const transformAndValidateObjectFn = transformAndValidateObjectFactory(classType, fn, handleValidationError);
-    return (input, context) => {
-      return toTransformAndValidateFunctionResult(transformAndValidateObjectFn(input, context));
-    };
-  };
-}
-function toTransformAndValidateFunctionResult(objectOutput) {
-  return util.mapPromiseOrValue(objectOutput, x => {
-    const {
-      object,
-      result
-    } = x;
-    const fnResult = result;
-    fnResult.params = object;
-    return fnResult;
-  });
-}
-
-function transformAndValidateResultFactory(defaults) {
-  const factory = transformAndValidateObjectFactory(defaults);
-  return (classType, fn, handleValidationError) => {
-    const transformAndValidateObjectFn = factory(classType, fn, handleValidationError);
-    return async (input, context) => {
-      const {
-        result
-      } = await transformAndValidateObjectFn(input, context);
-      return result;
     };
-  };
-}
-
-/**
- * isISO8601DayString validator
- */
-function IsISO8601DayString(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isISO8601DayString',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isISO8601DayString,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a ISO8601DayString.`, validationOptions)
-      }
-    });
-  };
-}
-
-/**
- * isMinuteOfDay validator
- */
-function IsMinuteOfDay(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isMinuteOfDay',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isMinuteOfDay,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid minute of the day.`, validationOptions)
-      }
-    });
-  };
-}
-
-/**
- * isE164PhoneNumber validator that does not allowed extensions.
- */
-function IsE164PhoneNumber(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isE164PhoneNumber',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: x => util.isE164PhoneNumber(x, false),
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumber with no extension.`, validationOptions)
-      }
-    });
-  };
-}
-/**
- * isE164PhoneNumber validator that allows extensions.
- *
- * @param validationOptions
- * @returns
- */
-function IsE164PhoneNumberWithOptionalExtension(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isE164PhoneNumber',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: x => util.isE164PhoneNumber(x, true),
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not an E164PhoneNumber or has an invalid extension.`, validationOptions)
-      }
-    });
-  };
-}
-/**
- * isE164PhoneNumberWithExtension validator
- *
- * @param validationOptions
- * @returns
- */
-function IsE164PhoneNumberWithExtension(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isE164PhoneNumberWithExtension',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isE164PhoneNumberWithExtension,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumberWithExtension.`, validationOptions)
-      }
-    });
-  };
-}
-
-/**
- * isUniqueKeyedFunction validator
- */
-function IsUniqueKeyed(readKey, validationOptions) {
-  const isUniqueKeyed = util.isUniqueKeyedFunction(readKey);
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isUniqueKeyed',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: isUniqueKeyed,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value has one or more values with the same key. Keys must be unique.`, validationOptions)
-      }
-    });
-  };
-}
-
-/**
- * isWebsiteUrl validator
- */
-function IsWebsiteUrl(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isWebsiteUrl',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isWebsiteUrl,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url.`, validationOptions)
-      }
-    });
-  };
 }
 /**
  * isWebsiteUrlWithPrefix validator
  */
 function IsWebsiteUrlWithPrefix(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isWebsiteUrlWithPrefix',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isWebsiteUrlWithPrefix,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url that starts with a http/https prefix.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isWebsiteUrlWithPrefix',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isWebsiteUrlWithPrefix,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url that starts with a http/https prefix.`, validationOptions)
+            }
+        });
+    };
 }
 
 exports.ADDRESS_CITY_MAX_LENGTH = ADDRESS_CITY_MAX_LENGTH;