@dereekb/model 13.2.2 → 13.3.1

package/index.esm.js

@@ -1,65 +1,61 @@
-import { US_STATE_CODE_STRING_REGEX, splitJoinRemainder, filterFalsyAndEmptyValues, isolateWebsitePathFunction, toRelativeSlashPathStartType, addPrefix, hasWebsiteDomain, toAbsoluteSlashPathStartType, removeHttpFromUrl, forEachKeyValue, iterableToArray, arrayToObject, MAP_IDENTITY, makeValuesGroupMap, cachedGetter, filterMaybeArrayValues, sortByNumberFunction, performAsyncTasks, pushArrayItemsIntoArray, mapPromiseOrValue, isISO8601DayString, isMinuteOfDay, isE164PhoneNumber, isE164PhoneNumberWithExtension, isValidLatLngPoint, isLatLngString, isUniqueKeyedFunction, isWebsiteUrl, isWebsiteUrlWithPrefix } from '@dereekb/util';
+import { US_STATE_CODE_STRING_REGEX, splitJoinRemainder, filterFalsyAndEmptyValues, isolateWebsitePathFunction, toRelativeSlashPathStartType, addPrefix, hasWebsiteDomain, toAbsoluteSlashPathStartType, removeHttpFromUrl, arrayToObject, forEachKeyValue, iterableToArray, MAP_IDENTITY, makeValuesGroupMap, cachedGetter, pushArrayItemsIntoArray, performAsyncTasks, filterMaybeArrayValues, sortByNumberFunction, mapPromiseOrValue, isISO8601DayString, isMinuteOfDay, isE164PhoneNumber, isE164PhoneNumberWithExtension, isValidLatLngPoint, isLatLngString, isUniqueKeyedFunction, isWebsiteUrl, isWebsiteUrlWithPrefix } from '@dereekb/util';
 import { type } from 'arktype';
 import { BaseError } from 'make-error';
 
 /**
  * Maximum character length for address line fields (line1, line2).
- */
-const ADDRESS_LINE_MAX_LENGTH = 50;
+ */ var ADDRESS_LINE_MAX_LENGTH = 50;
 /**
  * Maximum character length for city names.
- */
-const ADDRESS_CITY_MAX_LENGTH = 80;
+ */ var ADDRESS_CITY_MAX_LENGTH = 80;
 /**
  * Maximum character length for full state names (e.g., "Texas").
- */
-const ADDRESS_STATE_MAX_LENGTH = 30;
+ */ var ADDRESS_STATE_MAX_LENGTH = 30;
 /**
  * Maximum character length for two-letter state codes (e.g., "TX").
- */
-const ADDRESS_STATE_CODE_MAX_LENGTH = 2;
+ */ var ADDRESS_STATE_CODE_MAX_LENGTH = 2;
 /**
  * Maximum character length for ZIP codes, accommodating ZIP+4 format (e.g., "77834-1234").
- */
-const ADDRESS_ZIP_MAX_LENGTH = 11;
+ */ var ADDRESS_ZIP_MAX_LENGTH = 11;
 /**
  * Maximum character length for country names.
- */
-const ADDRESS_COUNTRY_MAX_LENGTH = 80;
+ */ var ADDRESS_COUNTRY_MAX_LENGTH = 80;
 /**
  * Base ArkType schema for United States address fields without the state.
- */
-const baseUnitedStatesAddressType = type({
-    line1: `0 < string <= ${ADDRESS_LINE_MAX_LENGTH}`,
-    'line2?': `string <= ${ADDRESS_LINE_MAX_LENGTH}`,
-    city: `0 < string <= ${ADDRESS_CITY_MAX_LENGTH}`,
-    zip: [/^\d{5}(-\d{4})?$/, '&', `string <= ${ADDRESS_ZIP_MAX_LENGTH}`]
+ */ var baseUnitedStatesAddressType = type({
+    line1: "0 < string <= ".concat(ADDRESS_LINE_MAX_LENGTH),
+    'line2?': "string <= ".concat(ADDRESS_LINE_MAX_LENGTH),
+    city: "0 < string <= ".concat(ADDRESS_CITY_MAX_LENGTH),
+    zip: [
+        /^\d{5}(-\d{4})?$/,
+        '&',
+        "string <= ".concat(ADDRESS_ZIP_MAX_LENGTH)
+    ]
 });
 /**
  * ArkType schema for a United States address with a two-letter state code (e.g., "TX").
- */
-const unitedStatesAddressWithStateCodeType = baseUnitedStatesAddressType.merge({
-    state: [US_STATE_CODE_STRING_REGEX, '&', `${ADDRESS_STATE_CODE_MAX_LENGTH} <= string <= ${ADDRESS_STATE_CODE_MAX_LENGTH}`]
+ */ var unitedStatesAddressWithStateCodeType = baseUnitedStatesAddressType.merge({
+    state: [
+        US_STATE_CODE_STRING_REGEX,
+        '&',
+        "".concat(ADDRESS_STATE_CODE_MAX_LENGTH, " <= string <= ").concat(ADDRESS_STATE_CODE_MAX_LENGTH)
+    ]
 });
 /**
  * ArkType schema for a United States address with a full state name (e.g., "Texas").
- */
-const unitedStatesAddressWithStateStringType = baseUnitedStatesAddressType.merge({
-    state: `0 < string <= ${ADDRESS_STATE_MAX_LENGTH}`
+ */ var unitedStatesAddressWithStateStringType = baseUnitedStatesAddressType.merge({
+    state: "0 < string <= ".concat(ADDRESS_STATE_MAX_LENGTH)
 });
 
 /**
  * Fallback link type used when the actual type is not known.
- */
-const UNKNOWN_WEBSITE_LINK_TYPE = 'u';
+ */ var UNKNOWN_WEBSITE_LINK_TYPE = 'u';
 /**
  * Maximum character length for a {@link WebsiteLinkType} string.
- */
-const WEBSITE_LINK_TYPE_MAX_LENGTH = 32;
+ */ var WEBSITE_LINK_TYPE_MAX_LENGTH = 32;
 /**
  * Regex pattern that validates a {@link WebsiteLinkType} as 1-32 alphanumeric characters.
- */
-const WEBSITE_LINK_TYPE_REGEX = /^[a-zA-Z0-9]{1,32}$/;
+ */ var WEBSITE_LINK_TYPE_REGEX = /^[a-zA-Z0-9]{1,32}$/;
 /**
  * Checks whether the given string is a valid {@link WebsiteLinkType}.
  *
@@ -72,64 +68,114 @@ const WEBSITE_LINK_TYPE_REGEX = /^[a-zA-Z0-9]{1,32}$/;
  * isValidWebsiteLinkType('');      // false
  * isValidWebsiteLinkType('a-b');   // false (hyphen not allowed)
  * ```
- */
-function isValidWebsiteLinkType(input) {
+ */ function isValidWebsiteLinkType(input) {
     return WEBSITE_LINK_TYPE_REGEX.test(input);
 }
 /**
  * Maximum character length for the encoded data string in a {@link WebsiteLink}.
- */
-const WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH = 1000;
+ */ var WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH = 1000;
 /**
  * ArkType schema for a {@link WebsiteLink}.
- */
-const websiteLinkType = type({
-    t: [WEBSITE_LINK_TYPE_REGEX, '&', `0 < string <= ${WEBSITE_LINK_TYPE_MAX_LENGTH}`],
-    d: `0 < string <= ${WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH}`
+ */ var websiteLinkType = type({
+    t: [
+        WEBSITE_LINK_TYPE_REGEX,
+        '&',
+        "0 < string <= ".concat(WEBSITE_LINK_TYPE_MAX_LENGTH)
+    ],
+    d: "0 < string <= ".concat(WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH)
 });
 
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$2(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit$2(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$2() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array$2(arr, i) {
+    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
 /**
  * Maximum character length for a {@link WebsiteFileLinkType}. Matches {@link WEBSITE_LINK_TYPE_MAX_LENGTH}.
- */
-const WEBSITE_FILE_LINK_TYPE_MAX_LENGTH = WEBSITE_LINK_TYPE_MAX_LENGTH;
+ */ var WEBSITE_FILE_LINK_TYPE_MAX_LENGTH = WEBSITE_LINK_TYPE_MAX_LENGTH;
 /**
  * Validation regex for {@link WebsiteFileLinkType}. Matches {@link WEBSITE_LINK_TYPE_REGEX}.
- */
-const WEBSITE_FILE_LINK_TYPE_REGEX = WEBSITE_LINK_TYPE_REGEX;
+ */ var WEBSITE_FILE_LINK_TYPE_REGEX = WEBSITE_LINK_TYPE_REGEX;
 /**
  * Maximum character length for a {@link WebsiteFileLinkMimeType}.
- */
-const WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH = 128;
+ */ var WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH = 128;
 /**
  * Regex pattern that validates a MIME type string (e.g., "text/plain", "application/vnd.api+json").
- */
-const WEBSITE_FILE_LINK_MIME_TYPE_REGEX = /^\w+\/[-+.\w]+$/;
+ */ var WEBSITE_FILE_LINK_MIME_TYPE_REGEX = /^\w+\/[-+.\w]+$/;
 /**
  * Maximum character length for a {@link WebsiteFileLinkName}.
- */
-const WEBSITE_FILE_LINK_NAME_MAX_LENGTH = 128;
+ */ var WEBSITE_FILE_LINK_NAME_MAX_LENGTH = 128;
 /**
  * Maximum character length for {@link WebsiteFileLinkData}, derived from the total encoded data budget
  * minus the separator characters, type, MIME type, and name fields.
- */
-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;
+ */ var 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;
 /**
  * Regex pattern for file link data — disallows the pipe character since it is used as the encoding separator.
- */
-const WEBSITE_FILE_LINK_DATA_REGEX = /^[^|]+$/;
+ */ var WEBSITE_FILE_LINK_DATA_REGEX = /^[^|]+$/;
 /**
  * ArkType schema for a {@link WebsiteFileLink}.
- */
-const websiteFileLinkType = type({
-    'type?': [WEBSITE_FILE_LINK_TYPE_REGEX, '&', `string <= ${WEBSITE_LINK_TYPE_MAX_LENGTH}`],
-    'mime?': [WEBSITE_FILE_LINK_MIME_TYPE_REGEX, '&', `string <= ${WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH}`],
-    'name?': `string <= ${WEBSITE_FILE_LINK_NAME_MAX_LENGTH}`,
-    data: [WEBSITE_FILE_LINK_DATA_REGEX, '&', `0 < string <= ${WEBSITE_FILE_LINK_DATA_MAX_LENGTH}`]
+ */ var websiteFileLinkType = type({
+    'type?': [
+        WEBSITE_FILE_LINK_TYPE_REGEX,
+        '&',
+        "string <= ".concat(WEBSITE_LINK_TYPE_MAX_LENGTH)
+    ],
+    'mime?': [
+        WEBSITE_FILE_LINK_MIME_TYPE_REGEX,
+        '&',
+        "string <= ".concat(WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH)
+    ],
+    'name?': "string <= ".concat(WEBSITE_FILE_LINK_NAME_MAX_LENGTH),
+    data: [
+        WEBSITE_FILE_LINK_DATA_REGEX,
+        '&',
+        "0 < string <= ".concat(WEBSITE_FILE_LINK_DATA_MAX_LENGTH)
+    ]
 });
 /**
  * The {@link WebsiteLinkType} code used to identify a {@link WebsiteLink} as a file link.
- */
-const WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE = 'f';
+ */ var WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE = 'f';
 /**
  * Converts a {@link WebsiteFileLink} to a {@link WebsiteLink} by encoding its fields into the data string.
  *
@@ -142,8 +188,7 @@ const WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE = 'f';
  * const link = websiteFileLinkToWebsiteLink(fileLink);
  * // link.t === 'f'
  * ```
- */
-function websiteFileLinkToWebsiteLink(input) {
+ */ function websiteFileLinkToWebsiteLink(input) {
     return {
         t: WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE,
         d: encodeWebsiteFileLinkToWebsiteLinkEncodedData(input)
@@ -161,15 +206,13 @@ function websiteFileLinkToWebsiteLink(input) {
  * const fileLink = websiteLinkToWebsiteLinkFile(link);
  * // fileLink.data === 'https://example.com/file.txt'
  * ```
- */
-function websiteLinkToWebsiteLinkFile(input) {
-    const encodedData = input.d;
+ */ function websiteLinkToWebsiteLinkFile(input) {
+    var encodedData = input.d;
     return decodeWebsiteLinkEncodedDataToWebsiteFileLink(encodedData);
 }
 /**
  * Separator character used when encoding/decoding file link fields into a single string.
- */
-const WEBSITE_FILE_LINK_ENCODE_SEPARATOR = '|';
+ */ var WEBSITE_FILE_LINK_ENCODE_SEPARATOR = '|';
 /**
  * Encodes a {@link WebsiteFileLink} into a pipe-separated string suitable for storage in a {@link WebsiteLink}'s data field.
  *
@@ -188,9 +231,15 @@ const WEBSITE_FILE_LINK_ENCODE_SEPARATOR = '|';
  * });
  * // encoded === 't|test/test|https://example.com/|test-name'
  * ```
- */
-function encodeWebsiteFileLinkToWebsiteLinkEncodedData(input) {
-    const encoded = [input.type, input.mime, input.data, input.name].map((x) => x || '').join(WEBSITE_FILE_LINK_ENCODE_SEPARATOR);
+ */ function encodeWebsiteFileLinkToWebsiteLinkEncodedData(input) {
+    var encoded = [
+        input.type,
+        input.mime,
+        input.data,
+        input.name
+    ].map(function(x) {
+        return x || '';
+    }).join(WEBSITE_FILE_LINK_ENCODE_SEPARATOR);
     return encoded;
 }
 /**
@@ -209,14 +258,13 @@ function encodeWebsiteFileLinkToWebsiteLinkEncodedData(input) {
  * // fileLink.data === 'https://example.com/'
  * // fileLink.name === 'test-name'
  * ```
- */
-function decodeWebsiteLinkEncodedDataToWebsiteFileLink(input) {
-    const [type, mime, data, name] = splitJoinRemainder(input, WEBSITE_FILE_LINK_ENCODE_SEPARATOR, 4);
+ */ function decodeWebsiteLinkEncodedDataToWebsiteFileLink(input) {
+    var _splitJoinRemainder = _sliced_to_array$2(splitJoinRemainder(input, WEBSITE_FILE_LINK_ENCODE_SEPARATOR, 4), 4), _$type = _splitJoinRemainder[0], mime = _splitJoinRemainder[1], data = _splitJoinRemainder[2], name = _splitJoinRemainder[3];
     return filterFalsyAndEmptyValues({
-        type,
-        mime,
-        name,
-        data
+        type: _$type,
+        mime: mime,
+        name: name,
+        data: data
     });
 }
 
@@ -231,8 +279,7 @@ function decodeWebsiteLinkEncodedDataToWebsiteFileLink(input) {
  * WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID('https://www.facebook.com/myuser');
  * // returns 'myuser'
  * ```
- */
-const WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID = isolateWebsitePathFunction({
+ */ var WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID = isolateWebsitePathFunction({
     isolatePathComponents: 0,
     removeTrailingSlash: true,
     removeQueryParameters: true
@@ -254,13 +301,11 @@ const WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID = isolateWebsitePathFunction({
  * usernameFromUsernameOrWebsiteWithBaseUrlUsername('myuser', '@');
  * // returns '@myuser'
  * ```
- */
-function usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, prefix) {
-    const username = toRelativeSlashPathStartType(WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID(usernameOrWebsiteUrlToWebsiteUrl(input)));
+ */ function usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, prefix) {
+    var username = toRelativeSlashPathStartType(WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID(usernameOrWebsiteUrlToWebsiteUrl(input)));
     if (prefix) {
         return addPrefix(prefix, username);
-    }
-    else {
+    } else {
         return username;
     }
 }
@@ -272,8 +317,7 @@ function usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, prefix) {
  * @param input - a username or full profile URL
  * @param isolateFn - custom function that extracts the relevant path segment from the URL
  * @returns the isolated username
- */
-function usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, isolateFn) {
+ */ function usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, isolateFn) {
     return toRelativeSlashPathStartType(isolateFn(usernameOrWebsiteUrlToWebsiteUrl(input)));
 }
 /**
@@ -283,15 +327,13 @@ function usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, isolateFn
  *
  * @param input - a username or website URL
  * @returns a normalized website URL
- */
-function usernameOrWebsiteUrlToWebsiteUrl(input) {
+ */ function usernameOrWebsiteUrlToWebsiteUrl(input) {
     return hasWebsiteDomain(input) ? input : toAbsoluteSlashPathStartType(removeHttpFromUrl(input));
 }
 // MARK: Website
 /**
  * {@link WebsiteLinkType} code for generic website URLs.
- */
-const WEBSITE_URL_WEBSITE_LINK_TYPE = 'w';
+ */ var WEBSITE_URL_WEBSITE_LINK_TYPE = 'w';
 /**
  * Converts a generic website URL into a {@link WebsiteLink}, stripping the HTTP/HTTPS protocol.
  *
@@ -303,8 +345,7 @@ const WEBSITE_URL_WEBSITE_LINK_TYPE = 'w';
  * const link = websiteUrlToWebsiteLink('https://example.com/page');
  * // link.t === 'w', link.d === 'example.com/page'
  * ```
- */
-function websiteUrlToWebsiteLink(input) {
+ */ function websiteUrlToWebsiteLink(input) {
     return {
         t: WEBSITE_URL_WEBSITE_LINK_TYPE,
         d: removeHttpFromUrl(input) // website urls are stored as-is without http/https
@@ -313,15 +354,13 @@ function websiteUrlToWebsiteLink(input) {
 // MARK: Email
 /**
  * {@link WebsiteLinkType} code for email addresses.
- */
-const EMAIL_URL_WEBSITE_LINK_TYPE = 'e';
+ */ var EMAIL_URL_WEBSITE_LINK_TYPE = 'e';
 /**
  * Converts an email address into a {@link WebsiteLink}.
  *
  * @param input - the email address
  * @returns a WebsiteLink storing the email as data
- */
-function emailAddressToWebsiteLink(input) {
+ */ function emailAddressToWebsiteLink(input) {
     return {
         t: EMAIL_URL_WEBSITE_LINK_TYPE,
         d: input
@@ -330,25 +369,21 @@ function emailAddressToWebsiteLink(input) {
 // MARK: Phone
 /**
  * {@link WebsiteLinkType} code for phone numbers.
- */
-const PHONE_URL_WEBSITE_LINK_TYPE = 'p';
+ */ var PHONE_URL_WEBSITE_LINK_TYPE = 'p';
 /**
  * Converts an E.164 phone number into a {@link WebsiteLink}.
  *
  * @param input - the phone number in E.164 format
  * @returns a WebsiteLink storing the phone number as data
- */
-function phoneNumberToWebsiteLink(input) {
+ */ function phoneNumberToWebsiteLink(input) {
     return {
         t: PHONE_URL_WEBSITE_LINK_TYPE,
         d: input
     };
 }
 // MARK: Facebook
-/** Base URL for Facebook profiles. */
-const FACEBOOK_BASE_URL = `https://www.facebook.com`;
-/** {@link WebsiteLinkType} code for Facebook. */
-const FACEBOOK_WEBSITE_LINK_TYPE = 'fb';
+/** Base URL for Facebook profiles. */ var FACEBOOK_BASE_URL = "https://www.facebook.com";
+/** {@link WebsiteLinkType} code for Facebook. */ var FACEBOOK_WEBSITE_LINK_TYPE = 'fb';
 /**
  * Converts a Facebook profile ID or URL into a {@link WebsiteLink}.
  *
@@ -365,8 +400,7 @@ const FACEBOOK_WEBSITE_LINK_TYPE = 'fb';
  * facebookProfileUrlToWebsiteLink('myuser');
  * // { t: 'fb', d: 'myuser' }
  * ```
- */
-function facebookProfileUrlToWebsiteLink(input) {
+ */ function facebookProfileUrlToWebsiteLink(input) {
     return {
         t: FACEBOOK_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
@@ -377,22 +411,18 @@ function facebookProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the Facebook profile ID or username
  * @returns the full profile URL
- */
-function facebookProfileUrl(profileId) {
-    return `${FACEBOOK_BASE_URL}/${profileId}`;
+ */ function facebookProfileUrl(profileId) {
+    return "".concat(FACEBOOK_BASE_URL, "/").concat(profileId);
 }
 // MARK: Instagram
-/** Base URL for Instagram profiles. */
-const INSTAGRAM_BASE_URL = `https://www.instagram.com`;
-/** {@link WebsiteLinkType} code for Instagram. */
-const INSTAGRAM_WEBSITE_LINK_TYPE = 'ig';
+/** Base URL for Instagram profiles. */ var INSTAGRAM_BASE_URL = "https://www.instagram.com";
+/** {@link WebsiteLinkType} code for Instagram. */ var INSTAGRAM_WEBSITE_LINK_TYPE = 'ig';
 /**
  * Converts an Instagram profile ID or URL into a {@link WebsiteLink}.
  *
  * @param input - an Instagram username or full profile URL
  * @returns a WebsiteLink with the isolated username as data
- */
-function instagramProfileUrlToWebsiteLink(input) {
+ */ function instagramProfileUrlToWebsiteLink(input) {
     return {
         t: INSTAGRAM_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
@@ -403,22 +433,18 @@ function instagramProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the Instagram username
  * @returns the full profile URL
- */
-function instagramProfileUrl(profileId) {
-    return `${INSTAGRAM_BASE_URL}/${profileId}`;
+ */ function instagramProfileUrl(profileId) {
+    return "".concat(INSTAGRAM_BASE_URL, "/").concat(profileId);
 }
 // MARK: Twitter
-/** Base URL for Twitter profiles. */
-const TWITTER_BASE_URL = `https://www.twitter.com`;
-/** {@link WebsiteLinkType} code for Twitter. */
-const TWITTER_WEBSITE_LINK_TYPE = 'tw';
+/** Base URL for Twitter profiles. */ var TWITTER_BASE_URL = "https://www.twitter.com";
+/** {@link WebsiteLinkType} code for Twitter. */ var TWITTER_WEBSITE_LINK_TYPE = 'tw';
 /**
  * Converts a Twitter profile ID or URL into a {@link WebsiteLink}.
  *
  * @param input - a Twitter username or full profile URL
  * @returns a WebsiteLink with the isolated username as data
- */
-function twitterProfileUrlToWebsiteLink(input) {
+ */ function twitterProfileUrlToWebsiteLink(input) {
     return {
         t: TWITTER_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
@@ -429,17 +455,13 @@ function twitterProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the Twitter username
  * @returns the full profile URL
- */
-function twitterProfileUrl(profileId) {
-    return `${TWITTER_BASE_URL}/${profileId}`;
+ */ function twitterProfileUrl(profileId) {
+    return "".concat(TWITTER_BASE_URL, "/").concat(profileId);
 }
 // MARK: Tiktok
-/** Base URL for TikTok profiles. */
-const TIKTOK_BASE_URL = `https://tiktok.com`;
-/** TikTok usernames are prefixed with "@" in URLs and stored data. */
-const TIKTOK_USERNAME_PREFIX = '@';
-/** {@link WebsiteLinkType} code for TikTok. */
-const TIKTOK_WEBSITE_LINK_TYPE = 'tt';
+/** Base URL for TikTok profiles. */ var TIKTOK_BASE_URL = "https://tiktok.com";
+/** TikTok usernames are prefixed with "@" in URLs and stored data. */ var TIKTOK_USERNAME_PREFIX = '@';
+/** {@link WebsiteLinkType} code for TikTok. */ var TIKTOK_WEBSITE_LINK_TYPE = 'tt';
 /**
  * Converts a TikTok profile ID or URL into a {@link WebsiteLink}.
  *
@@ -447,8 +469,7 @@ const TIKTOK_WEBSITE_LINK_TYPE = 'tt';
  *
  * @param input - a TikTok username (with or without "@") or full profile URL
  * @returns a WebsiteLink with the "@"-prefixed username as data
- */
-function tiktokProfileUrlToWebsiteLink(input) {
+ */ function tiktokProfileUrlToWebsiteLink(input) {
     return {
         t: TIKTOK_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, TIKTOK_USERNAME_PREFIX)
@@ -459,19 +480,15 @@ function tiktokProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the TikTok username (without "@" prefix)
  * @returns the full profile URL with "@" prefix
- */
-function tiktokProfileUrl(profileId) {
-    return `${TIKTOK_BASE_URL}/@${profileId}`;
+ */ function tiktokProfileUrl(profileId) {
+    return "".concat(TIKTOK_BASE_URL, "/@").concat(profileId);
 }
 // MARK: Snapchat
-/** Base URL for Snapchat profiles. */
-const SNAPCHAT_BASE_URL = `https://snapchat.com`;
-/** {@link WebsiteLinkType} code for Snapchat. */
-const SNAPCHAT_WEBSITE_LINK_TYPE = 'sc';
+/** Base URL for Snapchat profiles. */ var SNAPCHAT_BASE_URL = "https://snapchat.com";
+/** {@link WebsiteLinkType} code for Snapchat. */ var SNAPCHAT_WEBSITE_LINK_TYPE = 'sc';
 /**
  * Isolates a Snapchat username from a URL, ignoring the `/add/` base path segment.
- */
-const SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
+ */ var SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
     ignoredBasePath: 'add',
     isolatePathComponents: 0,
     removeTrailingSlash: true,
@@ -484,8 +501,7 @@ const SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
  *
  * @param input - a Snapchat username or full profile URL
  * @returns a WebsiteLink with the isolated username as data
- */
-function snapchatProfileUrlToWebsiteLink(input) {
+ */ function snapchatProfileUrlToWebsiteLink(input) {
     return {
         t: SNAPCHAT_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID)
@@ -496,19 +512,15 @@ function snapchatProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the Snapchat username
  * @returns the full profile URL with `/add/` path
- */
-function snapchatProfileUrl(profileId) {
-    return `${SNAPCHAT_BASE_URL}/add/${profileId}`;
+ */ function snapchatProfileUrl(profileId) {
+    return "".concat(SNAPCHAT_BASE_URL, "/add/").concat(profileId);
 }
 // MARK: YouTube
-/** Base URL for YouTube channels. */
-const YOUTUBE_BASE_URL = `https://youtube.com`;
-/** {@link WebsiteLinkType} code for YouTube. */
-const YOUTUBE_WEBSITE_LINK_TYPE = 'yt';
+/** Base URL for YouTube channels. */ var YOUTUBE_BASE_URL = "https://youtube.com";
+/** {@link WebsiteLinkType} code for YouTube. */ var YOUTUBE_WEBSITE_LINK_TYPE = 'yt';
 /**
  * Isolates a YouTube channel name from a URL, ignoring the `/c/` base path segment.
- */
-const YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
+ */ var YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
     ignoredBasePath: 'c',
     isolatePathComponents: 0,
     removeTrailingSlash: true,
@@ -521,8 +533,7 @@ const YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
  *
  * @param input - a YouTube channel name or full channel URL
  * @returns a WebsiteLink with the isolated channel name as data
- */
-function youtubeProfileUrlToWebsiteLink(input) {
+ */ function youtubeProfileUrlToWebsiteLink(input) {
     return {
         t: YOUTUBE_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID)
@@ -533,22 +544,18 @@ function youtubeProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the YouTube channel name
  * @returns the full channel URL with `/c/` path
- */
-function youtubeProfileUrl(profileId) {
-    return `${YOUTUBE_BASE_URL}/c/${profileId}`;
+ */ function youtubeProfileUrl(profileId) {
+    return "".concat(YOUTUBE_BASE_URL, "/c/").concat(profileId);
 }
 // MARK: PayPal
-/** Base URL for PayPal.me profiles. */
-const PAYPAL_BASE_URL = `https://paypal.me`;
-/** {@link WebsiteLinkType} code for PayPal. */
-const PAYPAL_WEBSITE_LINK_TYPE = 'pp';
+/** Base URL for PayPal.me profiles. */ var PAYPAL_BASE_URL = "https://paypal.me";
+/** {@link WebsiteLinkType} code for PayPal. */ var PAYPAL_WEBSITE_LINK_TYPE = 'pp';
 /**
  * Converts a PayPal profile ID or URL into a {@link WebsiteLink}.
  *
  * @param input - a PayPal username or full PayPal.me URL
  * @returns a WebsiteLink with the isolated username as data
- */
-function paypalProfileUrlToWebsiteLink(input) {
+ */ function paypalProfileUrlToWebsiteLink(input) {
     return {
         t: PAYPAL_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
@@ -559,17 +566,13 @@ function paypalProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the PayPal username
  * @returns the full PayPal.me URL
- */
-function paypalProfileUrl(profileId) {
-    return `${PAYPAL_BASE_URL}/${profileId}`;
+ */ function paypalProfileUrl(profileId) {
+    return "".concat(PAYPAL_BASE_URL, "/").concat(profileId);
 }
 // MARK: Cashapp
-/** Base URL for Cash App profiles. */
-const CASHAPP_BASE_URL = `https://cash.app`;
-/** Cash App usernames are prefixed with "$" (cashtag). */
-const CASHAPP_USERNAME_PREFIX = '$';
-/** {@link WebsiteLinkType} code for Cash App. */
-const CASHAPP_WEBSITE_LINK_TYPE = 'ca';
+/** Base URL for Cash App profiles. */ var CASHAPP_BASE_URL = "https://cash.app";
+/** Cash App usernames are prefixed with "$" (cashtag). */ var CASHAPP_USERNAME_PREFIX = '$';
+/** {@link WebsiteLinkType} code for Cash App. */ var CASHAPP_WEBSITE_LINK_TYPE = 'ca';
 /**
  * Converts a Cash App profile ID or URL into a {@link WebsiteLink}.
  *
@@ -577,8 +580,7 @@ const CASHAPP_WEBSITE_LINK_TYPE = 'ca';
  *
  * @param input - a Cash App username (with or without "$") or full profile URL
  * @returns a WebsiteLink with the "$"-prefixed username as data
- */
-function cashappProfileUrlToWebsiteLink(input) {
+ */ function cashappProfileUrlToWebsiteLink(input) {
     return {
         t: CASHAPP_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, CASHAPP_USERNAME_PREFIX)
@@ -589,19 +591,15 @@ function cashappProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the Cash App username (without "$" prefix)
  * @returns the full Cash App URL with "$" prefix
- */
-function cashappProfileUrl(profileId) {
-    return `${CASHAPP_BASE_URL}/$${profileId}`;
+ */ function cashappProfileUrl(profileId) {
+    return "".concat(CASHAPP_BASE_URL, "/$").concat(profileId);
 }
 // MARK: Venmo
-/** Base URL for Venmo profiles. */
-const VENMO_BASE_URL = `https://account.venmo.com`;
-/** {@link WebsiteLinkType} code for Venmo. */
-const VENMO_WEBSITE_LINK_TYPE = 'vn';
+/** Base URL for Venmo profiles. */ var VENMO_BASE_URL = "https://account.venmo.com";
+/** {@link WebsiteLinkType} code for Venmo. */ var VENMO_WEBSITE_LINK_TYPE = 'vn';
 /**
  * Isolates a Venmo username from a URL, ignoring the `/u/` base path segment.
- */
-const VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
+ */ var VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
     ignoredBasePath: 'u',
     isolatePathComponents: 0,
     removeTrailingSlash: true,
@@ -614,8 +612,7 @@ const VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
  *
  * @param input - a Venmo username or full profile URL
  * @returns a WebsiteLink with the isolated username as data
- */
-function venmoProfileUrlToWebsiteLink(input) {
+ */ function venmoProfileUrlToWebsiteLink(input) {
     return {
         t: VENMO_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID)
@@ -626,19 +623,15 @@ function venmoProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the Venmo username
  * @returns the full profile URL with `/u/` path
- */
-function venmoProfileUrl(profileId) {
-    return `${VENMO_BASE_URL}/u/${profileId}`;
+ */ function venmoProfileUrl(profileId) {
+    return "".concat(VENMO_BASE_URL, "/u/").concat(profileId);
 }
 // MARK: Spotify
-/** Base URL for Spotify profiles. */
-const SPOTIFY_BASE_URL = `https://open.spotify.com/`;
-/** {@link WebsiteLinkType} code for Spotify. */
-const SPOTIFY_WEBSITE_LINK_TYPE = 'sp';
+/** Base URL for Spotify profiles. */ var SPOTIFY_BASE_URL = "https://open.spotify.com/";
+/** {@link WebsiteLinkType} code for Spotify. */ var SPOTIFY_WEBSITE_LINK_TYPE = 'sp';
 /**
  * Isolates a Spotify username from a URL, ignoring the `/user/` base path segment.
- */
-const SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
+ */ var SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
     ignoredBasePath: 'user',
     isolatePathComponents: 0,
     removeTrailingSlash: true,
@@ -651,8 +644,7 @@ const SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID = isolateWebsitePathFunction({
  *
  * @param input - a Spotify username or full profile URL
  * @returns a WebsiteLink with the isolated username as data
- */
-function spotifyProfileUrlToWebsiteLink(input) {
+ */ function spotifyProfileUrlToWebsiteLink(input) {
     return {
         t: SPOTIFY_WEBSITE_LINK_TYPE,
         d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID)
@@ -663,14 +655,90 @@ function spotifyProfileUrlToWebsiteLink(input) {
  *
  * @param profileId - the Spotify username
  * @returns the full profile URL with `/user/` path
- */
-function spotifyProfileUrl(profileId) {
-    return `${SPOTIFY_BASE_URL}/user/${profileId}`;
+ */ function spotifyProfileUrl(profileId) {
+    return "".concat(SPOTIFY_BASE_URL, "/user/").concat(profileId);
 }
 
-const GRANTED_SYS_ADMIN_ROLE_KEY = 'sysadmin';
-const GRANTED_OWNER_ROLE_KEY = 'owner';
-const GRANTED_ADMIN_ROLE_KEY = 'admin';
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+var GRANTED_SYS_ADMIN_ROLE_KEY = 'sysadmin';
+var GRANTED_OWNER_ROLE_KEY = 'owner';
+var GRANTED_ADMIN_ROLE_KEY = 'admin';
 /**
  * Checks whether the given role represents an admin-level permission (either "admin" or "owner").
  *
@@ -683,15 +751,14 @@ const GRANTED_ADMIN_ROLE_KEY = 'admin';
  * isGrantedAdminLevelRole('owner');  // true
  * isGrantedAdminLevelRole('read');   // false
  * ```
- */
-function isGrantedAdminLevelRole(role) {
+ */ function isGrantedAdminLevelRole(role) {
     return role === GRANTED_ADMIN_ROLE_KEY || role === GRANTED_OWNER_ROLE_KEY;
 }
-const GRANTED_READ_ROLE_KEY = 'read';
-const GRANTED_UPDATE_ROLE_KEY = 'update';
-const GRANTED_DELETE_ROLE_KEY = 'delete';
-const FULL_ACCESS_ROLE_KEY = '__FULL__';
-const NO_ACCESS_ROLE_KEY = '__EMPTY__';
+var GRANTED_READ_ROLE_KEY = 'read';
+var GRANTED_UPDATE_ROLE_KEY = 'update';
+var GRANTED_DELETE_ROLE_KEY = 'delete';
+var FULL_ACCESS_ROLE_KEY = '__FULL__';
+var NO_ACCESS_ROLE_KEY = '__EMPTY__';
 /**
  * Creates a {@link GrantedRoleMap} that explicitly denies all access.
  *
@@ -702,19 +769,15 @@ const NO_ACCESS_ROLE_KEY = '__EMPTY__';
  * const map = noAccessRoleMap();
  * isNoAccessRoleMap(map); // true
  * ```
- */
-function noAccessRoleMap() {
-    return {
-        [NO_ACCESS_ROLE_KEY]: true
-    };
+ */ function noAccessRoleMap() {
+    return _define_property$3({}, NO_ACCESS_ROLE_KEY, true);
 }
 /**
  * Type guard that checks whether a role map is a no-access map.
  *
  * @param input - the role map to check
  * @returns true if the map has the no-access marker
- */
-function isNoAccessRoleMap(input) {
+ */ function isNoAccessRoleMap(input) {
     return input[NO_ACCESS_ROLE_KEY] === true;
 }
 /**
@@ -727,19 +790,15 @@ function isNoAccessRoleMap(input) {
  * const map = fullAccessRoleMap();
  * isFullAccessRoleMap(map); // true
  * ```
- */
-function fullAccessRoleMap() {
-    return {
-        [FULL_ACCESS_ROLE_KEY]: true
-    };
+ */ function fullAccessRoleMap() {
+    return _define_property$3({}, FULL_ACCESS_ROLE_KEY, true);
 }
 /**
  * Type guard that checks whether a role map is a full-access map.
  *
  * @param input - the role map to check
  * @returns true if the map has the full-access marker
- */
-function isFullAccessRoleMap(input) {
+ */ function isFullAccessRoleMap(input) {
     return input[FULL_ACCESS_ROLE_KEY] === true;
 }
 /**
@@ -761,66 +820,124 @@ function isFullAccessRoleMap(input) {
  * reader.containsRoles('any', ['read']);    // true
  * reader.containsRoles('all', ['read', 'delete']); // false
  * ```
- */
-function grantedRoleMapReader(map) {
+ */ function grantedRoleMapReader(map) {
     return new GrantedRoleMapReaderInstance(map);
 }
-class GrantedRoleMapReaderInstance {
-    _map;
-    constructor(map) {
+var GrantedRoleMapReaderInstance = /*#__PURE__*/ function() {
+    function GrantedRoleMapReaderInstance(map) {
+        _class_call_check$2(this, GrantedRoleMapReaderInstance);
+        _define_property$3(this, "_map", void 0);
         this._map = map;
     }
-    hasNoAccess() {
-        return this._map[NO_ACCESS_ROLE_KEY];
-    }
-    truthMap(input) {
-        const result = {};
-        forEachKeyValue(input, {
-            forEach: ([role, value]) => {
-                if (this.hasRole(role)) {
-                    result[role] = value;
+    _create_class$1(GrantedRoleMapReaderInstance, [
+        {
+            key: "hasNoAccess",
+            value: function hasNoAccess() {
+                return this._map[NO_ACCESS_ROLE_KEY];
+            }
+        },
+        {
+            key: "truthMap",
+            value: function truthMap(input) {
+                var _this = this;
+                var result = {};
+                forEachKeyValue(input, {
+                    forEach: function forEach(param) {
+                        var _param = _sliced_to_array$1(param, 2), role = _param[0], value = _param[1];
+                        if (_this.hasRole(role)) {
+                            result[role] = value;
+                        }
+                    }
+                });
+                return result;
+            }
+        },
+        {
+            key: "hasRole",
+            value: function hasRole(role) {
+                return this.hasRoles('any', role);
+            }
+        },
+        {
+            key: "hasRoles",
+            value: function hasRoles(setIncludes, inputRoles) {
+                if (this._map[FULL_ACCESS_ROLE_KEY]) {
+                    return true;
+                } else {
+                    return this.containsRoles(setIncludes, inputRoles);
                 }
             }
-        });
-        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 = iterableToArray(inputRoles);
-        if (setIncludes === 'any') {
-            return this.containsAnyRole(roles);
-        }
-        else {
-            return this.containsEachRole(roles);
-        }
-    }
-    containsAnyRole(roles) {
-        for (const role of roles) {
-            if (this._map[role]) {
-                return true;
+        },
+        {
+            key: "containsRoles",
+            value: function containsRoles(setIncludes, inputRoles) {
+                var roles = 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]) {
+        },
+        {
+            key: "containsAnyRole",
+            value: function containsAnyRole(roles) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = roles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var role = _step.value;
+                        if (this._map[role]) {
+                            return true;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
                 return false;
             }
+        },
+        {
+            key: "containsEachRole",
+            value: function containsEachRole(roles) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = roles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var role = _step.value;
+                        if (!this._map[role]) {
+                            return false;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return true;
+            }
         }
-        return true;
-    }
-}
+    ]);
+    return GrantedRoleMapReaderInstance;
+}();
 /**
  * Converts an array of role strings into a {@link GrantedRoleKeysMap} where each role is mapped to the given boolean value.
  *
@@ -833,9 +950,13 @@ class GrantedRoleMapReaderInstance {
  * const map = grantedRoleKeysMapFromArray(['read', 'update']);
  * // { read: true, update: true }
  * ```
- */
-function grantedRoleKeysMapFromArray(roles, value = true) {
-    return arrayToObject(roles, (x) => x, () => value);
+ */ function grantedRoleKeysMapFromArray(roles) {
+    var value = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+    return arrayToObject(roles, function(x) {
+        return x;
+    }, function() {
+        return value;
+    });
 }
 
 /**
@@ -850,8 +971,7 @@ function grantedRoleKeysMapFromArray(roles, value = true) {
  * const result = noAccessContextGrantedModelRoles(userContext);
  * // result.roleMap contains the no-access marker
  * ```
- */
-function noAccessContextGrantedModelRoles(context, data) {
+ */ function noAccessContextGrantedModelRoles(context, data) {
     return contextGrantedModelRoles(context, data, noAccessRoleMap());
 }
 /**
@@ -866,8 +986,7 @@ function noAccessContextGrantedModelRoles(context, data) {
  * const result = fullAccessGrantedModelRoles(adminContext, modelData);
  * // result.roleMap contains the full-access marker
  * ```
- */
-function fullAccessGrantedModelRoles(context, data) {
+ */ function fullAccessGrantedModelRoles(context, data) {
     return contextGrantedModelRoles(context, data, fullAccessRoleMap());
 }
 /**
@@ -877,56 +996,303 @@ function fullAccessGrantedModelRoles(context, data) {
  * @param data - the model data, if loaded
  * @param roles - the granted role map
  * @returns a ContextGrantedModelRoles combining all inputs
- */
-function contextGrantedModelRoles(context, data, roles) {
+ */ function contextGrantedModelRoles(context, data, roles) {
     return {
-        data,
-        context,
+        data: data,
+        context: context,
         roleMap: roles
     };
 }
 
-/**
- * Abstract ModelPermissionService implementation.
- */
-class AbstractModelPermissionService {
-    _modelLoader;
-    constructor(modelLoader) {
-        this._modelLoader = modelLoader;
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
     }
-    get modelLoader() {
-        return this._modelLoader;
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
     }
-    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;
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    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;
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    async getRoleMapForOutput(output, context, model) {
-        const roleMap = await this.roleMapForModel(output, context, model);
-        return contextGrantedModelRoles(context, output, roleMap);
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-    isUsableOutputForRoles(output, context) {
-        return true; // can override in parent functions to further filter roles.
+    return obj;
+}
+function _ts_generator$3(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
     }
 }
+/**
+ * Abstract ModelPermissionService implementation.
+ */ var AbstractModelPermissionService = /*#__PURE__*/ function() {
+    function AbstractModelPermissionService(modelLoader) {
+        _class_call_check$1(this, AbstractModelPermissionService);
+        _define_property$2(this, "_modelLoader", void 0);
+        this._modelLoader = modelLoader;
+    }
+    _create_class(AbstractModelPermissionService, [
+        {
+            key: "modelLoader",
+            get: function get() {
+                return this._modelLoader;
+            }
+        },
+        {
+            key: "roleMapForKeyContext",
+            value: function roleMapForKeyContext(key, context) {
+                return _async_to_generator$3(function() {
+                    var model, result;
+                    return _ts_generator$3(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.modelLoader.loadModelForKey(key, context)
+                                ];
+                            case 1:
+                                model = _state.sent();
+                                if (!(model != null)) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    this.roleMapForModelContext(model, context)
+                                ];
+                            case 2:
+                                result = _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                result = noAccessContextGrantedModelRoles(context);
+                                _state.label = 4;
+                            case 4:
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "roleMapForModelContext",
+            value: function roleMapForModelContext(model, context) {
+                return _async_to_generator$3(function() {
+                    var output, result;
+                    return _ts_generator$3(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.outputForModel(model, context)
+                                ];
+                            case 1:
+                                output = _state.sent();
+                                if (!(output != null && this.isUsableOutputForRoles(output, context))) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    this.getRoleMapForOutput(output, context, model)
+                                ];
+                            case 2:
+                                result = _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                result = noAccessContextGrantedModelRoles(context, output);
+                                _state.label = 4;
+                            case 4:
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "getRoleMapForOutput",
+            value: function getRoleMapForOutput(output, context, model) {
+                return _async_to_generator$3(function() {
+                    var roleMap;
+                    return _ts_generator$3(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.roleMapForModel(output, context, model)
+                                ];
+                            case 1:
+                                roleMap = _state.sent();
+                                return [
+                                    2,
+                                    contextGrantedModelRoles(context, output, roleMap)
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "isUsableOutputForRoles",
+            value: function isUsableOutputForRoles(output, context) {
+                return true; // can override in parent functions to further filter roles.
+            }
+        }
+    ]);
+    return AbstractModelPermissionService;
+} 
+();
 
 /**
  * Creates a factory that normalizes a {@link SyncEntityCommonTypeIdPairFactoryInput} into a full {@link SyncEntityCommonTypeIdPair}.
@@ -943,16 +1309,14 @@ class AbstractModelPermissionService {
  * factory('abc123');  // { commonType: 'user', commonId: 'abc123' }
  * factory({ commonType: 'user', commonId: 'abc123' });  // passed through as-is
  * ```
- */
-function syncEntityCommonTypeIdPairFactory(commonType) {
-    return (input) => {
+ */ function syncEntityCommonTypeIdPairFactory(commonType) {
+    return function(input) {
         if (typeof input === 'string') {
             return {
-                commonType,
+                commonType: commonType,
                 commonId: input
             };
-        }
-        else {
+        } else {
             return input;
         }
     };
@@ -975,64 +1339,155 @@ function syncEntityCommonTypeIdPairFactory(commonType) {
  * const entity = factory({ commonType: 'user', commonId: 'abc123' });
  * // entity.id === 'abc123', entity.sourceInfo.id === 'api'
  * ```
- */
-function syncEntityFactory(config) {
-    const { idFactory: inputIdFactory, sourceInfo } = config;
-    const idFactory = inputIdFactory ?? MAP_IDENTITY;
-    return (input) => {
-        const { commonType, commonId } = input;
-        const id = idFactory(commonId);
+ */ function syncEntityFactory(config) {
+    var inputIdFactory = config.idFactory, sourceInfo = config.sourceInfo;
+    var idFactory = inputIdFactory !== null && inputIdFactory !== void 0 ? inputIdFactory : MAP_IDENTITY;
+    return function(input) {
+        var commonType = input.commonType, commonId = input.commonId;
+        var id = idFactory(commonId);
         return {
-            commonType,
-            commonId,
-            id,
-            sourceInfo
+            commonType: commonType,
+            commonId: commonId,
+            id: id,
+            sourceInfo: sourceInfo
         };
     };
 }
 
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
 /**
  * Error thrown when the common type is not known/registered.
- */
-class UnregisteredSyncEntityCommonTypeError extends BaseError {
-    commonType;
-    constructor(commonType) {
-        super(`The common type "${commonType}" is not registered.`);
-        this.commonType = commonType;
+ */ var UnregisteredSyncEntityCommonTypeError = /*#__PURE__*/ function(BaseError) {
+    _inherits(UnregisteredSyncEntityCommonTypeError, BaseError);
+    function UnregisteredSyncEntityCommonTypeError(commonType) {
+        _class_call_check(this, UnregisteredSyncEntityCommonTypeError);
+        var _this;
+        _this = _call_super(this, UnregisteredSyncEntityCommonTypeError, [
+            'The common type "'.concat(commonType, '" is not registered.')
+        ]), _define_property$1(_this, "commonType", void 0);
+        _this.commonType = commonType;
+        return _this;
     }
-}
+    return UnregisteredSyncEntityCommonTypeError;
+}(BaseError);
 /**
  * Error thrown when no primary sync source is found for an entity.
- */
-class NoPrimarySyncSourceError extends BaseError {
-    entity;
-    constructor(entity) {
-        super(`No primary sync source found for entity "${entity.commonType}:${entity.commonId}".`);
-        this.entity = entity;
+ */ var NoPrimarySyncSourceError = /*#__PURE__*/ function(BaseError) {
+    _inherits(NoPrimarySyncSourceError, BaseError);
+    function NoPrimarySyncSourceError(entity) {
+        _class_call_check(this, NoPrimarySyncSourceError);
+        var _this;
+        _this = _call_super(this, NoPrimarySyncSourceError, [
+            'No primary sync source found for entity "'.concat(entity.commonType, ":").concat(entity.commonId, '".')
+        ]), _define_property$1(_this, "entity", void 0);
+        _this.entity = entity;
+        return _this;
     }
-}
+    return NoPrimarySyncSourceError;
+}(BaseError);
 /**
  * Error thrown when multiple primary sync sources are found for an entity.
- */
-class MultiplePrimarySyncSourceError extends BaseError {
-    entity;
-    constructor(entity) {
-        super(`Multiple primary sync sources found for entity "${entity.commonType}:${entity.commonId}".`);
-        this.entity = entity;
+ */ var MultiplePrimarySyncSourceError = /*#__PURE__*/ function(BaseError) {
+    _inherits(MultiplePrimarySyncSourceError, BaseError);
+    function MultiplePrimarySyncSourceError(entity) {
+        _class_call_check(this, MultiplePrimarySyncSourceError);
+        var _this;
+        _this = _call_super(this, MultiplePrimarySyncSourceError, [
+            'Multiple primary sync sources found for entity "'.concat(entity.commonType, ":").concat(entity.commonId, '".')
+        ]), _define_property$1(_this, "entity", void 0);
+        _this.entity = entity;
+        return _this;
     }
-}
+    return MultiplePrimarySyncSourceError;
+}(BaseError);
 /**
  * Error thrown when a synchronization fails for an entity.
- */
-class SynchronizationFailedError extends BaseError {
-    entity;
-    error;
-    constructor(entity, error) {
-        super(`Synchronization failed for entity "${entity.commonType}:${entity.commonId}". Error: ${error}`);
-        this.entity = entity;
-        this.error = error;
+ */ var SynchronizationFailedError = /*#__PURE__*/ function(BaseError) {
+    _inherits(SynchronizationFailedError, BaseError);
+    function SynchronizationFailedError(entity, error) {
+        _class_call_check(this, SynchronizationFailedError);
+        var _this;
+        _this = _call_super(this, SynchronizationFailedError, [
+            'Synchronization failed for entity "'.concat(entity.commonType, ":").concat(entity.commonId, '". Error: ').concat(error)
+        ]), _define_property$1(_this, "entity", void 0), _define_property$1(_this, "error", void 0);
+        _this.entity = entity;
+        _this.error = error;
+        return _this;
     }
-}
+    return SynchronizationFailedError;
+} 
+(BaseError);
 
 /**
  * Creates a {@link SyncEntitySynchronizer} from the given configuration.
@@ -1053,27 +1508,268 @@ class SynchronizationFailedError extends BaseError {
  * const instance = await synchronizer.synchronizeInstance({ commonType: 'user', commonId: '123' });
  * const result = await instance.synchronize();
  * ```
- */
-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);
+ */ function syncEntitySynchronizer(config) {
+    var map = new Map(config.commonTypeSynchronizers.map(function(x) {
+        return [
+            x.commonType,
+            x
+        ];
+    }));
+    var commonTypes = Array.from(map.keys());
+    var commonTypeSynchronizer = function commonTypeSynchronizer(input) {
+        var synchronizer = map.get(input);
         if (!synchronizer) {
             throw new UnregisteredSyncEntityCommonTypeError(input);
         }
         return synchronizer;
     };
     return {
-        commonTypes,
-        commonTypeSynchronizer,
-        synchronizeInstance: (input) => {
-            const synchronizer = commonTypeSynchronizer(input.commonType);
+        commonTypes: commonTypes,
+        commonTypeSynchronizer: commonTypeSynchronizer,
+        synchronizeInstance: function synchronizeInstance(input) {
+            var synchronizer = commonTypeSynchronizer(input.commonType);
             return synchronizer.synchronizeInstance(input);
         }
     };
 }
 
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_destructuring_empty(o) {
+    if (o === null || o === void 0) throw new TypeError("Cannot destructure " + o);
+    return o;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * Creates a {@link BasicSyncEntityCommonTypeSynchronizer} that orchestrates synchronization across multiple sources
  * for a specific entity common type.
@@ -1088,68 +1784,81 @@ function syncEntitySynchronizer(config) {
  * @throws {NoPrimarySyncSourceError} when no primary source is found
  * @throws {MultiplePrimarySyncSourceError} when more than one primary source is found
  * @throws {SynchronizationFailedError} when primary or secondary sync returns failed/error
- */
-function basicSyncEntityCommonTypeSynchronizerInstanceFactory(config) {
-    const { commonType, sources, entitySourceContextLoader, dynamicSources = false } = config;
-    const syncEntityCommonTypeIdPairForType = syncEntityCommonTypeIdPairFactory(commonType);
-    const sourcesByContextType = makeValuesGroupMap(sources, (x) => x.contextType);
-    const allGlobalSources = sourcesByContextType.get('global') ?? [];
-    const allContextSources = sourcesByContextType.get('context') ?? [];
+ */ function basicSyncEntityCommonTypeSynchronizerInstanceFactory(config) {
+    var _sourcesByContextType_get, _sourcesByContextType_get1;
+    var commonType = config.commonType, sources = config.sources, entitySourceContextLoader = config.entitySourceContextLoader, _config_dynamicSources = config.dynamicSources, dynamicSources = _config_dynamicSources === void 0 ? false : _config_dynamicSources;
+    var syncEntityCommonTypeIdPairForType = syncEntityCommonTypeIdPairFactory(commonType);
+    var sourcesByContextType = makeValuesGroupMap(sources, function(x) {
+        return x.contextType;
+    });
+    var allGlobalSources = (_sourcesByContextType_get = sourcesByContextType.get('global')) !== null && _sourcesByContextType_get !== void 0 ? _sourcesByContextType_get : [];
+    var allContextSources = (_sourcesByContextType_get1 = sourcesByContextType.get('context')) !== null && _sourcesByContextType_get1 !== void 0 ? _sourcesByContextType_get1 : [];
     /**
      * 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;
+     */ function loadSources(entityCommonTypeIdPair, entitySourceContext) {
+        var globalSources = entitySourceContext.globalSources, contextSources = entitySourceContext.contextSources;
         // load/filter global sources
-        const globalMap = new Map(globalSources.map((x) => {
-            let sourceId;
-            let flowType;
+        var globalMap = new Map(globalSources.map(function(x) {
+            var sourceId;
+            var flowType;
             if (typeof x === 'string') {
                 sourceId = x;
                 flowType = 'unset';
-            }
-            else {
+            } else {
                 sourceId = x.sourceId;
                 flowType = x.flowType;
             }
-            return [sourceId, { sourceId, flowType }];
+            return [
+                sourceId,
+                {
+                    sourceId: sourceId,
+                    flowType: flowType
+                }
+            ];
         }));
-        const relevantGlobalSources = filterMaybeArrayValues(allGlobalSources.map((x) => {
-            const sourceContext = globalMap.get(x.info.id);
-            let result;
+        var relevantGlobalSources = filterMaybeArrayValues(allGlobalSources.map(function(x) {
+            var sourceContext = globalMap.get(x.info.id);
+            var result;
             if (sourceContext != null) {
+                var _ref, _sourceContext_flowType;
                 result = {
-                    entityCommonTypeIdPair,
-                    flowType: sourceContext.flowType ?? x.defaultFlowType ?? 'unset',
+                    entityCommonTypeIdPair: entityCommonTypeIdPair,
+                    flowType: (_ref = (_sourceContext_flowType = sourceContext.flowType) !== null && _sourceContext_flowType !== void 0 ? _sourceContext_flowType : x.defaultFlowType) !== null && _ref !== void 0 ? _ref : 'unset',
                     source: x
                 };
             }
             return result;
         }));
         // load/filter context sources
-        const contextMap = new Map(contextSources.map((x) => [x.sourceId, x]));
-        const relevantContextSources = filterMaybeArrayValues(allContextSources.map((x) => {
-            const sourceContext = contextMap.get(x.info.id);
-            let result;
+        var contextMap = new Map(contextSources.map(function(x) {
+            return [
+                x.sourceId,
+                x
+            ];
+        }));
+        var relevantContextSources = filterMaybeArrayValues(allContextSources.map(function(x) {
+            var sourceContext = contextMap.get(x.info.id);
+            var result;
             if (sourceContext != null) {
-                const flowType = sourceContext.flowType ?? x.defaultFlowType ?? 'unset';
+                var _ref, _sourceContext_flowType;
+                var flowType = (_ref = (_sourceContext_flowType = sourceContext.flowType) !== null && _sourceContext_flowType !== void 0 ? _sourceContext_flowType : x.defaultFlowType) !== null && _ref !== void 0 ? _ref : 'unset';
                 result = {
-                    entityCommonTypeIdPair,
-                    flowType,
+                    entityCommonTypeIdPair: entityCommonTypeIdPair,
+                    flowType: flowType,
                     source: x,
                     context: sourceContext
                 };
             }
             return result;
         }));
-        const allSources = [...relevantGlobalSources, ...relevantContextSources];
+        var allSources = _to_consumable_array(relevantGlobalSources).concat(_to_consumable_array(relevantContextSources));
         // sort by order, with primary first
-        allSources.sort(sortByNumberFunction((x) => {
-            let result;
-            switch (x.flowType) {
+        allSources.sort(sortByNumberFunction(function(x) {
+            var result;
+            switch(x.flowType){
                 case 'primary':
                     result = 1;
                     break;
@@ -1165,123 +1874,458 @@ function basicSyncEntityCommonTypeSynchronizerInstanceFactory(config) {
         }));
         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 = cachedGetter(_loadRelevantSources);
-        }
-        /**
+    var synchronizeInstance = function synchronizeInstance(input) {
+        return _async_to_generator$2(function() {
+            var syncEntityCommonTypeIdPair, _loadRelevantSources, loadRelevantSources, synchronize, instance;
+            return _ts_generator$2(this, function(_state) {
+                syncEntityCommonTypeIdPair = syncEntityCommonTypeIdPairForType(input);
+                _loadRelevantSources = function _loadRelevantSources() {
+                    return _async_to_generator$2(function() {
+                        var entitySourceContext, relevantSources;
+                        return _ts_generator$2(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        entitySourceContextLoader(syncEntityCommonTypeIdPair)
+                                    ];
+                                case 1:
+                                    entitySourceContext = _state.sent();
+                                    relevantSources = loadSources(syncEntityCommonTypeIdPair, entitySourceContext);
+                                    return [
+                                        2,
+                                        relevantSources
+                                    ];
+                            }
+                        });
+                    })();
+                };
+                if (dynamicSources) {
+                    // if dynamic, reload each time and do not cache
+                    loadRelevantSources = _loadRelevantSources;
+                } else {
+                    // if not dynamic, make a cached getter
+                    loadRelevantSources = 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 = 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) {
+         */ synchronize = function synchronize(context) {
+                    return _async_to_generator$2(function() {
+                        var _sourcesByFlowType_get, _sourcesByFlowType_get1, _sourcesByFlowType_get2, relevantSources, syncEntityInstances, sourcesByFlowType, primarySources, secondarySources, replicaSources, result;
+                        function synchronizeInstance(source, deleted) {
+                            var _source = _sliced_to_array(source, 2), _$input = _source[0], sourceInstance = _source[1];
+                            var promise = deleted ? sourceInstance.synchronizeDelete() : sourceInstance.synchronize();
+                            return promise.catch(function(error) {
+                                var errorResult = {
+                                    type: 'error',
+                                    error: error,
+                                    entity: _object_spread_props(_object_spread({}, syncEntityCommonTypeIdPair), {
+                                        sourceInfo: _$input.source.info,
+                                        id: ''
+                                    })
+                                };
+                                return errorResult;
+                            });
+                        }
+                        function performSynchronizationOfSources(input) {
+                            return _async_to_generator$2(function() {
+                                var syncRecursionDepth, secondaryFlaggedDelete, result, primarySource, primarySyncResult, synchronizedEntityResults, primaryFlaggedDelete, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, secondarySource, secondarySyncResult, _, err, replicaTaskResults;
+                                return _ts_generator$2(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            syncRecursionDepth = input.syncRecursionDepth, secondaryFlaggedDelete = input.secondaryFlaggedDelete;
+                                            // synchronize the primary source
+                                            primarySource = primarySources[0];
+                                            return [
+                                                4,
+                                                synchronizeInstance(primarySource, secondaryFlaggedDelete !== null && secondaryFlaggedDelete !== void 0 ? secondaryFlaggedDelete : false)
+                                            ];
+                                        case 1:
+                                            primarySyncResult = _state.sent();
+                                            synchronizedEntityResults = [
+                                                primarySyncResult
+                                            ];
+                                            primaryFlaggedDelete = false;
+                                            switch(primarySyncResult.type){
+                                                case 'deleted':
+                                                    primaryFlaggedDelete = true;
+                                                    break;
+                                                case 'failed':
+                                                case 'error':
+                                                    throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, primarySyncResult.error);
+                                            }
+                                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                            _state.label = 2;
+                                        case 2:
+                                            _state.trys.push([
+                                                2,
+                                                13,
+                                                14,
+                                                15
+                                            ]);
+                                            _iterator = secondarySources[Symbol.iterator]();
+                                            _state.label = 3;
+                                        case 3:
+                                            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                                3,
+                                                12
+                                            ];
+                                            secondarySource = _step.value;
+                                            return [
+                                                4,
+                                                synchronizeInstance(secondarySource, primaryFlaggedDelete)
+                                            ];
+                                        case 4:
+                                            secondarySyncResult = _state.sent();
+                                            synchronizedEntityResults.push(secondarySyncResult);
+                                            _ = secondarySyncResult.type;
+                                            switch(_){
+                                                case 'deleted':
+                                                    return [
+                                                        3,
+                                                        5
+                                                    ];
+                                                case 'failed':
+                                                    return [
+                                                        3,
+                                                        9
+                                                    ];
+                                                case 'error':
+                                                    return [
+                                                        3,
+                                                        9
+                                                    ];
+                                                case 'nochange':
+                                                    return [
+                                                        3,
+                                                        10
+                                                    ];
+                                                case 'synchronized':
+                                                    return [
+                                                        3,
+                                                        10
+                                                    ];
+                                            }
+                                            return [
+                                                3,
+                                                10
+                                            ];
+                                        case 5:
+                                            if (!(primaryFlaggedDelete === false)) return [
+                                                3,
+                                                8
+                                            ];
+                                            if (!(syncRecursionDepth === 1)) return [
+                                                3,
+                                                7
+                                            ];
+                                            return [
+                                                4,
+                                                performSynchronizationOfSources({
+                                                    syncRecursionDepth: syncRecursionDepth + 1,
+                                                    secondaryFlaggedDelete: true
+                                                })
+                                            ];
+                                        case 6:
+                                            result = _state.sent();
+                                            return [
+                                                3,
+                                                7
+                                            ];
+                                        case 7:
+                                            return [
+                                                3,
+                                                11
+                                            ];
+                                        case 8:
+                                            return [
+                                                3,
+                                                11
+                                            ];
+                                        case 9:
+                                            throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, secondarySyncResult.error);
+                                        case 10:
+                                            // continue normally
+                                            return [
+                                                3,
+                                                11
+                                            ];
+                                        case 11:
+                                            _iteratorNormalCompletion = true;
+                                            return [
+                                                3,
+                                                3
+                                            ];
+                                        case 12:
+                                            return [
+                                                3,
+                                                15
+                                            ];
+                                        case 13:
+                                            err = _state.sent();
+                                            _didIteratorError = true;
+                                            _iteratorError = err;
+                                            return [
+                                                3,
+                                                15
+                                            ];
+                                        case 14:
+                                            try {
+                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                    _iterator.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError) {
+                                                    throw _iteratorError;
+                                                }
+                                            }
+                                            return [
+                                                7
+                                            ];
+                                        case 15:
+                                            if (!(result == null)) return [
+                                                3,
+                                                17
+                                            ];
+                                            return [
+                                                4,
+                                                performAsyncTasks(replicaSources, function(x) {
+                                                    return synchronizeInstance(x, primaryFlaggedDelete);
+                                                }, {
+                                                    sequential: false,
+                                                    maxParallelTasks: 3
+                                                })
+                                            ];
+                                        case 16:
+                                            replicaTaskResults = _state.sent();
+                                            // add all the results
+                                            pushArrayItemsIntoArray(synchronizedEntityResults, replicaTaskResults.results.map(function(x) {
+                                                return x[1];
+                                            }));
+                                            // compute final result
+                                            result = {
+                                                synchronizedEntityResults: synchronizedEntityResults
+                                            };
+                                            _state.label = 17;
+                                        case 17:
+                                            return [
+                                                2,
+                                                result
+                                            ];
+                                    }
+                                });
+                            })();
+                        }
+                        return _ts_generator$2(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _object_destructuring_empty(context !== null && context !== void 0 ? context : {});
+                                    return [
+                                        4,
+                                        loadRelevantSources()
+                                    ];
+                                case 1:
+                                    relevantSources = _state.sent();
+                                    return [
+                                        4,
+                                        Promise.all(relevantSources.map(function(x) {
+                                            return x.source.syncEntityInstance(x).then(function(y) {
+                                                return [
+                                                    x,
+                                                    y
+                                                ];
+                                            });
+                                        }))
+                                    ];
+                                case 2:
+                                    syncEntityInstances = _state.sent();
+                                    sourcesByFlowType = makeValuesGroupMap(syncEntityInstances, function(x) {
+                                        return x[0].flowType;
+                                    });
+                                    primarySources = (_sourcesByFlowType_get = sourcesByFlowType.get('primary')) !== null && _sourcesByFlowType_get !== void 0 ? _sourcesByFlowType_get : [];
+                                    secondarySources = (_sourcesByFlowType_get1 = sourcesByFlowType.get('secondary')) !== null && _sourcesByFlowType_get1 !== void 0 ? _sourcesByFlowType_get1 : [];
+                                    replicaSources = (_sourcesByFlowType_get2 = sourcesByFlowType.get('replica')) !== null && _sourcesByFlowType_get2 !== void 0 ? _sourcesByFlowType_get2 : [];
+                                    // assert primary sources count
+                                    switch(primarySources.length){
+                                        case 0:
+                                            throw new NoPrimarySyncSourceError(syncEntityCommonTypeIdPair);
+                                        case 1:
+                                            break;
+                                        default:
+                                            throw new MultiplePrimarySyncSourceError(syncEntityCommonTypeIdPair);
+                                    }
+                                    return [
+                                        4,
+                                        performSynchronizationOfSources({
+                                            syncRecursionDepth: 0
+                                        })
+                                    ];
+                                case 3:
+                                    result = _state.sent();
+                                    return [
+                                        2,
+                                        {
+                                            targetPair: syncEntityCommonTypeIdPair,
+                                            entitiesSynchronized: result.synchronizedEntityResults
+                                        }
+                                    ];
+                            }
+                        });
+                    })();
+                };
+                instance = {
+                    entityPair: syncEntityCommonTypeIdPair,
+                    synchronize: synchronize
+                };
+                return [
+                    2,
+                    instance
+                ];
+            });
+        })();
+    };
+    var result = {
+        commonType: commonType,
+        synchronizeInstance: synchronizeInstance
+    };
+    return result;
+}
+
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
                 case 0:
-                    throw new NoPrimarySyncSourceError(syncEntityCommonTypeIdPair);
                 case 1:
+                    t = op;
                     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: ''
-                        }
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
                     };
-                    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;
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
                         break;
-                    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 performAsyncTasks(replicaSources, (x) => synchronizeInstance(x, primaryFlaggedDelete), {
-                        sequential: false,
-                        maxParallelTasks: 3
-                    });
-                    // add all the results
-                    pushArrayItemsIntoArray(synchronizedEntityResults, replicaTaskResults.results.map((x) => x[1]));
-                    // compute final result
-                    result = {
-                        synchronizedEntityResults
-                    };
-                }
-                return result;
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
             }
-            const result = await performSynchronizationOfSources({ });
-            return {
-                targetPair: syncEntityCommonTypeIdPair,
-                entitiesSynchronized: result.synchronizedEntityResults
-            };
-        };
-        const instance = {
-            entityPair: syncEntityCommonTypeIdPair,
-            synchronize
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
         };
-        return instance;
-    };
-    const result = {
-        commonType,
-        synchronizeInstance
-    };
-    return result;
+    }
 }
-
 /**
  * Creates a function that validates input against an ArkType schema and then processes it.
  *
@@ -1300,18 +2344,46 @@ function basicSyncEntityCommonTypeSynchronizerInstanceFactory(config) {
  *
  * const result = await processUser({ id: '123', name: 'John' });
  * ```
- */
-function transformAndValidateObject(config) {
-    const transformToResult = transformAndValidateObjectResult(config);
-    const { handleValidationError } = config;
-    return async (input, context) => {
-        const x = await transformToResult(input, context);
-        if (x.success) {
-            return { object: x.object, result: x.result };
-        }
-        // Error handler is expected to throw. If it doesn't, there is no validated object to return.
-        const result = await handleValidationError(x.validationErrors);
-        return { object: undefined, result };
+ */ function transformAndValidateObject(config) {
+    var transformToResult = transformAndValidateObjectResult(config);
+    var handleValidationError = config.handleValidationError;
+    return function(input, context) {
+        return _async_to_generator$1(function() {
+            var x, result;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            transformToResult(input, context)
+                        ];
+                    case 1:
+                        x = _state.sent();
+                        if (x.success) {
+                            return [
+                                2,
+                                {
+                                    object: x.object,
+                                    result: x.result
+                                }
+                            ];
+                        }
+                        return [
+                            4,
+                            handleValidationError(x.validationErrors)
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            2,
+                            {
+                                object: undefined,
+                                result: result
+                            }
+                        ];
+                }
+            });
+        })();
     };
 }
 /**
@@ -1322,14 +2394,13 @@ function transformAndValidateObject(config) {
  *
  * @param defaults - default error handler
  * @returns a factory function that creates TransformAndValidateObjectFunction instances
- */
-function transformAndValidateObjectFactory(defaults) {
-    const { handleValidationError: defaultHandleValidationError } = defaults;
-    return (schema, fn, handleValidationError) => {
-        const config = {
-            schema,
-            fn,
-            handleValidationError: handleValidationError ?? defaultHandleValidationError
+ */ function transformAndValidateObjectFactory(defaults) {
+    var defaultHandleValidationError = defaults.handleValidationError;
+    return function(schema, fn, handleValidationError) {
+        var config = {
+            schema: schema,
+            fn: fn,
+            handleValidationError: handleValidationError !== null && handleValidationError !== void 0 ? handleValidationError : defaultHandleValidationError
         };
         return transformAndValidateObject(config);
     };
@@ -1357,17 +2428,42 @@ function transformAndValidateObjectFactory(defaults) {
  *   console.log(result.validationErrors.summary);
  * }
  * ```
- */
-function transformAndValidateObjectResult(config) {
-    const { schema, fn } = config;
-    return async (input) => {
-        const out = schema(input);
-        if (out instanceof type.errors) {
-            return { validationErrors: out, success: false };
-        }
-        const object = out;
-        const result = await fn(object);
-        return { object, result, success: true };
+ */ function transformAndValidateObjectResult(config) {
+    var schema = config.schema, fn = config.fn;
+    return function(input) {
+        return _async_to_generator$1(function() {
+            var out, object, result;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        out = schema(input);
+                        if (_instanceof(out, type.errors)) {
+                            return [
+                                2,
+                                {
+                                    validationErrors: out,
+                                    success: false
+                                }
+                            ];
+                        }
+                        object = out;
+                        return [
+                            4,
+                            fn(object)
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            {
+                                object: object,
+                                result: result,
+                                success: true
+                            }
+                        ];
+                }
+            });
+        })();
     };
 }
 
@@ -1376,8 +2472,7 @@ function transformAndValidateObjectResult(config) {
  *
  * @param defaults - shared error handler defaults
  * @returns a factory that produces functions returning {@link TransformAndValidateFunctionResult}
- */
-function transformAndValidateFunctionResultFactory(defaults) {
+ */ function transformAndValidateFunctionResultFactory(defaults) {
     return toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory(defaults));
 }
 /**
@@ -1386,24 +2481,151 @@ function transformAndValidateFunctionResultFactory(defaults) {
  *
  * @param transformAndValidateObjectFactory - the base factory to wrap
  * @returns a factory that produces functions returning results with `params` attached
- */
-function toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory) {
-    return (schema, fn, handleValidationError) => {
-        const transformAndValidateObjectFn = transformAndValidateObjectFactory(schema, fn, handleValidationError);
-        return (input, context) => {
+ */ function toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory) {
+    return function(schema, fn, handleValidationError) {
+        var transformAndValidateObjectFn = transformAndValidateObjectFactory(schema, fn, handleValidationError);
+        return function(input, context) {
             return toTransformAndValidateFunctionResult(transformAndValidateObjectFn(input, context));
         };
     };
 }
 function toTransformAndValidateFunctionResult(objectOutput) {
-    return mapPromiseOrValue(objectOutput, (x) => {
-        const { object, result } = x;
-        const fnResult = result;
+    return mapPromiseOrValue(objectOutput, function(x) {
+        var object = x.object, result = x.result;
+        var fnResult = result;
         fnResult.params = object;
         return fnResult;
     });
 }
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * Creates a factory for transform-and-validate functions that return only the result (discarding the parsed object).
  *
@@ -1411,45 +2633,55 @@ function toTransformAndValidateFunctionResult(objectOutput) {
  *
  * @param defaults - shared error handler defaults
  * @returns a factory that produces functions returning only the handler's result
- */
-function transformAndValidateResultFactory(defaults) {
-    const factory = transformAndValidateObjectFactory(defaults);
-    return (schema, fn, handleValidationError) => {
-        const transformAndValidateObjectFn = factory(schema, fn, handleValidationError);
-        return async (input, context) => {
-            const { result } = await transformAndValidateObjectFn(input, context);
-            return result;
+ */ function transformAndValidateResultFactory(defaults) {
+    var factory = transformAndValidateObjectFactory(defaults);
+    return function(schema, fn, handleValidationError) {
+        var transformAndValidateObjectFn = factory(schema, fn, handleValidationError);
+        return function(input, context) {
+            return _async_to_generator(function() {
+                var result;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                transformAndValidateObjectFn(input, context)
+                            ];
+                        case 1:
+                            result = _state.sent().result;
+                            return [
+                                2,
+                                result
+                            ];
+                    }
+                });
+            })();
         };
     };
 }
 
 /**
  * ArkType schema for a model key (non-empty string).
- */
-const modelKeyType = type('string > 0');
+ */ var modelKeyType = type('string > 0');
 /**
  * ArkType schema for a model id (non-empty string).
- */
-const modelIdType = type('string > 0');
+ */ var modelIdType = type('string > 0');
 /**
  * ArkType schema for target model params with a required `key` field.
- */
-const targetModelParamsType = type({
+ */ var targetModelParamsType = type({
     key: modelKeyType
 });
 /**
  * ArkType schema for target model id params with a required `id` field.
- */
-const targetModelIdParamsType = type({
+ */ var targetModelIdParamsType = type({
     id: modelIdType
 });
 
 function clearable(definition) {
-    let result;
+    var result;
     if (typeof definition === 'string') {
-        result = `${definition} | null | undefined`;
-    }
-    else {
+        result = "".concat(definition, " | null | undefined");
+    } else {
         result = definition.or('null').or('undefined');
     }
     return result;
@@ -1464,43 +2696,49 @@ function clearable(definition) {
  * If we only used Date, or only used string.date.parse, then using the ArkType gets more specific to
  * those independent cases, and will cause validation errors if you end up passing the object of that type
  * rather than a freshly parsed JSON string POJO of that type.
- */
-const ARKTYPE_DATE_DTO_TYPE = 'Date | string.date.parse';
+ */ var ARKTYPE_DATE_DTO_TYPE = 'Date | string.date.parse';
 
 /**
  * ArkType schema for a valid ISO 8601 day string (e.g., "2024-01-15").
- */
-const iso8601DayStringType = type('string > 0').narrow((val, ctx) => (val != null && isISO8601DayString(val)) || ctx.mustBe('a valid ISO 8601 day string'));
+ */ var iso8601DayStringType = type('string > 0').narrow(function(val, ctx) {
+    return val != null && isISO8601DayString(val) || ctx.mustBe('a valid ISO 8601 day string');
+});
 
 /**
  * ArkType schema for a valid minute of the day (0-1439).
- */
-const minuteOfDayType = type('number').narrow((val, ctx) => (val != null && isMinuteOfDay(val)) || ctx.mustBe('a valid minute of the day (0-1439)'));
+ */ var minuteOfDayType = type('number').narrow(function(val, ctx) {
+    return val != null && isMinuteOfDay(val) || ctx.mustBe('a valid minute of the day (0-1439)');
+});
 
 /**
  * ArkType schema for a valid E.164 phone number without an extension.
- */
-const e164PhoneNumberType = type('string > 0').narrow((val, ctx) => (val != null && isE164PhoneNumber(val, false)) || ctx.mustBe('a valid E.164 phone number without an extension'));
+ */ var e164PhoneNumberType = type('string > 0').narrow(function(val, ctx) {
+    return val != null && isE164PhoneNumber(val, false) || ctx.mustBe('a valid E.164 phone number without an extension');
+});
 /**
  * ArkType schema for a valid E.164 phone number, optionally with an extension.
- */
-const e164PhoneNumberWithOptionalExtensionType = type('string > 0').narrow((val, ctx) => (val != null && isE164PhoneNumber(val, true)) || ctx.mustBe('a valid E.164 phone number'));
+ */ var e164PhoneNumberWithOptionalExtensionType = type('string > 0').narrow(function(val, ctx) {
+    return val != null && isE164PhoneNumber(val, true) || ctx.mustBe('a valid E.164 phone number');
+});
 /**
  * ArkType schema for a valid E.164 phone number that includes an extension.
- */
-const e164PhoneNumberWithExtensionType = type('string > 0').narrow((val, ctx) => (val != null && isE164PhoneNumberWithExtension(val)) || ctx.mustBe('a valid E.164 phone number with an extension'));
+ */ var e164PhoneNumberWithExtensionType = type('string > 0').narrow(function(val, ctx) {
+    return val != null && isE164PhoneNumberWithExtension(val) || ctx.mustBe('a valid E.164 phone number with an extension');
+});
 
 /**
  * ArkType schema for a valid {@link LatLngPoint} with lat in [-90, 90] and lng in [-180, 180].
- */
-const latLngPointType = type({
+ */ var latLngPointType = type({
     lat: '-90 <= number <= 90',
     lng: '-180 <= number <= 180'
-}).narrow((val, ctx) => (val != null && isValidLatLngPoint(val)) || ctx.mustBe('a valid LatLngPoint with lat in [-90, 90] and lng in [-180, 180]'));
+}).narrow(function(val, ctx) {
+    return val != null && isValidLatLngPoint(val) || ctx.mustBe('a valid LatLngPoint with lat in [-90, 90] and lng in [-180, 180]');
+});
 /**
  * ArkType schema for a valid {@link LatLngString} (comma-separated lat/lng, e.g. "30.5,-96.3").
- */
-const latLngStringType = type('string > 0').narrow((val, ctx) => (val != null && isLatLngString(val)) || ctx.mustBe('a valid lat,lng string (e.g. "30.5,-96.3")'));
+ */ var latLngStringType = type('string > 0').narrow(function(val, ctx) {
+    return val != null && isLatLngString(val) || ctx.mustBe('a valid lat,lng string (e.g. "30.5,-96.3")');
+});
 
 /**
  * Creates an ArkType schema that validates an array has no duplicate keys.
@@ -1512,20 +2750,22 @@ const latLngStringType = type('string > 0').narrow((val, ctx) => (val != null &&
  * ```typescript
  * const uniqueItemsType = uniqueKeyedType((item: Item) => item.id);
  * ```
- */
-function uniqueKeyedType(readKey) {
-    const isUniqueKeyed = isUniqueKeyedFunction(readKey);
-    return type('unknown[]').narrow((val, ctx) => (val != null && isUniqueKeyed(val)) || ctx.mustBe('an array with unique keys'));
+ */ function uniqueKeyedType(readKey) {
+    var isUniqueKeyed = isUniqueKeyedFunction(readKey);
+    return type('unknown[]').narrow(function(val, ctx) {
+        return val != null && isUniqueKeyed(val) || ctx.mustBe('an array with unique keys');
+    });
 }
 
 /**
  * ArkType schema for a valid website URL (with or without protocol prefix).
- */
-const websiteUrlType = type('string > 0').narrow((val, ctx) => (val != null && isWebsiteUrl(val)) || ctx.mustBe('a valid website URL'));
+ */ var websiteUrlType = type('string > 0').narrow(function(val, ctx) {
+    return val != null && isWebsiteUrl(val) || ctx.mustBe('a valid website URL');
+});
 /**
  * ArkType schema for a valid website URL that starts with `http://` or `https://`.
- */
-const websiteUrlWithPrefixType = type('string > 0').narrow((val, ctx) => (val != null && isWebsiteUrlWithPrefix(val)) || ctx.mustBe('a valid website URL starting with http:// or https://'));
+ */ var websiteUrlWithPrefixType = type('string > 0').narrow(function(val, ctx) {
+    return val != null && isWebsiteUrlWithPrefix(val) || ctx.mustBe('a valid website URL starting with http:// or https://');
+});
 
 export { ADDRESS_CITY_MAX_LENGTH, ADDRESS_COUNTRY_MAX_LENGTH, ADDRESS_LINE_MAX_LENGTH, ADDRESS_STATE_CODE_MAX_LENGTH, ADDRESS_STATE_MAX_LENGTH, ADDRESS_ZIP_MAX_LENGTH, ARKTYPE_DATE_DTO_TYPE, AbstractModelPermissionService, CASHAPP_BASE_URL, CASHAPP_USERNAME_PREFIX, CASHAPP_WEBSITE_LINK_TYPE, EMAIL_URL_WEBSITE_LINK_TYPE, FACEBOOK_BASE_URL, FACEBOOK_WEBSITE_LINK_TYPE, FULL_ACCESS_ROLE_KEY, GRANTED_ADMIN_ROLE_KEY, GRANTED_DELETE_ROLE_KEY, GRANTED_OWNER_ROLE_KEY, GRANTED_READ_ROLE_KEY, GRANTED_SYS_ADMIN_ROLE_KEY, GRANTED_UPDATE_ROLE_KEY, GrantedRoleMapReaderInstance, INSTAGRAM_BASE_URL, INSTAGRAM_WEBSITE_LINK_TYPE, NO_ACCESS_ROLE_KEY, PAYPAL_BASE_URL, PAYPAL_WEBSITE_LINK_TYPE, PHONE_URL_WEBSITE_LINK_TYPE, SNAPCHAT_BASE_URL, SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID, SNAPCHAT_WEBSITE_LINK_TYPE, SPOTIFY_BASE_URL, SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID, SPOTIFY_WEBSITE_LINK_TYPE, TIKTOK_BASE_URL, TIKTOK_USERNAME_PREFIX, TIKTOK_WEBSITE_LINK_TYPE, TWITTER_BASE_URL, TWITTER_WEBSITE_LINK_TYPE, UNKNOWN_WEBSITE_LINK_TYPE, VENMO_BASE_URL, VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID, VENMO_WEBSITE_LINK_TYPE, WEBSITE_FILE_LINK_DATA_MAX_LENGTH, WEBSITE_FILE_LINK_DATA_REGEX, WEBSITE_FILE_LINK_ENCODE_SEPARATOR, WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH, WEBSITE_FILE_LINK_MIME_TYPE_REGEX, WEBSITE_FILE_LINK_NAME_MAX_LENGTH, WEBSITE_FILE_LINK_TYPE_MAX_LENGTH, WEBSITE_FILE_LINK_TYPE_REGEX, WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE, WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH, WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID, WEBSITE_LINK_TYPE_MAX_LENGTH, WEBSITE_LINK_TYPE_REGEX, WEBSITE_URL_WEBSITE_LINK_TYPE, YOUTUBE_BASE_URL, YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID, YOUTUBE_WEBSITE_LINK_TYPE, basicSyncEntityCommonTypeSynchronizerInstanceFactory, cashappProfileUrl, cashappProfileUrlToWebsiteLink, clearable, contextGrantedModelRoles, decodeWebsiteLinkEncodedDataToWebsiteFileLink, e164PhoneNumberType, e164PhoneNumberWithExtensionType, e164PhoneNumberWithOptionalExtensionType, emailAddressToWebsiteLink, encodeWebsiteFileLinkToWebsiteLinkEncodedData, facebookProfileUrl, facebookProfileUrlToWebsiteLink, fullAccessGrantedModelRoles, fullAccessRoleMap, grantedRoleKeysMapFromArray, grantedRoleMapReader, instagramProfileUrl, instagramProfileUrlToWebsiteLink, isFullAccessRoleMap, isGrantedAdminLevelRole, isNoAccessRoleMap, isValidWebsiteLinkType, iso8601DayStringType, latLngPointType, latLngStringType, minuteOfDayType, modelIdType, modelKeyType, noAccessContextGrantedModelRoles, noAccessRoleMap, paypalProfileUrl, paypalProfileUrlToWebsiteLink, phoneNumberToWebsiteLink, snapchatProfileUrl, snapchatProfileUrlToWebsiteLink, spotifyProfileUrl, spotifyProfileUrlToWebsiteLink, syncEntityCommonTypeIdPairFactory, syncEntityFactory, syncEntitySynchronizer, targetModelIdParamsType, targetModelParamsType, tiktokProfileUrl, tiktokProfileUrlToWebsiteLink, toTransformAndValidateFunctionResult, toTransformAndValidateFunctionResultFactory, transformAndValidateFunctionResultFactory, transformAndValidateObject, transformAndValidateObjectFactory, transformAndValidateObjectResult, transformAndValidateResultFactory, twitterProfileUrl, twitterProfileUrlToWebsiteLink, uniqueKeyedType, unitedStatesAddressWithStateCodeType, unitedStatesAddressWithStateStringType, usernameFromUsernameOrWebsiteWithBaseUrlUsername, usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername, usernameOrWebsiteUrlToWebsiteUrl, venmoProfileUrl, venmoProfileUrlToWebsiteLink, websiteFileLinkToWebsiteLink, websiteFileLinkType, websiteLinkToWebsiteLinkFile, websiteLinkType, websiteUrlToWebsiteLink, websiteUrlType, websiteUrlWithPrefixType, youtubeProfileUrl, youtubeProfileUrlToWebsiteLink };
-//# sourceMappingURL=index.esm.js.map