@meltwater/conversations-api-services 1.1.24 → 1.2.2

package/dist/cjs/data-access/http/twitter.native.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.addOAuthToToken = addOAuthToToken;
 exports.followUser = followUser;
+exports.getAuthenticatedUser = getAuthenticatedUser;
 exports.getBrandUserRelationship = getBrandUserRelationship;
 exports.getCurrentInfo = getCurrentInfo;
 exports.getDirectMessageImage = getDirectMessageImage;
@@ -27,7 +28,6 @@ var _oauth = _interopRequireDefault(require("oauth-1.0a"));
 var _crypto = _interopRequireDefault(require("crypto"));
 var _axios = _interopRequireDefault(require("axios"));
 var _fs = _interopRequireDefault(require("fs"));
-var _socialTwit = _interopRequireDefault(require("@meltwater/social-twit"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const TWITTER_API_CONFIG = {
   v1_1: {
@@ -135,6 +135,28 @@ function normalizeUsersData(users) {
   }
   return normalizeUserData(users, apiVersion);
 }
+
+/**
+ * Get authenticated user information using Twitter API v2
+ * @param {Object} token - OAuth token object
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} User data from v2 API
+ */
+async function getAuthenticatedUser(token, logger) {
+  try {
+    const result = await getRequest({
+      token,
+      uri: 'https://api.x.com/2/users/me',
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
+      logger
+    });
+    return result.data;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting authenticated user info`, e);
+    throw e;
+  }
+}
 function addOAuthToToken(token, TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET) {
   if (!token.oauth) {
     token.oauth = (0, _oauth.default)({
@@ -230,7 +252,7 @@ async function getCurrentInfo(token, externalId, logger) {
     });
 
     // this makes it so 'retweeted' is only true on a retweet that isn't a comment
-    // sometimes 'retweeted' is true if user retweeted with comment, sometimes not :sadness:
+    // sometimes 'retweeted' is true if user retweeted with comment, sometimes not
     result.data.retweeted = !!result.data.current_user_retweet;
     return result.data.data[0].public_metrics;
   } catch (error) {
@@ -293,12 +315,20 @@ async function unRetweet(token, sourceId, externalId, logger) {
 }
 async function like(token, externalId, logger) {
   try {
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
     let response = await postRequest({
       token,
-      uri: 'favorites/create.json?id=' + (0, _externalIdHelpers.removePrefix)(externalId),
+      uri: `https://api.x.com/2/users/${userId}/likes`,
+      payload: {
+        tweet_id: (0, _externalIdHelpers.removePrefix)(externalId)
+      },
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+    if (response.data.data?.liked !== undefined && response.resp.statusCode === 200) {
       return true;
     } else {
       (0, _loggerHelpers.loggerInfo)(logger, 'Twitter Error in like user statusCode non 200 ', {
@@ -313,12 +343,17 @@ async function like(token, externalId, logger) {
 }
 async function unLike(token, externalId, logger) {
   try {
-    let response = await postRequest({
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
+    let response = await deleteRequest({
       token,
-      uri: 'favorites/destroy.json?id=' + (0, _externalIdHelpers.removePrefix)(externalId),
+      uri: `https://api.x.com/2/users/${userId}/likes/${(0, _externalIdHelpers.removePrefix)(externalId)}`,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+    if (response.data.data?.liked !== undefined && response.resp.statusCode === 200) {
       return true;
     } else {
       return false;
@@ -330,16 +365,20 @@ async function unLike(token, externalId, logger) {
 }
 async function followUser(token, profileId, logger) {
   try {
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
     let response = await postRequest({
       token,
-      uri: 'friendships/create.json',
+      uri: `https://api.x.com/2/users/${userId}/following`,
       payload: {
-        user_id: (0, _externalIdHelpers.removePrefix)(profileId),
-        follow: true
+        target_user_id: (0, _externalIdHelpers.removePrefix)(profileId)
       },
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.following !== undefined) {
+    if (response.data.data?.following !== undefined) {
       return true;
     } else {
       return false;
@@ -350,15 +389,17 @@ async function followUser(token, profileId, logger) {
 }
 async function unFollowUser(token, profileId, logger) {
   try {
-    let response = await postRequest({
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
+    let response = await deleteRequest({
       token,
-      uri: 'friendships/destroy.json',
-      payload: {
-        user_id: (0, _externalIdHelpers.removePrefix)(profileId)
-      },
+      uri: `https://api.x.com/2/users/${userId}/following/${(0, _externalIdHelpers.removePrefix)(profileId)}`,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.following !== undefined) {
+    if (response.data.data?.following !== undefined) {
       return true;
     } else {
       return false;
@@ -369,26 +410,34 @@ async function unFollowUser(token, profileId, logger) {
 }
 async function userFollowStatus(token, profileId, logger) {
   try {
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
+
+    // Check if authenticated user is following the target user
+    // We need to check the following list with pagination support
     let response = await getRequest({
       token,
-      uri: 'friendships/lookup.json',
+      uri: `https://api.x.com/2/users/${userId}/following`,
       payload: {
-        user_id: (0, _externalIdHelpers.removePrefix)(profileId)
+        max_results: 1000 // Max allowed per request
       },
+      attachUrlPrefix: false,
+      convertPayloadToUri: true,
       logger
     });
-    if (response.data.length > 0) {
-      if (response.data[0].connections.length > 0) {
-        for (var i = 0; i < response.data[0].connections.length; i++) {
-          if (response.data[0].connections[i] === 'following') {
-            return true;
-          }
-        }
-        return false;
-      } else {
-        return false;
+    if (response.data?.data) {
+      // Check if the profileId is in the following list
+      const isFollowing = response.data.data.some(user => user.id === (0, _externalIdHelpers.removePrefix)(profileId));
+      if (isFollowing) {
+        return true;
       }
+
+      // If not found and there's a next page, we might need to paginate
+      // For now, return false if not in first page
+      return false;
     }
+    return false;
   } catch (error) {
     (0, _loggerHelpers.loggerDebug)(logger, `Error in getting user follow status: ${profileId}`, error);
     if (error.message != 'Bad Request') {
@@ -400,16 +449,58 @@ async function userFollowStatus(token, profileId, logger) {
 }
 async function getBrandUserRelationship(token, profileId, brandProfileId, logger) {
   try {
-    let {
-      data: {
-        relationship
-      } = {}
-    } = await getRequest({
-      token,
-      uri: `friendships/show.json?source_id=${brandProfileId}&target_id=${(0, _externalIdHelpers.removePrefix)(profileId)}`,
-      logger
-    });
-    return relationship;
+    // In v2 API, we need to make separate calls to check following/followers status
+    // Check if brand follows user
+    let brandFollowsUser = false;
+    let userFollowsBrand = false;
+    try {
+      const followingResponse = await getRequest({
+        token,
+        uri: `https://api.x.com/2/users/${brandProfileId}/following`,
+        payload: {
+          max_results: 1000
+        },
+        attachUrlPrefix: false,
+        convertPayloadToUri: true,
+        logger
+      });
+      if (followingResponse.data?.data) {
+        brandFollowsUser = followingResponse.data.data.some(user => user.id === (0, _externalIdHelpers.removePrefix)(profileId));
+      }
+    } catch (e) {
+      (0, _loggerHelpers.loggerWarn)(logger, 'Error checking if brand follows user', e);
+    }
+    try {
+      const followersResponse = await getRequest({
+        token,
+        uri: `https://api.x.com/2/users/${brandProfileId}/followers`,
+        payload: {
+          max_results: 1000
+        },
+        attachUrlPrefix: false,
+        convertPayloadToUri: true,
+        logger
+      });
+      if (followersResponse.data?.data) {
+        userFollowsBrand = followersResponse.data.data.some(user => user.id === (0, _externalIdHelpers.removePrefix)(profileId));
+      }
+    } catch (e) {
+      (0, _loggerHelpers.loggerWarn)(logger, 'Error checking if user follows brand', e);
+    }
+
+    // Build a relationship object similar to v1.1 format
+    return {
+      source: {
+        id_str: brandProfileId,
+        following: brandFollowsUser,
+        followed_by: userFollowsBrand
+      },
+      target: {
+        id_str: (0, _externalIdHelpers.removePrefix)(profileId),
+        following: userFollowsBrand,
+        followed_by: brandFollowsUser
+      }
+    };
   } catch (error) {
     (0, _loggerHelpers.loggerDebug)(logger, `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`, error);
   }
@@ -441,34 +532,21 @@ async function reply(token, text, attachment, inReplyToId, removeInReplyToId, lo
   return publishTweet(token, payload, query, false, logger);
 }
 async function privateMessage(token, text, attachment, profileId, logger) {
-  let query = 'direct_messages/events/new.json';
+  let query = `https://api.x.com/2/dm_conversations/with/${(0, _externalIdHelpers.removePrefix)(profileId)}/messages`;
   let mediaId;
   if (attachment) {
     // discussionType only matters if DM or Not
     mediaId = await uploadMedia(attachment, token, 'dm', logger);
   }
   const payload = {
-    event: {
-      type: 'message_create',
-      message_create: {
-        target: {
-          recipient_id: (0, _externalIdHelpers.removePrefix)(profileId)
-        },
-        message_data: {
-          text: text || ' ',
-          ...(attachment && {
-            attachment: {
-              type: 'media',
-              media: {
-                id: mediaId
-              }
-            }
-          })
-        }
-      }
-    }
+    text: text || ' ',
+    ...(attachment && {
+      attachments: [{
+        media_id: mediaId
+      }]
+    })
   };
-  return publishTweet(token, payload, query, true, logger);
+  return publishDirectMessage(token, payload, query, logger);
 }
 async function retweetWithComment(token, text, attachment, logger) {
   let mediaId;
@@ -487,6 +565,84 @@ async function retweetWithComment(token, text, attachment, logger) {
   let query = 'https://api.twitter.com/2/tweets';
   return publishTweet(token, payload, query, false, logger);
 }
+
+/**
+ * Normalizes Twitter API responses to ensure consistent structure across v1.1 and v2
+ * This is critical for backward compatibility - consumers expect certain fields to exist
+ *
+ * @param {Object} response - The response object to normalize
+ * @param {string} responseType - Type of response: 'dm' for direct messages, 'tweet' for tweets
+ * @param {Object} logger - Logger instance for debugging
+ * @param {Object} fullResponse - Full API response including includes (for extracting author_id from expansions)
+ * @returns {Object} Normalized response with consistent field structure
+ */
+function normalizeTwitterResponse(response, responseType, logger) {
+  let fullResponse = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  if (!response || !response.data) {
+    return response;
+  }
+  (0, _loggerHelpers.loggerDebug)(logger, `Normalizing Twitter API response (${responseType})`, {
+    beforeNormalization: JSON.stringify(response.data)
+  });
+
+  // Handle Twitter API v2 Direct Message responses
+  // v2 DM structure: { dm_event_id, dm_conversation_id }
+  // v1.1 expected structure: { id, author_id }
+  if (responseType === 'dm' && response.data.dm_event_id) {
+    const normalizedData = {
+      ...response.data,
+      // Add v1.1-compatible fields for backward compatibility
+      id: response.data.dm_event_id,
+      // Note: author_id is intentionally not set here. The caller (twitterApi.client.js)
+      // will set the correct author_id from the original document since dm_conversation_id
+      // doesn't reliably indicate the sender (it's just "user1-user2" format)
+      author_id: null
+    };
+    (0, _loggerHelpers.loggerInfo)(logger, `Normalized Twitter API v2 DM response to v1.1 format`, {
+      dm_event_id: response.data.dm_event_id,
+      normalized_id: normalizedData.id,
+      dm_conversation_id: response.data.dm_conversation_id,
+      normalized_author_id: normalizedData.author_id
+    });
+    return {
+      ...response,
+      data: normalizedData
+    };
+  }
+
+  // Handle Twitter API v2 Tweet responses
+  // v2 has 'id' field but author_id is in expansions (includes.users)
+  if (responseType === 'tweet' && response.data.id) {
+    const normalizedData = {
+      ...response.data
+    };
+
+    // If author_id is missing but we have includes.users from expansions
+    if (!normalizedData.author_id && fullResponse?.includes?.users?.[0]?.id) {
+      normalizedData.author_id = fullResponse.includes.users[0].id;
+      (0, _loggerHelpers.loggerInfo)(logger, `Added author_id to tweet response from expansions`, {
+        tweet_id: normalizedData.id,
+        author_id: normalizedData.author_id
+      });
+    } else if (normalizedData.author_id) {
+      (0, _loggerHelpers.loggerDebug)(logger, `Twitter v2 tweet response already has 'author_id'`, {
+        id: response.data.id,
+        author_id: normalizedData.author_id
+      });
+    } else {
+      (0, _loggerHelpers.loggerWarn)(logger, `Twitter v2 tweet response missing author_id and no expansions available`, {
+        id: response.data.id,
+        hasIncludes: !!fullResponse?.includes,
+        hasUsers: !!fullResponse?.includes?.users
+      });
+    }
+    return {
+      ...response,
+      data: normalizedData
+    };
+  }
+  return response;
+}
 async function publishTweet(token, payload, query, isDirectMessage, logger) {
   try {
     let nativeResponse = await postRequest({
@@ -521,12 +677,50 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
     (0, _loggerHelpers.loggerDebug)(logger, `Twitter the data response is`, {
       response: JSON.stringify(response)
     });
-    return response;
+
+    // Normalize the response to ensure backward compatibility with v1.1 structure
+    // Pass full nativeResponse to extract author_id from expansions if needed
+    const normalizedResponse = normalizeTwitterResponse(response, 'tweet', logger, nativeResponse.data // Full response with includes.users for author_id
+    );
+    return normalizedResponse;
   } catch (err) {
     (0, _loggerHelpers.loggerError)(logger, `Twitter publish exception details`, err);
     throw err;
   }
 }
+async function publishDirectMessage(token, payload, query, logger) {
+  try {
+    let nativeResponse = await postRequest({
+      token,
+      uri: query,
+      payload,
+      convertPayloadToUri: false,
+      attachUrlPrefix: false
+    });
+    (0, _loggerHelpers.loggerInfo)(logger, `finished sending DM via Twitter API v2`, {
+      data: JSON.stringify(nativeResponse.data)
+    });
+    const response = nativeResponse.resp ? {
+      statusCode: nativeResponse.resp.statusCode,
+      statusMessage: nativeResponse.resp.statusCode === 201 || nativeResponse.resp.statusCode === 200 ? 'Success' : 'Unknown Failure',
+      data: nativeResponse.data.data
+    } : {
+      statusCode: nativeResponse.statusCode,
+      statusMessage: nativeResponse.message
+    };
+    (0, _loggerHelpers.loggerDebug)(logger, `Twitter DM response is`, {
+      response: JSON.stringify(response)
+    });
+
+    // Normalize the response to ensure backward compatibility with v1.1 structure
+    // This is CRITICAL - v2 DM responses have dm_event_id instead of id
+    const normalizedResponse = normalizeTwitterResponse(response, 'dm', logger);
+    return normalizedResponse;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Twitter DM exception details`, err);
+    throw err;
+  }
+}
 async function postRequest(_ref2) {
   let {
     token,
@@ -685,32 +879,177 @@ function generateFilePath(mimeType, dirname) {
 }
 // local
 async function uploadMedia(attachment, token, discussionType, logger) {
-  return new Promise(async (resolve, reject) => {
-    let filePath = generateFilePath(attachment.mimeType, attachment.__dirname);
+  let filePath;
+  try {
+    filePath = generateFilePath(attachment.mimeType, attachment.__dirname);
     await downloadImage(attachment.url, filePath);
-    const T = new _socialTwit.default({
-      consumer_key: token.consumer_key,
-      consumer_secret: token.consumer_secret,
-      access_token: token.token,
-      access_token_secret: token.tokenSecret
+    const mediaCategory = discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+    const fileStats = _fs.default.statSync(filePath);
+    const fileSize = fileStats.size;
+    const fileData = _fs.default.readFileSync(filePath);
+
+    // For small files, use simple upload
+    if (fileSize < 5000000) {
+      // 5MB
+      const mediaIdString = await simpleMediaUpload(fileData, attachment.mimeType, token, logger);
+      removeMedia(filePath, logger);
+      return mediaIdString;
+    } else {
+      // For large files, use chunked upload
+      const mediaIdString = await chunkedMediaUpload(filePath, fileSize, attachment.mimeType, mediaCategory, token, logger);
+      removeMedia(filePath, logger);
+      return mediaIdString;
+    }
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed uploading media`, e);
+    if (filePath) {
+      removeMedia(filePath, logger);
+    }
+    throw e;
+  }
+}
+
+// Simple upload for small media files
+async function simpleMediaUpload(fileData, mimeType, token, logger) {
+  try {
+    const base64Data = fileData.toString('base64');
+    const mediaType = mimeType.split('/')[0]; // 'image', 'video', etc.
+
+    const url = 'https://upload.twitter.com/1.1/media/upload.json';
+    const {
+      Authorization
+    } = token.oauth.toHeader(token.oauth.authorize({
+      url,
+      method: 'post',
+      data: {}
+    }, {
+      key: token.token,
+      secret: token.tokenSecret
+    }));
+    const result = await _superagent.default.post(url).set('Authorization', Authorization).send({
+      media_data: base64Data,
+      media_type: mimeType
     });
-    let mediaCategory = discussionType === 'dm' ? 'dm' : 'tweet';
-    try {
-      T.postMediaChunked({
-        file_path: filePath
-      }, mediaCategory, function (err, data, response) {
-        if (err) {
-          reject(err);
-        }
-        resolve(data.media_id_string);
-        removeMedia(filePath, logger);
+    (0, _loggerHelpers.loggerDebug)(logger, 'Media uploaded successfully (simple)', {
+      media_id: result.body.media_id_string
+    });
+    return result.body.media_id_string;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in simple media upload', e);
+    throw e;
+  }
+}
+
+// Chunked upload for large media files
+async function chunkedMediaUpload(filePath, fileSize, mimeType, mediaCategory, token, logger) {
+  try {
+    const mediaType = mimeType.split('/')[0];
+
+    // Step 1: INIT
+    const initResponse = await mediaUploadRequest({
+      command: 'INIT',
+      total_bytes: fileSize,
+      media_type: mimeType,
+      media_category: mediaCategory
+    }, token, logger);
+    const mediaId = initResponse.media_id_string;
+    (0, _loggerHelpers.loggerDebug)(logger, 'Media upload INIT successful', {
+      mediaId
+    });
+
+    // Step 2: APPEND (upload in chunks)
+    const chunkSize = 5 * 1024 * 1024; // 5MB chunks
+    const fileBuffer = _fs.default.readFileSync(filePath);
+    let segmentIndex = 0;
+    for (let offset = 0; offset < fileSize; offset += chunkSize) {
+      const chunk = fileBuffer.slice(offset, Math.min(offset + chunkSize, fileSize));
+      const base64Chunk = chunk.toString('base64');
+      await mediaUploadRequest({
+        command: 'APPEND',
+        media_id: mediaId,
+        media_data: base64Chunk,
+        segment_index: segmentIndex
+      }, token, logger);
+      (0, _loggerHelpers.loggerDebug)(logger, `Media chunk ${segmentIndex} uploaded`, {
+        mediaId,
+        segmentIndex
       });
-    } catch (e) {
-      (0, _loggerHelpers.loggerError)(logger, `Failed posting media`, e);
-      // this is just a safety precaution
-      removeMedia(filePath, logger);
+      segmentIndex++;
     }
-  });
+
+    // Step 3: FINALIZE
+    const finalizeResponse = await mediaUploadRequest({
+      command: 'FINALIZE',
+      media_id: mediaId
+    }, token, logger);
+    (0, _loggerHelpers.loggerDebug)(logger, 'Media upload FINALIZE successful', {
+      mediaId
+    });
+
+    // Step 4: Check processing status if needed
+    if (finalizeResponse.processing_info) {
+      await waitForMediaProcessing(mediaId, token, logger);
+    }
+    return mediaId;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in chunked media upload', e);
+    throw e;
+  }
+}
+
+// Make a media upload request
+async function mediaUploadRequest(params, token, logger) {
+  const url = 'https://upload.twitter.com/1.1/media/upload.json';
+  const {
+    Authorization
+  } = token.oauth.toHeader(token.oauth.authorize({
+    url,
+    method: 'post',
+    data: {}
+  }, {
+    key: token.token,
+    secret: token.tokenSecret
+  }));
+  try {
+    const result = await _superagent.default.post(url).set('Authorization', Authorization).send(params);
+    return result.body;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Media upload request failed for command: ${params.command}`, e);
+    throw e;
+  }
+}
+
+// Wait for media processing to complete
+async function waitForMediaProcessing(mediaId, token, logger) {
+  let maxAttempts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 20;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const statusResponse = await mediaUploadRequest({
+      command: 'STATUS',
+      media_id: mediaId
+    }, token, logger);
+    if (!statusResponse.processing_info) {
+      return; // Processing complete
+    }
+    const state = statusResponse.processing_info.state;
+    if (state === 'succeeded') {
+      (0, _loggerHelpers.loggerDebug)(logger, 'Media processing succeeded', {
+        mediaId
+      });
+      return;
+    }
+    if (state === 'failed') {
+      throw new Error(`Media processing failed: ${statusResponse.processing_info.error?.message || 'Unknown error'}`);
+    }
+
+    // Still processing, wait before checking again
+    const waitTime = statusResponse.processing_info.check_after_secs || 1;
+    (0, _loggerHelpers.loggerDebug)(logger, `Media still processing, waiting ${waitTime}s`, {
+      mediaId,
+      state
+    });
+    await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+  }
+  throw new Error('Media processing timeout');
 }
 function removeMedia(file, logger) {
   try {
@@ -722,5 +1061,4 @@ function removeMedia(file, logger) {
   } catch (e) {
     (0, _loggerHelpers.loggerError)(logger, `failed trying to remove media ${file} it may have already been removed`);
   }
-}
-;
+}

package/dist/cjs/data-access/index.js

@@ -31,8 +31,7 @@ var TwitterNative = _interopRequireWildcard(require("./http/twitter.native.js"))
 var InstagramNative = _interopRequireWildcard(require("./http/instagram.native.js"));
 var ThreadsNative = _interopRequireWildcard(require("./http/threads.native.js"));
 var AssetManagerClient = _interopRequireWildcard(require("./http/assetManager.client.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const DocumentHelperFunctions = {
   ...messageHelpers,
   ...applicationTagFunctions,