@meltwater/conversations-api-services 1.0.23 → 1.0.25

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

@@ -0,0 +1,584 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addOAuthToToken = addOAuthToToken;
+exports.followUser = followUser;
+exports.getBrandUserRelationship = getBrandUserRelationship;
+exports.getCurrentInfo = getCurrentInfo;
+exports.getDirectMessageImage = getDirectMessageImage;
+exports.getMentionHandleInfo = getMentionHandleInfo;
+exports.getUserInfoFromHandle = getUserInfoFromHandle;
+exports.getUserInfoFromHandles = getUserInfoFromHandles;
+exports.like = like;
+exports.privateMessage = privateMessage;
+exports.reply = reply;
+exports.retweet = retweet;
+exports.retweetWithComment = retweetWithComment;
+exports.unFollowUser = unFollowUser;
+exports.unLike = unLike;
+exports.unRetweet = unRetweet;
+exports.userFollowStatus = userFollowStatus;
+var _superagent = _interopRequireDefault(require("superagent"));
+var _externalIdHelpers = require("../../lib/externalId.helpers.js");
+var _loggerHelpers = require("../../lib/logger.helpers.js");
+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 }; }
+function addOAuthToToken(token, TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET) {
+  if (!token.oauth) {
+    token.oauth = (0, _oauth.default)({
+      consumer: {
+        key: TWITTER_CONSUMER_KEY,
+        secret: TWITTER_CONSUMER_SECRET
+      },
+      signature_method: 'HMAC-SHA1',
+      hash_function(base_string, key) {
+        return _crypto.default.createHmac('sha1', key).update(base_string).digest('base64');
+      }
+    });
+    token.consumer_key = TWITTER_CONSUMER_KEY;
+    token.consumer_secret = TWITTER_CONSUMER_SECRET;
+  }
+  return token;
+}
+async function getUserInfoFromHandles(token, handles, logger) {
+  try {
+    let query = `users/lookup.json?screen_name=${handles.join(',')}`;
+    let result = await postRequest({
+      token,
+      uri: query,
+      logger
+    });
+    return result.data;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting UserInfo`, e);
+  }
+}
+async function getUserInfoFromHandle(token, handleId, logger) {
+  try {
+    let query = `users/show.json?user_id=${(0, _externalIdHelpers.removePrefix)(handleId)}`;
+    let result = await getRequest({
+      token,
+      uri: query,
+      logger
+    });
+    return result.data;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting UserInfo`, e);
+  }
+}
+async function getDirectMessageImage(token, imageUrl, logger) {
+  try {
+    let result = await getRequest({
+      token,
+      uri: imageUrl,
+      attachUrlPrefix: false,
+      logger
+    });
+    return {
+      image: result.data,
+      contentType: result.contentType
+    };
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting image`, e);
+    throw e;
+  }
+}
+async function getCurrentInfo(token, externalId, logger) {
+  try {
+    const uri = `https://api.twitter.com/2/tweets?ids=${(0, _externalIdHelpers.removePrefix)(externalId)}&tweet.fields=public_metrics&expansions=author_id`;
+    let result = await getRequest({
+      token,
+      uri,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
+      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:
+    result.data.retweeted = !!result.data.current_user_retweet;
+    return result.data.data[0].public_metrics;
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, 'Error in twitter getCurrentInfo', error);
+  }
+}
+async function getMentionHandleInfo(token, externalId, logger) {
+  try {
+    const uri = `https://api.twitter.com/2/tweets/${(0, _externalIdHelpers.removePrefix)(externalId)}?tweet.fields=entities&expansions=entities.mentions.username,author_id&user.fields=id,name,username,profile_image_url`;
+    let result = await getRequest({
+      token,
+      uri,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false
+    });
+    return result.data;
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, 'Error in twitter getMentionHandleInfo', error);
+  }
+}
+async function retweet(token, sourceId, externalId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: `https://api.twitter.com/2/users/${(0, _externalIdHelpers.removePrefix)(sourceId)}/retweets`,
+      payload: {
+        tweet_id: (0, _externalIdHelpers.removePrefix)(externalId)
+      },
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
+      logger
+    });
+    if (response.data.data.retweeted !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Error in retweet user: ${sourceId}`, error);
+  }
+}
+async function unRetweet(token, sourceId, externalId, logger) {
+  try {
+    let response = await deleteRequest({
+      token,
+      uri: `https://api.twitter.com/2/users/${sourceId}/retweets/${(0, _externalIdHelpers.removePrefix)(externalId)}`,
+      logger
+    });
+    if (response.data.data.retweeted !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Error in unretweet user: ${sourceId}`, error, {
+      [MeltwaterAttributes.SOCIALEXTERNALID]: externalId
+    });
+  }
+}
+async function like(token, externalId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'favorites/create.json?id=' + (0, _externalIdHelpers.removePrefix)(externalId),
+      logger
+    });
+    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      (0, _loggerHelpers.loggerInfo)(logger, 'Twitter Error in like user statusCode non 200 ', {
+        response: JSON.stringify(response)
+      });
+      return false;
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Twitter Error in like user: ${externalId}`, error);
+    throw error;
+  }
+}
+async function unLike(token, externalId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'favorites/destroy.json?id=' + (0, _externalIdHelpers.removePrefix)(externalId),
+      logger
+    });
+    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Error in unlike user: ${externalId}`, error);
+    throw error;
+  }
+}
+async function followUser(token, profileId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'friendships/create.json',
+      payload: {
+        user_id: (0, _externalIdHelpers.removePrefix)(profileId),
+        follow: true
+      },
+      logger
+    });
+    if (response.data.following !== undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Error in following user: ${profileId}`, error);
+  }
+}
+async function unFollowUser(token, profileId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'friendships/destroy.json',
+      payload: {
+        user_id: (0, _externalIdHelpers.removePrefix)(profileId)
+      },
+      logger
+    });
+    if (response.data.following !== undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Error in unfollowing user: ${profileId}`, error);
+  }
+}
+async function userFollowStatus(token, profileId, logger) {
+  try {
+    let response = await getRequest({
+      token,
+      uri: 'friendships/lookup.json',
+      payload: {
+        user_id: (0, _externalIdHelpers.removePrefix)(profileId)
+      },
+      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;
+      }
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Error in getting user follow status: ${profileId}`, error);
+    if (error.message != 'Bad Request') {
+      // if we hit a minor rate limit here, we wait for 5 seconds before attempting again, usually long enough to continue
+      await new Promise(r => setTimeout(r, 5000));
+      return 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;
+  } catch (error) {
+    (0, _loggerHelpers.loggerDebug)(logger, `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`, error);
+  }
+}
+async function reply(token, text, attachment, inReplyToId, removeInReplyToId, logger) {
+  let mediaId;
+  if (attachment) {
+    // discussionType only matters if DM or Not
+    mediaId = await uploadMedia(attachment, token, 're', logger);
+  }
+  const payload = {
+    text,
+    ...(attachment && {
+      media: {
+        media_ids: [mediaId]
+      }
+    }),
+    reply: {
+      in_reply_to_tweet_id: (0, _externalIdHelpers.removePrefix)(inReplyToId)
+    }
+  };
+  if (removeInReplyToId.length) {
+    payload.reply.exclude_reply_user_ids = removeInReplyToId.map(_externalIdHelpers.removePrefix);
+  }
+  let query = 'https://api.twitter.com/2/tweets';
+  return publishTweet(token, payload, query, false, logger);
+}
+async function privateMessage(token, text, attachment, profileId, logger) {
+  let query = 'direct_messages/events/new.json';
+  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
+              }
+            }
+          })
+        }
+      }
+    }
+  };
+  return publishTweet(token, payload, query, true, logger);
+}
+async function retweetWithComment(token, text, attachment, logger) {
+  let mediaId;
+  if (attachment) {
+    // discussionType only matters if DM or Not
+    mediaId = await uploadMedia(attachment, token, 're', logger);
+  }
+  const payload = {
+    text,
+    ...(attachment && {
+      media: {
+        media_ids: [mediaId]
+      }
+    })
+  };
+  let query = 'https://api.twitter.com/2/tweets';
+  return publishTweet(token, payload, query, false, logger);
+}
+async function publishTweet(token, payload, query, isDirectMessage, logger) {
+  try {
+    let nativeResponse = await postRequest({
+      token,
+      uri: query,
+      payload,
+      convertPayloadToUri: false,
+      attachUrlPrefix: isDirectMessage
+    });
+    if (!isDirectMessage && nativeResponse.resp.statusCode === 201) {
+      const uri = `https://api.twitter.com/2/tweets?ids=${nativeResponse.data.data.id}&tweet.fields=public_metrics&expansions=author_id`;
+      nativeResponse = await getRequest({
+        token,
+        uri,
+        payload,
+        attachUrlPrefix: false,
+        convertPayloadToUri: false
+      });
+    }
+    (0, _loggerHelpers.loggerInfo)(logger, `finished fetching twitterAPI nativeResponse `, {
+      data: JSON.stringify(nativeResponse.data)
+    });
+    const response = nativeResponse.resp ? {
+      statusCode: nativeResponse.resp.statusCode,
+      statusMessage: nativeResponse.resp.statusCode === 200 ? 'Success' : 'Unknown Failure',
+      data: isDirectMessage ? nativeResponse.data.event : nativeResponse.data.data[0]
+    } : {
+      statusCode: nativeResponse.statusCode,
+      statusMessage: nativeResponse.message
+    };
+    (0, _loggerHelpers.loggerDebug)(logger, `Twitter the data response is`, {
+      response: JSON.stringify(response)
+    });
+    return response;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(`Twitter publish exception details`, err);
+    throw err;
+  }
+}
+async function postRequest(_ref) {
+  let {
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+  } = _ref;
+  return doRequest({
+    requestMethod: 'post',
+    token,
+    convertPayloadToUri,
+    payload,
+    uri,
+    attachUrlPrefix,
+    logger
+  });
+}
+async function getRequest(_ref2) {
+  let {
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+  } = _ref2;
+  return doRequest({
+    requestMethod: 'get',
+    payload,
+    token,
+    uri,
+    attachUrlPrefix,
+    convertPayloadToUri,
+    logger
+  });
+}
+async function deleteRequest(_ref3) {
+  let {
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = false,
+    convertPayloadToUri = false,
+    logger
+  } = _ref3;
+  return doRequest({
+    requestMethod: 'delete',
+    token,
+    convertPayloadToUri,
+    payload,
+    uri,
+    attachUrlPrefix,
+    logger
+  });
+}
+function fixedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
+    return '%' + c.charCodeAt(0).toString(16);
+  });
+}
+async function doRequest(_ref4) {
+  let {
+    requestMethod,
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+  } = _ref4;
+  if (payload && convertPayloadToUri) {
+    uri = uri + (uri.endsWith('?') ? '' : '?') + Object.keys(payload).map(key => {
+      return fixedEncodeURIComponent(key) + '=' + fixedEncodeURIComponent(payload[key]);
+    }).join('&');
+  }
+  let url = attachUrlPrefix ? `https://api.twitter.com/1.1/${uri}` : uri;
+  return new Promise(async (resolve, reject) => {
+    try {
+      const {
+        Authorization
+      } = token.oauth.toHeader(token.oauth.authorize({
+        url,
+        method: requestMethod,
+        data: {}
+      }, {
+        key: token.token,
+        secret: token.tokenSecret
+      }));
+      const result = await (requestMethod === 'get' ? _superagent.default.get(url).set('Authorization', Authorization) : requestMethod === 'post' ? _superagent.default.post(url).set('Authorization', Authorization).send(payload && !convertPayloadToUri ? payload : undefined) : _superagent.default.del(url).set('Authorization', Authorization));
+      (0, _loggerHelpers.loggerDebug)(logger, 'Twitter Native Response ', {
+        native: {
+          //data: result.body,
+          contentType: result.headers['content-type']
+        },
+        methodParams: {
+          uri,
+          payload: JSON.stringify(payload)
+        }
+      });
+      resolve({
+        data: result.body,
+        contentType: result.headers['content-type'],
+        resp: {
+          ...result
+        }
+      });
+    } catch (e) {
+      (0, _loggerHelpers.loggerError)(logger, `Error in twitter doRequest`, e, {
+        url,
+        convertPayloadToUri,
+        payload: JSON.stringify(payload)
+      });
+      reject(e);
+    }
+  });
+}
+
+// local
+async function downloadImage(url, fileName) {
+  const writer = _fs.default.createWriteStream(fileName);
+  const response = await (0, _axios.default)({
+    url,
+    method: 'GET',
+    responseType: 'stream'
+  });
+  response.data = response.data;
+  response.data.pipe(writer);
+  return new Promise((resolve, reject) => {
+    writer.on('finish', resolve);
+    writer.on('error', reject);
+  });
+}
+
+// local
+function generateFilePath(mimeType) {
+  let dir = `${__dirname}/temporaryTwitterMedia`;
+  if (!_fs.default.existsSync(dir)) {
+    _fs.default.mkdirSync(dir);
+  }
+  let randomFileName = Math.floor(Math.random() * 100);
+  let fileExtension = mimeType.split('/')[1];
+  if (mimeType === 'video/quicktime') {
+    fileExtension = 'mov';
+  }
+  return `${dir}/${randomFileName}.${fileExtension}`;
+}
+// local
+async function uploadMedia(attachment, token, discussionType, logger) {
+  return new Promise(async (resolve, reject) => {
+    let filePath = generateFilePath(attachment.mimeType);
+    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
+    });
+    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);
+      });
+    } catch (e) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed posting media`, e);
+      // this is just a safety precaution
+      removeMedia(filePath, logger);
+    }
+  });
+}
+function removeMedia(file, logger) {
+  try {
+    _fs.default.unlink(file, function (err) {
+      if (err) {
+        (0, _loggerHelpers.loggerError)(logger, `Failed removing ${file}`, err);
+      }
+    });
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `failed trying to remove media ${file} it may have already been removed`);
+  }
+}
+;

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

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.comment = comment;
+exports.likeVideo = likeVideo;
+exports.reply = reply;
+exports.sendRequest = sendRequest;
+exports.unlikeVideo = unlikeVideo;
+var _superagent = _interopRequireDefault(require("superagent"));
+var _externalIdHelpers = require("../../lib/externalId.helpers.js");
+var _loggerHelpers = require("../../lib/logger.helpers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const YOUTUBE_API_URL = "https://www.googleapis.com/youtube/v3/";
+async function sendPost(token) {
+  let paramString = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let postData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  let logger = arguments.length > 3 ? arguments[3] : undefined;
+  let response = {};
+  try {
+    response = await _superagent.default.post(YOUTUBE_API_URL + paramString).set('Accept', 'application/json').set('Content-Type', 'application/json').set('Authorization', `Bearer ${token}`).send(postData);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call youtube api for paramString ${paramString}: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call youtube api for paramString ${paramString}`, err);
+    }
+    throw err;
+  }
+  return response;
+}
+async function sendRequest(token) {
+  let paramString = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let logger = arguments.length > 2 ? arguments[2] : undefined;
+  let response = {};
+  try {
+    response = await _superagent.default.get(YOUTUBE_API_URL + paramString).set('Accept', 'application/json').set('Content-Type', 'application/json').set('Authorization', `Bearer ${token}`).send();
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call youtube api for paramString ${paramString}: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call youtube api for paramString ${paramString}`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call facebook api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response.body;
+}
+async function likeVideo(token, externalId, logger) {
+  return setVideoRating(token, externalId, true, logger);
+}
+async function unlikeVideo(token, externalId, logger) {
+  return setVideoRating(token, externalId, false, logger);
+}
+async function setVideoRating(token, externalId) {
+  let like = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  let logger = arguments.length > 3 ? arguments[3] : undefined;
+  const requestResult = await sendPost(token, `videos/rate?id=${(0, _externalIdHelpers.removePrefix)(externalId)}&rating=${like ? 'like' : 'dislike'}`, logger);
+  return requestResult;
+}
+async function comment(token, inReplyToId, textOriginal, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'commentThreads?part=snippet', {
+    snippet: {
+      videoId: inReplyToId,
+      topLevelComment: {
+        snippet: {
+          textOriginal
+        }
+      }
+    }
+  }, logger)) || {};
+  return publishedMessage;
+}
+async function reply(token, inReplyToId, textOriginal, logger) {
+  const {
+    body: publishedMessage
+  } = await sendPost(token, 'comments?part=snippet', {
+    snippet: {
+      textOriginal,
+      parentId: inReplyToId
+    }
+  }, logger);
+  return publishedMessage;
+}

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

@@ -78,13 +78,14 @@ Object.defineProperty(exports, "TikTokApiClient", {
     return _tiktokApiClient.TikTokApiClient;
   }
 });
-exports.TiktokNative = void 0;
+exports.TwitterNative = exports.TiktokNative = void 0;
 Object.defineProperty(exports, "WarpZoneApiClient", {
   enumerable: true,
   get: function () {
     return _WarpZoneApiClient.WarpZoneApiClient;
   }
 });
+exports.YoutubeNative = void 0;
 Object.defineProperty(exports, "assetManagerTvmRepository", {
   enumerable: true,
   get: function () {
@@ -119,8 +120,12 @@ var FacebookNative = _interopRequireWildcard(require("./http/facebook.native.js"
 exports.FacebookNative = FacebookNative;
 var TiktokNative = _interopRequireWildcard(require("./http/tiktok.native.js"));
 exports.TiktokNative = TiktokNative;
+var YoutubeNative = _interopRequireWildcard(require("./http/youtube.native.js"));
+exports.YoutubeNative = YoutubeNative;
 var LinkedinNative = _interopRequireWildcard(require("./http/linkedin.native.js"));
 exports.LinkedinNative = LinkedinNative;
+var TwitterNative = _interopRequireWildcard(require("./http/twitter.native.js"));
+exports.TwitterNative = TwitterNative;
 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; }
 const DocumentHelperFunctions = exports.DocumentHelperFunctions = {