emusks 0.0.1

package/src/methods/tweet.js

@@ -0,0 +1,396 @@
+import headers from "../utils/headers.js";
+import parseTweet from "../parsers/tweet.js";
+import parseUser from "../parsers/user.js";
+
+const createPoll = async function (poll, auth) {
+  // to add a poll to a tweet, we need to first create a card
+  // this for whatever reason isn't using the normal graphql api
+
+  if (!poll.choices || poll.choices.length < 2)
+    throw new Error("a poll must have at least 2 choices");
+
+  if (!poll.choices || poll.choices.length > 4)
+    throw new Error("a poll must not have more than 4 choices");
+
+  const pollResponse = await (
+    await fetch("https://caps.x.com/v2/cards/create.json", {
+      headers: {
+        Accept: "*/*",
+        "accept-language": "en-US,en;q=0.9",
+
+        authorization:
+          "Bearer AAAAAAAAAAAAAAAAAAAAAFQODgEAAAAAVHTp76lzh3rFzcHbmHVvQxYYpTw%3DckAlMINMjmCwxUcaXbAN4XqJVdgMJaHqNOFgPMK0zN1qLqLQCF",
+        "content-type": "application/x-www-form-urlencoded",
+        "x-csrf-token": auth.csrfToken,
+
+        "x-twitter-active-user": "yes",
+        "x-twitter-auth-type": "OAuth2Session",
+        "x-twitter-client-language": "en",
+
+        cookie: auth.cookies,
+        ...headers,
+      },
+      body: `card_data=${encodeURIComponent(
+        JSON.stringify({
+          "twitter:card": `poll${poll.choices.length}choice_text_only`,
+          "twitter:api:api:endpoint": "1",
+          "twitter:long:duration_minutes": poll.duration_minutes || 1440,
+          ...Object.fromEntries(
+            poll.choices.map((choice, i) => [
+              `twitter:string:choice${i + 1}_label`,
+              choice,
+            ])
+          ),
+        })
+      )}`,
+      method: "POST",
+    })
+  ).json();
+
+  if (!pollResponse?.card_uri)
+    throw new Error(
+      `failed to create poll card: ${JSON.stringify(pollResponse, null, 2)}`
+    );
+
+  return pollResponse?.card_uri;
+};
+
+export async function tweet(body = {}) {
+  if (!this.auth.cookies) {
+    throw new Error("you must be logged in to tweet");
+  }
+
+  if (body.poll) {
+    if (body.card) throw new Error("a tweet can't have both a poll and a card");
+
+    body.card = await createPoll(body.poll, this.auth);
+  }
+
+  const out = await (
+    await fetch(
+      `https://pro.x.com/i/api/graphql/IVdJU2Vjw2llhmJOAZy9Ow/CreateTweet`,
+      {
+        headers: {
+          Accept: "*/*",
+          "accept-language": "en-US,en;q=0.9",
+
+          authorization:
+            "Bearer AAAAAAAAAAAAAAAAAAAAAFQODgEAAAAAVHTp76lzh3rFzcHbmHVvQxYYpTw%3DckAlMINMjmCwxUcaXbAN4XqJVdgMJaHqNOFgPMK0zN1qLqLQCF",
+          "content-type": "application/json",
+
+          "x-client-transaction-id": Math.random().toString().replace("0.", ""),
+          "x-csrf-token": this.auth.csrfToken,
+
+          "x-twitter-active-user": "yes",
+          "x-twitter-auth-type": "OAuth2Session",
+          "x-twitter-client-language": "en",
+
+          cookie: this.auth.cookies,
+          ...headers,
+        },
+        method: "POST",
+        body: JSON.stringify({
+          variables: {
+            tweet_text: body.text,
+            reply: body.reply
+              ? {
+                  in_reply_to_tweet_id: body.reply,
+                  exclude_reply_user_ids: [],
+                }
+              : undefined,
+            dark_request: false,
+            card_uri: body.card || undefined,
+            media: body.media || {
+              media_entities: [],
+              possibly_sensitive: false,
+            },
+            semantic_annotation_ids: [],
+            disallowed_reply_options: body.disallowed_reply_options || null,
+          },
+          features: {
+            premium_content_api_read_enabled: false,
+            communities_web_enable_tweet_community_results_fetch: true,
+            c9s_tweet_anatomy_moderator_badge_enabled: true,
+            responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+            responsive_web_grok_analyze_post_followups_enabled: true,
+            responsive_web_jetfuel_frame: false,
+            responsive_web_grok_share_attachment_enabled: true,
+            responsive_web_edit_tweet_api_enabled: true,
+            graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+            view_counts_everywhere_api_enabled: true,
+            longform_notetweets_consumption_enabled: true,
+            responsive_web_twitter_article_tweet_consumption_enabled: true,
+            tweet_awards_web_tipping_enabled: false,
+            responsive_web_grok_show_grok_translated_post: false,
+            responsive_web_grok_analysis_button_from_backend: true,
+            creator_subscriptions_quote_tweet_preview_enabled: false,
+            longform_notetweets_rich_text_read_enabled: true,
+            longform_notetweets_inline_media_enabled: true,
+            profile_label_improvements_pcf_label_in_post_enabled: true,
+            rweb_tipjar_consumption_enabled: true,
+            responsive_web_graphql_exclude_directive_enabled: true,
+            verified_phone_label_enabled: false,
+            articles_preview_enabled: true,
+            responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+            freedom_of_speech_not_reach_fetch_enabled: true,
+            standardized_nudges_misinfo: true,
+            tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+            responsive_web_grok_image_annotation_enabled: true,
+            responsive_web_graphql_timeline_navigation_enabled: true,
+            responsive_web_enhance_cards_enabled: false,
+            includePromotedContent: false,
+          },
+          queryId: "IVdJU2Vjw2llhmJOAZy9Ow",
+        }),
+      }
+    )
+  ).json();
+
+  if (!out?.data?.create_tweet) {
+    throw new Error(`failed to tweet: ${JSON.stringify(out, null, 2)}`);
+  }
+
+  return {
+    post_id: out?.data?.create_tweet?.tweet_results?.result?.legacy?.id_str,
+    post_url: `https://x.com/i/status/${out?.data?.create_tweet?.tweet_results?.result?.legacy?.id_str}`,
+    response: out,
+  };
+}
+
+export async function deleteTweet(tweetId) {
+  if (!this.auth.cookies) {
+    throw new Error("you must be logged in to delete a tweet");
+  }
+
+  const out = await (
+    await fetch(
+      `https://pro.x.com/i/api/graphql/VaenaVgh5q5ih7kvyVjgtg/DeleteTweet`,
+      {
+        headers: {
+          Accept: "*/*",
+          "accept-language": "en-US,en;q=0.9",
+
+          authorization:
+            "Bearer AAAAAAAAAAAAAAAAAAAAAFQODgEAAAAAVHTp76lzh3rFzcHbmHVvQxYYpTw%3DckAlMINMjmCwxUcaXbAN4XqJVdgMJaHqNOFgPMK0zN1qLqLQCF",
+          "content-type": "application/json",
+
+          "x-client-transaction-id": Math.random().toString().replace("0.", ""),
+          "x-csrf-token": this.auth.csrfToken,
+
+          "x-twitter-active-user": "yes",
+          "x-twitter-auth-type": "OAuth2Session",
+          "x-twitter-client-language": "en",
+
+          cookie: this.auth.cookies,
+          ...headers,
+        },
+        method: "POST",
+        body: JSON.stringify({
+          variables: {
+            dark_request: false,
+            tweet_id: tweetId,
+          },
+          queryId: "VaenaVgh5q5ih7kvyVjgtg",
+        }),
+      }
+    )
+  ).json();
+
+  if (!out?.data?.delete_tweet) {
+    throw new Error(`failed to delete tweet: ${JSON.stringify(out, null, 2)}`);
+  }
+
+  return true;
+}
+
+export async function getTweet(tweetId) {
+  const raw = await (
+    await fetch(
+      `https://cdn.syndication.twimg.com/tweet-result?id=${tweetId}&lang=en&token=${Math.random()
+        .toString()
+        .replace("0.", "")}`
+    )
+  ).json();
+
+  const tweetObj = parseTweet(raw);
+  if (tweetObj.user) {
+    tweetObj.user = parseUser(tweetObj.user);
+  }
+  return tweetObj;
+}
+
+export async function getFullTweet(
+  tweetId,
+  { rankingMode = "Relevance", includeAds = false, cursor = undefined } = {}
+) {
+  if (!this.auth.cookies) {
+    throw new Error(
+      "you must be logged in to get a full tweet. consider using getTweet instead for a shorter yet still useful result without needing to log in"
+    );
+  }
+
+  const variables = {
+    focalTweetId: tweetId,
+    referrer: "ntab",
+    with_rux_injections: false,
+    rankingMode: rankingMode,
+    includePromotedContent: includeAds,
+    withCommunity: true,
+    withQuickPromoteEligibilityTweetFields: true,
+    withBirdwatchNotes: true,
+    withVoice: true,
+  };
+
+  if (cursor) {
+    variables.cursor = cursor;
+  }
+
+  const out = await (
+    await fetch(
+      `https://pro.x.com/i/api/graphql/8IPrg-fiWPM4p735QRfGqA/TweetDetail?variables=${encodeURIComponent(
+        JSON.stringify(variables)
+      )}&features=${encodeURIComponent(
+        JSON.stringify({
+          rweb_video_screen_enabled: false,
+          payments_enabled: false,
+          profile_label_improvements_pcf_label_in_post_enabled: true,
+          rweb_tipjar_consumption_enabled: true,
+          verified_phone_label_enabled: false,
+          creator_subscriptions_tweet_preview_api_enabled: true,
+          responsive_web_graphql_timeline_navigation_enabled: true,
+          responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+          premium_content_api_read_enabled: false,
+          communities_web_enable_tweet_community_results_fetch: true,
+          c9s_tweet_anatomy_moderator_badge_enabled: true,
+          responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+          responsive_web_grok_analyze_post_followups_enabled: true,
+          responsive_web_jetfuel_frame: false,
+          responsive_web_grok_share_attachment_enabled: true,
+          articles_preview_enabled: true,
+          responsive_web_edit_tweet_api_enabled: true,
+          graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+          view_counts_everywhere_api_enabled: true,
+          longform_notetweets_consumption_enabled: true,
+          responsive_web_twitter_article_tweet_consumption_enabled: true,
+          tweet_awards_web_tipping_enabled: false,
+          responsive_web_grok_show_grok_translated_post: false,
+          responsive_web_grok_analysis_button_from_backend: false,
+          creator_subscriptions_quote_tweet_preview_enabled: false,
+          freedom_of_speech_not_reach_fetch_enabled: true,
+          standardized_nudges_misinfo: true,
+          tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+          longform_notetweets_rich_text_read_enabled: true,
+          longform_notetweets_inline_media_enabled: true,
+          responsive_web_grok_image_annotation_enabled: true,
+          responsive_web_enhance_cards_enabled: false,
+        })
+      )}&fieldToggles=${encodeURIComponent(
+        JSON.stringify({
+          withArticleRichContentState: true,
+          withArticlePlainText: false,
+          withGrokAnalyze: false,
+          withDisallowedReplyControls: true,
+        })
+      )}`,
+      {
+        headers: {
+          authorization:
+            "Bearer AAAAAAAAAAAAAAAAAAAAAFQODgEAAAAAVHTp76lzh3rFzcHbmHVvQxYYpTw%3DckAlMINMjmCwxUcaXbAN4XqJVdgMJaHqNOFgPMK0zN1qLqLQCF",
+          "content-type": "application/json",
+
+          "x-client-transaction-id": Math.random().toString().replace("0.", ""),
+          "x-csrf-token": this.auth.csrfToken,
+
+          "x-twitter-active-user": "yes",
+          "x-twitter-auth-type": "OAuth2Session",
+          "x-twitter-client-language": "en",
+
+          cookie: this.auth.cookies,
+          ...headers,
+        },
+      }
+    )
+  ).json();
+
+  const entries =
+    out?.data?.threaded_conversation_with_injections_v2?.instructions?.find(
+      (e) => e.type === "TimelineAddEntries"
+    )?.entries;
+
+  if (!entries.length) {
+    throw new Error("unable to find instructions");
+  }
+
+  const cursors = {
+    top: null,
+    bottom: null,
+  };
+
+  entries.forEach((entry) => {
+    if (entry.entryId && entry.entryId.startsWith("cursor-")) {
+      if (entry.entryId.includes("top")) {
+        cursors.top = entry.content?.itemContent?.value;
+      } else if (entry.entryId.includes("bottom")) {
+        cursors.bottom = entry.content?.itemContent?.value;
+      }
+    }
+  });
+
+  const tweets = [];
+
+  entries.forEach((entry) => {
+    if (entry.content?.itemContent?.tweet_results?.result) {
+      const rawTweet = entry.content.itemContent.tweet_results.result;
+      const tweetObj = parseTweet(rawTweet);
+      if (tweetObj.user) {
+        tweetObj.user = parseUser(tweetObj.user);
+      }
+      tweets.push(tweetObj);
+    } else if (
+      entry.content?.entryType === "TimelineTimelineModule" &&
+      entry.content?.items
+    ) {
+      entry.content.items.forEach((item) => {
+        if (item.item?.itemContent?.tweet_results?.result) {
+          const rawTweet = item.item.itemContent.tweet_results.result;
+          const tweetObj = parseTweet(rawTweet);
+          if (tweetObj.user) {
+            tweetObj.user = parseUser(tweetObj.user);
+          }
+          tweets.push(tweetObj);
+        }
+      });
+    }
+  });
+
+  return {
+    tweets,
+    cursors,
+  };
+}
+
+export async function getTweetReplies(
+  tweetId,
+  { rankingMode = "Relevance", includeAds = false, cursor = undefined } = {}
+) {
+  const fullTweetData = await this.getFullTweet(tweetId, {
+    rankingMode,
+    includeAds,
+    cursor,
+  });
+
+  const mainTweet = fullTweetData.tweets.find((tweet) => tweet.id === tweetId);
+  const replies = fullTweetData.tweets.filter(
+    (tweet) =>
+      tweet.id !== tweetId &&
+      (tweet.in_reply_to_status_id === tweetId ||
+        tweet.conversation_id === tweetId)
+  );
+
+  return {
+    mainTweet,
+    replies,
+    cursors: fullTweetData.cursors,
+    fullTweetData,
+  };
+}

package/src/methods/users.js

@@ -0,0 +1,209 @@
+import parseUser from "../parsers/user.js";
+import parseTweet from "../parsers/tweet.js";
+import headers from "../utils/headers.js";
+
+export async function getUser(username) {
+  const out = await (
+    await fetch(
+      `https://pro.x.com/i/api/graphql/jUKA--0QkqGIFhmfRZdWrQ/UserByScreenName?variables=${encodeURIComponent(
+        JSON.stringify({
+          screen_name: username,
+        })
+      )}&features=${encodeURIComponent(
+        JSON.stringify({
+          responsive_web_grok_bio_auto_translation_is_enabled: false,
+          hidden_profile_subscriptions_enabled: false,
+          payments_enabled: false,
+          profile_label_improvements_pcf_label_in_post_enabled: true,
+          rweb_tipjar_consumption_enabled: true,
+          verified_phone_label_enabled: true,
+          subscriptions_verification_info_is_identity_verified_enabled: true,
+          subscriptions_verification_info_verified_since_enabled: true,
+          highlights_tweets_tab_ui_enabled: true,
+          responsive_web_twitter_article_notes_tab_enabled: true,
+          subscriptions_feature_can_gift_premium: true,
+          creator_subscriptions_tweet_preview_api_enabled: true,
+          responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+          responsive_web_graphql_timeline_navigation_enabled: true,
+        })
+      )}&fieldToggles=${encodeURIComponent(
+        JSON.stringify({
+          withAuxiliaryUserLabels: true,
+        })
+      )}`,
+      {
+        headers: {
+          Accept: "*/*",
+          "accept-language": "en-US,en;q=0.9",
+
+          authorization:
+            "Bearer AAAAAAAAAAAAAAAAAAAAAFQODgEAAAAAVHTp76lzh3rFzcHbmHVvQxYYpTw%3DckAlMINMjmCwxUcaXbAN4XqJVdgMJaHqNOFgPMK0zN1qLqLQCF",
+          "content-type": "application/json",
+
+          "x-csrf-token": this.auth.csrfToken,
+
+          "x-twitter-active-user": "yes",
+          "x-twitter-auth-type": "OAuth2Session",
+          "x-twitter-client-language": "en",
+
+          cookie: this.auth.cookies,
+          ...headers,
+        },
+      }
+    )
+  ).json();
+
+  if (!out?.data?.user?.result)
+    throw new Error(`failed to get user: ${JSON.stringify(out, null, 1)}`);
+
+  const user = parseUser(out.data.user.result);
+
+  user.follow = () => this.follow(out.data.user.result.rest_id);
+  user.unfollow = () => this.unfollow(out.data.user.result.rest_id);
+  user.getTweets = (options) =>
+    this.getUserTweets(out.data.user.result.rest_id, options);
+
+  return user;
+}
+
+export async function getUserTweets(
+  userId,
+  { count = 20, includePromotedContent = false, cursor = undefined } = {}
+) {
+  if (!this.auth.cookies) {
+    throw new Error("you must be logged in to get user tweets");
+  }
+
+  const variables = {
+    userId: userId,
+    count: count,
+    includePromotedContent: includePromotedContent,
+    withQuickPromoteEligibilityTweetFields: true,
+    withVoice: true,
+  };
+
+  if (cursor) {
+    variables.cursor = cursor;
+  }
+
+  const out = await (
+    await fetch(
+      `https://pro.x.com/i/api/graphql/2ItQrd86P8C0pDU6td3Z7Q/UserTweets?variables=${encodeURIComponent(
+        JSON.stringify(variables)
+      )}&features=${encodeURIComponent(
+        JSON.stringify({
+          rweb_video_screen_enabled: false,
+          payments_enabled: false,
+          profile_label_improvements_pcf_label_in_post_enabled: true,
+          rweb_tipjar_consumption_enabled: true,
+          verified_phone_label_enabled: false,
+          creator_subscriptions_tweet_preview_api_enabled: true,
+          responsive_web_graphql_timeline_navigation_enabled: true,
+          responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+          premium_content_api_read_enabled: false,
+          communities_web_enable_tweet_community_results_fetch: true,
+          c9s_tweet_anatomy_moderator_badge_enabled: true,
+          responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+          responsive_web_grok_analyze_post_followups_enabled: true,
+          responsive_web_jetfuel_frame: false,
+          responsive_web_grok_share_attachment_enabled: true,
+          articles_preview_enabled: true,
+          responsive_web_edit_tweet_api_enabled: true,
+          graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+          view_counts_everywhere_api_enabled: true,
+          longform_notetweets_consumption_enabled: true,
+          responsive_web_twitter_article_tweet_consumption_enabled: true,
+          tweet_awards_web_tipping_enabled: false,
+          responsive_web_grok_show_grok_translated_post: false,
+          responsive_web_grok_analysis_button_from_backend: false,
+          creator_subscriptions_quote_tweet_preview_enabled: false,
+          freedom_of_speech_not_reach_fetch_enabled: true,
+          standardized_nudges_misinfo: true,
+          tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+          longform_notetweets_rich_text_read_enabled: true,
+          longform_notetweets_inline_media_enabled: true,
+          responsive_web_grok_image_annotation_enabled: true,
+          responsive_web_enhance_cards_enabled: false,
+        })
+      )}&fieldToggles=${encodeURIComponent(
+        JSON.stringify({
+          withArticlePlainText: false,
+        })
+      )}`,
+      {
+        headers: {
+          Accept: "*/*",
+          "accept-language": "en-US,en;q=0.9",
+          authorization:
+            "Bearer AAAAAAAAAAAAAAAAAAAAAFQODgEAAAAAVHTp76lzh3rFzcHbmHVvQxYYpTw%3DckAlMINMjmCwxUcaXbAN4XqJVdgMJaHqNOFgPMK0zN1qLqLQCF",
+          "content-type": "application/json",
+          "x-csrf-token": this.auth.csrfToken,
+          "x-twitter-active-user": "yes",
+          "x-twitter-auth-type": "OAuth2Session",
+          "x-twitter-client-language": "en",
+          cookie: this.auth.cookies,
+          ...headers,
+        },
+      }
+    )
+  ).json();
+
+  if (!out?.data?.user?.result?.timeline?.timeline?.instructions) {
+    throw new Error(
+      `failed to get user tweets: ${JSON.stringify(out, null, 1)}`
+    );
+  }
+
+  const instructions = out.data.user.result.timeline.timeline.instructions;
+
+  const timelineInstruction = instructions.find(
+    (instruction) =>
+      instruction.type === "TimelineAddEntries" ||
+      instruction.type === "TimelinePinEntry"
+  );
+
+  let entries = [];
+  const cursors = {
+    top: null,
+    bottom: null,
+  };
+
+  if (!timelineInstruction) {
+    instructions.forEach((instruction) => {
+      if (instruction.entries) {
+        entries.push(...instruction.entries);
+      } else if (instruction.entry) {
+        entries.push(instruction.entry);
+      }
+    });
+
+    if (entries.length === 0) {
+      return { tweets: [], cursors };
+    }
+  } else {
+    entries = timelineInstruction.entries || [timelineInstruction.entry];
+  }
+
+  // Extract cursors for pagination
+  entries.forEach((entry) => {
+    if (entry.entryId && entry.entryId.startsWith("cursor-")) {
+      if (entry.entryId.includes("top")) {
+        cursors.top = entry.content?.value;
+      } else if (entry.entryId.includes("bottom")) {
+        cursors.bottom = entry.content?.value;
+      }
+    }
+  });
+
+  const tweets = entries
+    .filter((entry) => entry.content?.itemContent?.tweet_results?.result)
+    .map((entry) => {
+      const tweet = entry.content.itemContent.tweet_results.result;
+      return parseTweet(tweet);
+    });
+
+  return {
+    tweets,
+    cursors,
+  };
+}

package/src/parsers/tweet.js

@@ -0,0 +1,75 @@
+import parseUser from "./user.js";
+
+export default function parseTweet(tweet) {
+  const get = (obj, path, fallback = undefined) =>
+    path
+      .split(".")
+      .reduce((o, k) => (o && o[k] !== undefined ? o[k] : fallback), obj);
+  const data = tweet.data?.tweet || tweet;
+
+  const legacy = data.legacy || data;
+  const core = data.core || {};
+  const views = data.views || {};
+
+  return {
+    id: tweet.rest_id || legacy.id_str || tweet.id || tweet.id_str,
+    text: legacy.full_text || legacy.text || tweet.text,
+    created_at: legacy.created_at || tweet.created_at,
+    conversation_id: legacy.conversation_id_str || tweet.conversation_id_str,
+    in_reply_to_status_id:
+      legacy.in_reply_to_status_id_str || tweet.in_reply_to_status_id_str,
+    in_reply_to_user_id:
+      legacy.in_reply_to_user_id_str || tweet.in_reply_to_user_id_str,
+    in_reply_to_screen_name:
+      legacy.in_reply_to_screen_name || tweet.in_reply_to_screen_name,
+
+    user: (() => {
+      const raw =
+        get(core, "user_results.result") ||
+        get(data, "core.user_results.result") ||
+        data.user;
+      return raw ? parseUser(raw) : null;
+    })(),
+
+    stats: {
+      retweets: legacy.retweet_count || tweet.retweet_count || 0,
+      likes: legacy.favorite_count || tweet.favorite_count || 0,
+      replies: legacy.reply_count || tweet.reply_count || 0,
+      quotes: legacy.quote_count || tweet.quote_count || 0,
+      bookmarks: legacy.bookmark_count || tweet.bookmark_count || 0,
+      views: get(views, "count") || 0,
+    },
+
+    engagement: {
+      retweeted: legacy.retweeted || tweet.retweeted || false,
+      liked: legacy.favorited || tweet.favorited || false,
+      bookmarked: legacy.bookmarked || tweet.bookmarked || false,
+    },
+
+    media: legacy.entities?.media || tweet.entities?.media || [],
+    urls: legacy.entities?.urls || tweet.entities?.urls || [],
+    hashtags: legacy.entities?.hashtags || tweet.entities?.hashtags || [],
+    user_mentions:
+      legacy.entities?.user_mentions || tweet.entities?.user_mentions || [],
+
+    source: legacy.source || tweet.source,
+    lang: legacy.lang || tweet.lang,
+
+    quoting: get(tweet, "quoted_status_result.result") ? parseTweet(get(tweet, "quoted_status_result.result")) : null,
+
+    edit_control: data.edit_control || {},
+    card: data.card || null,
+    unmention_data: data.unmention_data || {},
+
+    misc: {
+      display_text_range: legacy.display_text_range || tweet.display_text_range,
+      is_translatable: tweet.is_translatable || false,
+      possibly_sensitive:
+        legacy.possibly_sensitive || tweet.possibly_sensitive || false,
+      withheld_copyright:
+        legacy.withheld_copyright || tweet.withheld_copyright || false,
+      withheld_in_countries:
+        legacy.withheld_in_countries || tweet.withheld_in_countries || [],
+    },
+  };
+}