yeet

ConstantsIOS.tsx

@@ -0,0 +1,305 @@
+// Metro module 691 (f692).
+const r29 = {
+  BACK_BUTTON: "Back Button",
+  SWIPE: "Swipe",
+  MUTUAL_GUILD_ITEM: "Mutual Guild Item",
+  MEMBER_LIST_ICON: "Member List Icon",
+  CHANNEL_DRAWER_ICON: "Channel Drawer Icon",
+  CHANNEL_TITLE: "Channel Title",
+  PREMIUM_GUILD_SUBSCRIPTION_GUILD_LIST_UPSELL: "Premium Guild Subscription Guild List Upsell"
+};
+const r28 = {
+  INACTIVE: "inactive",
+  BACKGROUND: "background",
+  ACTIVE: "active"
+};
+const r27 = {
+  WELCOME: "WELCOME",
+  LOGIN: "LOGIN",
+  REGISTER_IDENTITY: "REGISTER_IDENTITY",
+  REGISTER_DISPLAY_NAME: "REGISTER_DISPLAY_NAME",
+  REGISTER_ACCOUNT_INFORMATION: "REGISTER_ACCOUNT_INFORMATION",
+  VERIFY_PHONE: "VERIFY_PHONE",
+  MFA: "MFA",
+  ACCOUNT_DISABLED_OR_DELETION_SCHEDULED: "ACCOUNT_DISABLED_OR_DELETION_SCHEDULED",
+  AGE_GATE_UNDERAGE: "AGE_GATE_UNDERAGE",
+  AGE_GATE: "AGE_GATE",
+  COUNTRY_SELECT: "COUNTRY_SELECT",
+  EXTERNAL_LINK: "EXTERNAL_LINK",
+  COMPANION_REMOTE_AUTH: "COMPANION_REMOTE_AUTH"
+};
+const r26 = {
+  DEFAULT: "default",
+  DARK: "dark",
+  LIGHT: "light"
+};
+const r25 = {
+  LANDING: "LANDING",
+  NAME: "NAME"
+};
+const r24 = {
+  SAFARI: 0,
+  0: "SAFARI",
+  IN_APP: 1,
+  1: "IN_APP",
+  CHROME: 2,
+  2: "CHROME"
+};
+const r23 = {
+  SOLVED: "solved",
+  EXPIRED: "expired"
+};
+const r22 = {
+  OVERVIEW: "OVERVIEW",
+  RESEND_EMAIL: "RESEND_EMAIL",
+  CONFIRM_EMAIL_CHANGE_START: "CONFIRM_EMAIL_CHANGE_START",
+  CONFIRM_EMAIL_CHANGE_CODE: "CONFIRM_EMAIL_CHANGE_CODE",
+  ENTER_EMAIL: "ENTER_EMAIL",
+  ADD_PHONE: "ADD_PHONE",
+  VERIFY_PHONE: "VERIFY_PHONE",
+  VERIFY_PASSWORD: "VERIFY_PASSWORD",
+  PHONE_THEN_EMAIL_INTERSTITIAL: "PHONE_THEN_EMAIL_INTERSTITIAL",
+  CHANGE_EMAIL_COMPLETE: "CHANGE_EMAIL_COMPLETE",
+  CHANGE_EMAIL_COLLECT_REASONS: "CHANGE_EMAIL_COLLECT_REASONS",
+  CHANGE_EMAIL_WARNING: "CHANGE_EMAIL_WARNING"
+};
+const r21 = {
+  ADVANCED: "ADVANCED"
+};
+const r20 = {
+  USER: "USER",
+  ACTION: "ACTION"
+};
+const r19 = {
+  OVERVIEW: "OVERVIEW",
+  ADD_OVERRIDE: "ADD_OVERRIDE",
+  CHANNEL_OVERRIDE: "CHANNEL_OVERRIDE"
+};
+const r18 = {
+  INVITE: "invite",
+  GUILD_TEMPLATE: "guild-template",
+  CHANNEL: "channel",
+  GIFT_CODE: "gift-code",
+  MESSAGE: "message",
+  OAUTH2_AUTHORIZE: "oauth2-authorize",
+  ONE_TIME_LOGIN: "one-time-login",
+  APP_DIRECTORY_PROFILE: "app-directory-profile",
+  PROMOTIONS: "promotions",
+  FEATURE_PROMO_URL: "promo-url",
+  NONE: "none",
+  REMOTE_AUTH: "remote-auth",
+  USER_PROFILE: "user-profile",
+  BUILD_OVERRIDE: "build-override",
+  CONTACT_SYNC: "contact-sync",
+  ADD_FRIENDS: "add-friends",
+  COMPOSE_MESSAGE: "compose-message",
+  GUILD_EVENT_DETAILS: "guild-event-details",
+  FRIENDS: "friends",
+  EDIT_PROFILE: "edit-profile",
+  MOBILE_WEB_HANDOFF: "mobile-web-handoff",
+  USER_CONNECTIONS_CALLBACK: "user-connections-callback",
+  VOICE_CHANNEL: "voice-channel",
+  GUILD_HOME: "guild-home",
+  USER_CONNECTIONS_LINK_CALLBACK: "user-connections-link-callback",
+  SESSION_MANAGEMENT: "session-management",
+  CONNECTIONS: "connections",
+  GUILD_SETTINGS: "guild-settings",
+  GUILD_SETTINGS_PICKER: "guild-settings-picker",
+  ACTIVATE_DEVICE: "activate-device",
+  FAMILY_CENTER: "family-center",
+  SHARE: "share",
+  CREATE_VOICE_INVITE: "create_voice_invite",
+  SEND_VOICE_HANGOUT_WAVE: "send_voice_hangout_wave",
+  ACCOUNT_STANDING: "account-standing",
+  MOBILE_NATIVE_UPDATE: "mobile-native-update",
+  SHOP: "shop",
+  MOBILE_WEB_REDIRECT_CHECKOUT: "mobile-web-redirect-checkout",
+  AUTHORIZED_APPS: "authorized-apps",
+  DAVE_PROTOCOL_VERIFICATION: "dave-protocol-verification",
+  ICYMI: "icymi",
+  QUESTS: "quests",
+  GIFT: "gift",
+  NITRO_HOME: "store",
+  ACTIVITY: "activity",
+  CONNECTED_GAMES: "connected-games",
+  BOOST_MARKETING: "boost-marketing",
+  BOOST_SETTINGS: "boost-settings",
+  QUEST_PREVIEW_TOOL: "quest-preview-tool",
+  QUEST_HOME_PREVIEW: "quest-home-preview",
+  SUBSCRIPTION_SETTINGS: "subscription-settings",
+  ROLL_DICE: "roll-dice",
+  GAME_PROFILE: "game-profile",
+  MESSAGE_REQUESTS: "message-requests"
+};
+const set = new Set(["token", "fingerprint"]);
+const r15 = {
+  UPLOAD: "upload",
+  GLOBAL_EMOJI: "global-emoji",
+  EMOJI_AUTOCOMPLETE: "emoji-autocomplete",
+  BADGE: "badge",
+  ANIMATED_EMOJI: "animated-emoji",
+  ANIMATED_AVATAR: "animated-avatar",
+  CUSTOM_PROFILES: "custom-profiles",
+  GLOBAL_STICKER: "global-sticker",
+  PREMIUM_GUILD_PROFILE: "premium-guild-profile",
+  LONGER_MESSAGE: "longer-message",
+  GUILD_CAP: "guild-cap",
+  ACTIVITIES: "activities",
+  APP_ICONS: "app-icons",
+  SOUNDBOARD: "soundboard",
+  CLIENT_THEMES: "client-themes",
+  FOR_LATER: "for-later",
+  STREAM_HIGH_QUALITY: "stream-high-quality"
+};
+const r14 = {
+  UNKNOWN: "ESKERRORDOMAIN0",
+  CLIENT_INVALID: "ESKERRORDOMAIN1",
+  PAYMENT_CANCELED: "ESKERRORDOMAIN2",
+  PAYMENT_INVALID: "ESKERRORDOMAIN3",
+  PAYMENT_NOT_ALLOWED: "ESKERRORDOMAIN4",
+  STORE_PRODUCT_NOT_AVAILABLE: "ESKERRORDOMAIN5",
+  CLOUD_SERVICE_PERMISSION_DENIED: "ESKERRORDOMAIN6",
+  CLOUD_SERVICE_NETWORK_CONNECTION_FAILED: "ESKERRORDOMAIN7",
+  CLOUD_SERVICE_REVOKED: "ESKERRORDOMAIN8",
+  PRIVACY_ACKNOWLEDGEMENT_REQUIRED: "ESKERRORDOMAIN9",
+  UNAUTHORIZED_REQUEST_DATA: "ESKERRORDOMAIN10",
+  INVALID_OFFER_IDENTIFIER: "ESKERRORDOMAIN11",
+  INVALID_SIGNATURE: "ESKERRORDOMAIN12",
+  MISSING_OFFER_PARAMS: "ESKERRORDOMAIN13",
+  INVALID_OFFER_PRICE: "ESKERRORDOMAIN14",
+  OVERLAY_CANCELLED: "ESKERRORDOMAIN15",
+  OVERLAY_INVALID_CONFIGURATION: "ESKERRORDOMAIN16",
+  OVERLAY_TIMEOUT: "ESKERRORDOMAIN17",
+  INELIGIBLE_FOR_OFFER: "ESKERRORDOMAIN18",
+  UNSUPPORTED_PLATFORM: "ESKERRORDOMAIN19"
+};
+const r13 = {
+  LOGOUT_TIMESTAMP_KEY: "logout_timestamp_key",
+  ACKNOWLEDGED_TOOLTIPS_KEY: "acknowledged_tooltips_key",
+  KRISP_ONBOARD: "krisp_onboard"
+};
+const r12 = {
+  NONE: "none",
+  SLIDE_UP: "slide-up",
+  SLIDE_IN: "slide-in",
+  SLIDE_OUT: "slide-out",
+  SLIDE_IN_OUT: "slide-in-out",
+  SLIDE_IN_OUT_REVERSE: "slide-in-out-reverse",
+  FADE: "fade"
+};
+const r11 = Object.freeze({
+  START: {
+    x: 0,
+    y: 0
+  },
+  END: {
+    x: 1,
+    y: 0
+  }
+});
+const r198 = Object.freeze({
+  START: {
+    x: 0,
+    y: 0
+  },
+  END: {
+    x: 0,
+    y: 1
+  }
+});
+const r199 = {
+  HIGH: 0.6
+};
+r199[0.6] = "HIGH";
+r199.LOW = 0.3;
+r199[0.3] = "LOW";
+const r203 = {
+  IMAGE: 0,
+  0: "IMAGE",
+  GIF: 1,
+  1: "GIF",
+  VIDEO: 2,
+  2: "VIDEO"
+};
+const r207 = {
+  GUILD_TOOLTIP: "guild_tooltip",
+  GIF_PICKER_TOOLTIP: "gif_picker_tooltip",
+  GIF_PICKER_TOOLTIP_SPARKLE: "gif_picker_tooltip_sparkle",
+  STICKER_PICKER_SHOP_VIEW_ALL: "sticker_picker_shop_view_all",
+  SCREENSHARE_ONBOARD_SPARKLES: "screenshare_onboard_sparkles",
+  SCREENSHARE_SWIPE_UP_CONTROLS: "screenshare_swipe_up_controls",
+  STAGE_DISCOVERY_TOOLTIP: "stage_discovery_tooltip",
+  HUB_DISCOVERY_TOOLTIP: "hub_discovery_tooltip"
+};
+const r216 = {
+  ROW: 0,
+  0: "ROW",
+  HEADER: 1,
+  1: "HEADER",
+  FOOTER: 2,
+  2: "FOOTER"
+};
+export { r29 as DrawerSourceTypes };
+export { r28 as AppStates };
+export { r27 as AuthStates };
+export { r26 as KeyboardThemes };
+export { r25 as DiscoverabilityScenes };
+export { r24 as WebBrowserType };
+export { r23 as CaptchaEvent };
+export { r22 as VerificationModalScenes };
+export { r21 as InviteModalScenes };
+export { r20 as AuditLogFilterTypes };
+export { r19 as NotificationSettingsSections };
+export const APP_STORE_REVIEW_LINK = "itms-apps://itunes.apple.com/us/app/id985746746?mt=8&action=write-review";
+export const MANAGE_SUBSCRIPTION_LINK = "itms-apps://apps.apple.com/account/subscriptions";
+export const Base64JPEGPrefix = "data:image/jpeg;base64,";
+export const Base64PNGPrefix = "data:image/png;base64,";
+export const Base64GIFPrefix = "data:image/gif;base64,";
+export const Base64AVIFPrefix = "data:image/avif;base64,";
+export const Base64WEBPPrefix = "data:image/webp;base64,";
+export { r18 as LinkingTypes };
+export const ActivityPartyApplicationNames = {
+  spotify: "Spotify"
+};
+export const CACHE_STORE_LAZY_KEY = "CacheStoreLazy";
+export const CACHE_STORE_CHANNELS_LAZY_KEY = "CacheStoreChannelsLazy";
+export const CACHE_STORE_KEY = "CacheStore";
+export { set as STORAGE_SECURE_KEYS };
+export const MAX_INVITE_AVATARS_TO_SHOW = 6;
+export const INVITE_EMBED_AVATAR_SIZE = 50;
+export const UPLOAD_BANNER_SIZE = {
+  width: 1080,
+  height: 432
+};
+export const UPLOAD_STICKER_SIZE = 320;
+export const UPLOAD_MEDIUM_SIZE = 256;
+export const UPLOAD_SMALL_SIZE = 128;
+export const UPLOAD_EMOJI_SIZE = 128;
+export const EMOJI_CHAT_SIZE = 18;
+export const DM_WIDTH = 72;
+export { r15 as UpsellTypes };
+export { r14 as StoreKitErrors };
+export { r13 as StorageKeys };
+export { r12 as ModalAnimation };
+export const GIF_RE_IOS = /\.(gif)$/i;
+export const WEBP_RE_IOS = /\.(webp)$/i;
+export { r11 as HorizontalGradient };
+export { r198 as VerticalGradient };
+export { r199 as CompressionQuality };
+export const USER_SETTINGS_CONTAINER_HORIZONTAL_PADDING = 16;
+export const DISCORD_CONNECT_EXAMPLE_APP_DEEPLINK_URI = "discordconnect://connect";
+export const DISCORD_CONNECT_EXAMPLE_APP_APPLICATION_ID = "628735568569696256";
+export { r203 as MediaType };
+export { r207 as TooltipNames };
+export const GIF_FETCH_LIMIT_IOS = 50;
+export const EMOJI_SEARCH_HEADER_HEIGHT = 56;
+export const NODE_SIZE = 32;
+export const NODE_MARGIN = 4;
+export const EXPRESSION_FOOTER_HEIGHT = 40;
+export const CATEGORY_ICON_RIPPLE_CONFIG = {
+  radius: 16
+};
+export const CATEGORY_ICON_SIZE = 24;
+export const WHITESPACE_RE = /(\t|\s)/;
+export { r216 as SectionListElementType };
+export const BANNER_HEIGHT = 150;

Dispatcher.tsx

@@ -0,0 +1,25 @@
+// Metro module 709 (f710).
+import { STORAGE_KEY_LOG_DISPATCHES } from "./modules/devtools/Constants";
+import { ActionLogger } from "./_bundle/ActionLog";
+import { Storage } from "./_bundle/Module595";
+import { Dispatcher } from "./_bundle/Module589";
+import addSentryBreadcrumb_native from "./modules/sentry/addSentryBreadcrumb.native";
+const r22 = {
+  Early: 0,
+  0: "Early",
+  Database: 1,
+  1: "Database",
+  Default: 2,
+  2: "Default"
+};
+let persist = Storage.get(STORAGE_KEY_LOG_DISPATCHES);
+if (persist == null) {
+  persist = false;
+}
+const dispatcher = new Dispatcher(r22.Default, new ActionLogger({
+  persist
+}), {
+  addBreadcrumb: addSentryBreadcrumb_native
+});
+export default dispatcher;
+export { r22 as DispatchBand };

_bundle/$ZodAsyncError.js

@@ -0,0 +1,142 @@
+// Metro module 12080 (f12081).
+import * as __wrapNativeSuper from "./_wrapNativeSuper";
+import * as _createClass from "./_createClass";
+import * as _classCallCheck from "./_classCallCheck";
+import * as _possibleConstructorReturn from "./_possibleConstructorReturn";
+import * as _getPrototypeOf from "./_getPrototypeOf";
+import * as _inherits from "./_inherits";
+let _ZodAsyncError;
+let _ZodEncodeError;
+let env8309 = {};
+env8309[6] = function _isNativeReflectConstruct() {
+  let c19391_0;
+  try {
+    c19391_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c19391_0;
+  };
+  env8309[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+exports.$constructor = function(a0, c19392_1, a2) {
+  let c19392_4, constr;
+  let c19392_0 = a0;
+  const init2 = function init(a0, a1) {
+    if (!a0._zod) {
+      Object.defineProperty(a0, "_zod", {
+        value: {
+          def: a1,
+          constr,
+          traits: new Set()
+        },
+        enumerable: false
+      });
+    }
+    const traits = a0._zod.traits;
+    if (!traits.has(c19392_0)) {
+      a0._zod.traits.add(c19392_0);
+      c19392_1(a0, a1);
+      const prototype = constr.prototype;
+      const r40 = Object.keys(prototype);
+      const length = r40.length;
+      let r0 = 0;
+      if (0 < length) {
+        do {
+          const r43 = r40[r0];
+          const r44 = r43 in a0;
+          const r1 = r0;
+          if (!r44) {
+            a0[r43] = prototype[r43].bind(a0);
+          }
+          r0 = r1 + 1;
+        } while (r0 < r40.length);
+      }
+    }
+  };
+  constr = function _(a0) {
+    const r18 = a2?.Parent ? new c19392_4() : this;
+    init2(r18, a0);
+    const _zod = r18._zod;
+    if (_zod.deferred == null) {
+      _zod.deferred = [];
+    }
+    for (const item of r18._zod.deferred) {
+      item();
+    }
+    return r18;
+  };
+  let r9 = a2?.Parent;
+  if (r9 == null) {
+    r9 = Object;
+  }
+  const Definition2 = function Definition() {
+    _classCallCheck(this, Definition2);
+    const r8 = _getPrototypeOf(Definition2);
+    return _possibleConstructorReturn(this, (0, env8309[6])() ? Reflect.construct(r8, arguments, _getPrototypeOf(this).constructor) : r8.apply(this, arguments));
+  };
+  _inherits(Definition2, r9);
+  const r12 = _createClass(Definition2);
+  c19392_4 = r12;
+  Object.defineProperty(r12, "name", {
+    value: a0
+  });
+  Object.defineProperty(constr, "init", {
+    value: init2
+  });
+  Object.defineProperty(constr, Symbol.hasInstance, {
+    value: (a0) => {
+      let r10 = !!(a2?.Parent && a0 instanceof a2.Parent);
+      if (!r10) {
+        const r11 = a0 == null;
+        let r12 = void 0;
+        if (!r11) {
+          const _zod = a0._zod;
+          const r14 = _zod == null;
+          r12 = void 0;
+          if (!r14) {
+            const traits = _zod.traits;
+            r12 = traits == null ? void 0 : traits.has(c19392_0);
+          }
+        }
+        r10 = r12;
+      }
+      return r10;
+    }
+  });
+  Object.defineProperty(constr, "name", {
+    value: a0
+  });
+  return constr;
+};
+export function config(a0) {
+  if (a0) {
+    Object.assign(exports.globalConfig, a0);
+  }
+  return exports.globalConfig;
+}
+export const NEVER = Object.freeze({
+  status: "aborted"
+});
+exports.$brand = Symbol("zod_brand");
+const r34 = __wrapNativeSuper(Error);
+_ZodAsyncError = function() {
+  _classCallCheck(this, _ZodAsyncError);
+  const r8 = ["Encountered Promise during synchronous parse. Use .parseAsync() instead."];
+  const r7 = _getPrototypeOf(_ZodAsyncError);
+  return _possibleConstructorReturn(this, (0, env8309[6])() ? Reflect.construct(r7, r8, _getPrototypeOf(this).constructor) : r7.apply(this, r8));
+};
+_inherits(_ZodAsyncError, r34);
+exports.$ZodAsyncError = _createClass(_ZodAsyncError);
+const r40 = __wrapNativeSuper(Error);
+_ZodEncodeError = function(a0) {
+  _classCallCheck(this, _ZodEncodeError);
+  const r8 = [`Encountered unidirectional transform during encode: ${a0}`];
+  const r15 = _getPrototypeOf(_ZodEncodeError);
+  const r25 = _possibleConstructorReturn(this, (0, env8309[6])() ? Reflect.construct(r15, r8, _getPrototypeOf(this).constructor) : r15.apply(this, r8));
+  r25.name = "ZodEncodeError";
+  return r25;
+};
+_inherits(_ZodEncodeError, r40);
+exports.$ZodEncodeError = _createClass(_ZodEncodeError);
+export const globalConfig = {};

_bundle/$ZodRegistry.js

@@ -0,0 +1,76 @@
+// Metro module 12139 (f12140).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+let c8371_1;
+let _ZodRegistry;
+let env8371 = {};
+export function registry() {
+  return new c8371_1();
+}
+exports.$output = Symbol("ZodOutput");
+exports.$input = Symbol("ZodInput");
+_ZodRegistry = function() {
+  _classCallCheck(this, _ZodRegistry);
+  this._map = new WeakMap();
+  this._idmap = new Map();
+};
+c8371_1 = __createClass(_ZodRegistry, [{
+  key: "add",
+  value: function add(a0) {
+    const r9 = Array.prototype.slice.call(arguments, 1)[0];
+    this._map.set(a0, r9);
+    if (r9 && typeof r9 === "object" && "id" in r9) {
+      this._idmap.set(r9.id, a0);
+    }
+    return this;
+  }
+}, {
+  key: "clear",
+  value: function clear() {
+    this._map = new WeakMap();
+    this._idmap = new Map();
+    return this;
+  }
+}, {
+  key: "remove",
+  value: function remove(a0) {
+    const r6 = this._map.get(a0);
+    if (r6 && typeof r6 === "object" && "id" in r6) {
+      this._idmap.delete(r6.id);
+    }
+    this._map.delete(a0);
+    return this;
+  }
+}, {
+  key: "get",
+  value: function get(a0) {
+    const parent = a0._zod.parent;
+    if (parent) {
+      let r11 = this.get(parent);
+      if (r11 == null) {
+        r11 = {};
+      }
+      const r12 = {
+        ...r11
+      };
+      delete r12["id"];
+      const r16 = {
+        ...r12,
+        ...this._map.get(a0)
+      };
+      return Object.keys(r16).length ? r16 : void 0;
+    }
+    return this._map.get(a0);
+  }
+}, {
+  key: "has",
+  value: function has(a0) {
+    return this._map.has(a0);
+  }
+}]);
+export { c8371_1 as $ZodRegistry };
+const globalThis2 = globalThis.globalThis;
+if (globalThis2.__zod_globalRegistry == null) {
+  globalThis2.__zod_globalRegistry = new c8371_1();
+}
+export const globalRegistry = globalThis.globalThis.__zod_globalRegistry;

_bundle/AMPMMidnightParser.js

@@ -0,0 +1,182 @@
+// Metro module 3598 (f3599).
+import { dayPeriodEnumToHours } from "./Module3576";
+import { Parser } from "./Parser";
+let _createSuperInternal2, AMPMMidnightParser;
+let env1989 = {};
+env1989[2] = function _typeof(a0) {
+  const r6 = typeof globalThis.Symbol === "function" && typeof Symbol.iterator === "symbol" ? function _typeof(a0) {
+    return typeof a0;
+  } : function _typeof(a0) {
+    return a0 && typeof globalThis.Symbol === "function" && a0.constructor === Symbol ? a0 === Symbol.prototype ? typeof a0 : "symbol" : typeof a0;
+  };
+  env1989[2] = r6;
+  return r6(a0);
+};
+env1989[3] = function _setPrototypeOf(a0, a1) {
+  const r3 = Object.setPrototypeOf || function _setPrototypeOf(a0, a1) {
+    a0.__proto__ = a1;
+    return a0;
+  };
+  env1989[3] = r3;
+  return r3(a0, a1);
+};
+env1989[4] = function _getPrototypeOf(a0) {
+  const r5 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(a0) {
+    return a0.__proto__ || Object.getPrototypeOf(a0);
+  };
+  env1989[4] = r5;
+  return r5(a0);
+};
+_createSuperInternal2 = void 0;
+AMPMMidnightParser = function AMPMMidnightParser() {
+  if (this instanceof AMPMMidnightParser) {
+    const length = arguments.length;
+    const array = new Array(length);
+    let r0 = 0;
+    while (r0 < length) {
+      array[r0] = arguments[r0];
+      r0 = r0 + 1;
+    }
+    const r34 = _createSuperInternal2.call.apply(_createSuperInternal2, [this].concat(array));
+    const r35 = r34 === void 0;
+    if (r35) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    if ("priority" in r34) {
+      Object.defineProperty(r34, "priority", {
+        value: 80,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      r34.priority = 80;
+    }
+    if (r35) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    const value = ["a", "B", "H", "k", "t", "T"];
+    if ("incompatibleTokens" in r34) {
+      Object.defineProperty(r34, "incompatibleTokens", {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      r34.incompatibleTokens = value;
+    }
+    return r34;
+  }
+  throw new TypeError("Cannot call a class as a function");
+};
+if (typeof Parser !== "function" && Parser !== null) {
+  throw new TypeError("Super expression must either be null or a function");
+}
+AMPMMidnightParser.prototype = Object.create(Parser && Parser.prototype, {
+  constructor: {
+    value: AMPMMidnightParser,
+    writable: true,
+    configurable: true
+  }
+});
+if (Parser) {
+  (0, env1989[3])(AMPMMidnightParser, Parser);
+}
+const AMPMMidnightParser2 = AMPMMidnightParser;
+let r0 = 0;
+let c1991_1 = (function _isNativeReflectConstruct() {
+  if (typeof globalThis.Reflect !== "undefined" && Reflect.construct) {
+    if (Reflect.construct.sham) {
+      return false;
+    }
+    if (typeof globalThis.Proxy === "function") {
+      return true;
+    }
+    try {
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch ($e) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+})();
+_createSuperInternal2 = function _createSuperInternal() {
+  let r27;
+  const r9 = (0, env1989[4])(AMPMMidnightParser2);
+  const r17 = c1991_1 ? Reflect.construct(r9, arguments, (0, env1989[4])(this).constructor) : r9.apply(this, arguments);
+  L8: {
+    if (r17) {
+      const r25 = (0, env1989[2])(r17);
+      r27 = r17;
+      if (r25 === "object") {
+        break L8;
+      }
+      r27 = r17;
+      if (typeof r27 === "function") {
+        break L8;
+      }
+    }
+    r27 = this;
+    if (this === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+  }
+  return r27;
+};
+const r43 = [{
+  key: "parse",
+  value: function parse(a0, a1, a2) {
+    if (a1 !== "b" && a1 !== "bb" && a1 !== "bbb") {
+      if (a1 === "bbbbb") {
+        return a2.dayPeriod(a0, {
+          width: "narrow",
+          context: "formatting"
+        });
+      }
+      return a2.dayPeriod(a0, {
+        width: "wide",
+        context: "formatting"
+      }) || a2.dayPeriod(a0, {
+        width: "abbreviated",
+        context: "formatting"
+      }) || a2.dayPeriod(a0, {
+        width: "narrow",
+        context: "formatting"
+      });
+    }
+    return a2.dayPeriod(a0, {
+      width: "abbreviated",
+      context: "formatting"
+    }) || a2.dayPeriod(a0, {
+      width: "narrow",
+      context: "formatting"
+    });
+  }
+}, {
+  key: "set",
+  value: function set(a0, a1, a2) {
+    a0.setUTCHours((0, dayPeriodEnumToHours)(a2), 0, 0, 0);
+    return a0;
+  }
+}];
+const prototype = AMPMMidnightParser.prototype;
+if (0 < r43.length) {
+  do {
+    const r49 = r43[r0];
+    let enumerable = r49.enumerable;
+    const r1 = r0;
+    if (!enumerable) {
+      enumerable = false;
+    }
+    r49.enumerable = enumerable;
+    r49.configurable = true;
+    if ("value" in r49) {
+      r49.writable = true;
+    }
+    Object.defineProperty(prototype, r49.key, r49);
+    r0 = r1 + 1;
+  } while (r0 < r43.length);
+}
+export { AMPMMidnightParser };

_bundle/AMPMParser.js

@@ -0,0 +1,182 @@
+// Metro module 3597 (f3598).
+import { dayPeriodEnumToHours } from "./Module3576";
+import { Parser } from "./Parser";
+let _createSuperInternal2, AMPMParser;
+let env1986 = {};
+env1986[2] = function _typeof(a0) {
+  const r6 = typeof globalThis.Symbol === "function" && typeof Symbol.iterator === "symbol" ? function _typeof(a0) {
+    return typeof a0;
+  } : function _typeof(a0) {
+    return a0 && typeof globalThis.Symbol === "function" && a0.constructor === Symbol ? a0 === Symbol.prototype ? typeof a0 : "symbol" : typeof a0;
+  };
+  env1986[2] = r6;
+  return r6(a0);
+};
+env1986[3] = function _setPrototypeOf(a0, a1) {
+  const r3 = Object.setPrototypeOf || function _setPrototypeOf(a0, a1) {
+    a0.__proto__ = a1;
+    return a0;
+  };
+  env1986[3] = r3;
+  return r3(a0, a1);
+};
+env1986[4] = function _getPrototypeOf(a0) {
+  const r5 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(a0) {
+    return a0.__proto__ || Object.getPrototypeOf(a0);
+  };
+  env1986[4] = r5;
+  return r5(a0);
+};
+_createSuperInternal2 = void 0;
+AMPMParser = function AMPMParser() {
+  if (this instanceof AMPMParser) {
+    const length = arguments.length;
+    const array = new Array(length);
+    let r0 = 0;
+    while (r0 < length) {
+      array[r0] = arguments[r0];
+      r0 = r0 + 1;
+    }
+    const r34 = _createSuperInternal2.call.apply(_createSuperInternal2, [this].concat(array));
+    const r35 = r34 === void 0;
+    if (r35) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    if ("priority" in r34) {
+      Object.defineProperty(r34, "priority", {
+        value: 80,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      r34.priority = 80;
+    }
+    if (r35) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    const value = ["b", "B", "H", "k", "t", "T"];
+    if ("incompatibleTokens" in r34) {
+      Object.defineProperty(r34, "incompatibleTokens", {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      r34.incompatibleTokens = value;
+    }
+    return r34;
+  }
+  throw new TypeError("Cannot call a class as a function");
+};
+if (typeof Parser !== "function" && Parser !== null) {
+  throw new TypeError("Super expression must either be null or a function");
+}
+AMPMParser.prototype = Object.create(Parser && Parser.prototype, {
+  constructor: {
+    value: AMPMParser,
+    writable: true,
+    configurable: true
+  }
+});
+if (Parser) {
+  (0, env1986[3])(AMPMParser, Parser);
+}
+const AMPMParser2 = AMPMParser;
+let r0 = 0;
+let c1988_1 = (function _isNativeReflectConstruct() {
+  if (typeof globalThis.Reflect !== "undefined" && Reflect.construct) {
+    if (Reflect.construct.sham) {
+      return false;
+    }
+    if (typeof globalThis.Proxy === "function") {
+      return true;
+    }
+    try {
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch ($e) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+})();
+_createSuperInternal2 = function _createSuperInternal() {
+  let r27;
+  const r9 = (0, env1986[4])(AMPMParser2);
+  const r17 = c1988_1 ? Reflect.construct(r9, arguments, (0, env1986[4])(this).constructor) : r9.apply(this, arguments);
+  L8: {
+    if (r17) {
+      const r25 = (0, env1986[2])(r17);
+      r27 = r17;
+      if (r25 === "object") {
+        break L8;
+      }
+      r27 = r17;
+      if (typeof r27 === "function") {
+        break L8;
+      }
+    }
+    r27 = this;
+    if (this === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+  }
+  return r27;
+};
+const r43 = [{
+  key: "parse",
+  value: function parse(a0, a1, a2) {
+    if (a1 !== "a" && a1 !== "aa" && a1 !== "aaa") {
+      if (a1 === "aaaaa") {
+        return a2.dayPeriod(a0, {
+          width: "narrow",
+          context: "formatting"
+        });
+      }
+      return a2.dayPeriod(a0, {
+        width: "wide",
+        context: "formatting"
+      }) || a2.dayPeriod(a0, {
+        width: "abbreviated",
+        context: "formatting"
+      }) || a2.dayPeriod(a0, {
+        width: "narrow",
+        context: "formatting"
+      });
+    }
+    return a2.dayPeriod(a0, {
+      width: "abbreviated",
+      context: "formatting"
+    }) || a2.dayPeriod(a0, {
+      width: "narrow",
+      context: "formatting"
+    });
+  }
+}, {
+  key: "set",
+  value: function set(a0, a1, a2) {
+    a0.setUTCHours((0, dayPeriodEnumToHours)(a2), 0, 0, 0);
+    return a0;
+  }
+}];
+const prototype = AMPMParser.prototype;
+if (0 < r43.length) {
+  do {
+    const r49 = r43[r0];
+    let enumerable = r49.enumerable;
+    const r1 = r0;
+    if (!enumerable) {
+      enumerable = false;
+    }
+    r49.enumerable = enumerable;
+    r49.configurable = true;
+    if ("value" in r49) {
+      r49.writable = true;
+    }
+    Object.defineProperty(prototype, r49.key, r49);
+    r0 = r1 + 1;
+  } while (r0 < r43.length);
+}
+export { AMPMParser };

_bundle/AbortSignal.js

@@ -0,0 +1,107 @@
+// Metro module 228 (f229).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+import * as _possibleConstructorReturn from "./_possibleConstructorReturn";
+import * as _getPrototypeOf from "./_getPrototypeOf";
+import * as __inherits from "./_inherits";
+import { EventTarget, defineEventAttribute } from "./EventTarget";
+let c249_6, c249_7, c249_8;
+let AbortSignal2;
+let env249 = {};
+env249[5] = function _isNativeReflectConstruct() {
+  let c12212_0;
+  try {
+    c12212_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12212_0;
+  };
+  env249[5] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AbortSignal2 = function() {
+  _classCallCheck(this, AbortSignal2);
+  const r8 = _getPrototypeOf(AbortSignal2);
+  _possibleConstructorReturn(this, (0, env249[5])() ? Reflect.construct(r8, [], _getPrototypeOf(this).constructor) : r8.apply(this, void 0));
+  throw new TypeError("AbortSignal cannot be constructed directly");
+};
+__inherits(AbortSignal2, EventTarget);
+c249_6 = __createClass(AbortSignal2, [{
+  key: "aborted",
+  get: function get() {
+    const r8 = c249_7.get(this);
+    if (typeof r8 !== "boolean") {
+      throw new TypeError("Expected 'this' to be an 'AbortSignal' object, but got " + (this !== null ? typeof this : "null"));
+    }
+    return r8;
+  }
+}]);
+defineEventAttribute(c249_6.prototype, "abort");
+c249_7 = new WeakMap();
+Object.defineProperties(c249_6.prototype, {
+  aborted: {
+    enumerable: true
+  }
+});
+const Symbol2 = globalThis.Symbol;
+if (typeof Symbol2 === "function" ? typeof Symbol.toStringTag === "symbol" : typeof Symbol2 === "function") {
+  Object.defineProperty(c249_6.prototype, Symbol.toStringTag, {
+    configurable: true,
+    value: "AbortSignal"
+  });
+}
+const AbortController2 = function() {
+  _classCallCheck(this, AbortController2);
+  const r15 = Object.create(c249_6.prototype);
+  EventTarget.call(r15);
+  c249_7.set(r15, false);
+  c249_8.set(this, r15);
+};
+const exports3 = __createClass(AbortController2, [{
+  key: "signal",
+  get: function get() {
+    const r8 = c249_8.get(this);
+    if (r8 == null) {
+      throw new TypeError("Expected 'this' to be an 'AbortController' object, but got " + (this !== null ? typeof this : "null"));
+    }
+    return r8;
+  }
+}, {
+  key: "abort",
+  value: function abort() {
+    const r9 = c249_8.get(this);
+    if (r9 == null) {
+      throw new TypeError("Expected 'this' to be an 'AbortController' object, but got " + (this !== null ? typeof this : "null"));
+    }
+    if (c249_7.get(r9) === false) {
+      c249_7.set(r9, true);
+      r9.dispatchEvent({
+        type: "abort"
+      });
+    }
+  }
+}]);
+c249_8 = new WeakMap();
+Object.defineProperties(exports3.prototype, {
+  signal: {
+    enumerable: true
+  },
+  abort: {
+    enumerable: true
+  }
+});
+const Symbol3 = globalThis.Symbol;
+if (typeof Symbol3 === "function" ? typeof Symbol.toStringTag === "symbol" : typeof Symbol3 === "function") {
+  Object.defineProperty(exports3.prototype, Symbol.toStringTag, {
+    configurable: true,
+    value: "AbortController"
+  });
+}
+export { exports3 as AbortController };
+export { c249_6 as AbortSignal };
+export default exports3;
+module.exports = exports3;
+const exports2 = module.exports;
+module.exports.default = exports3;
+exports2.AbortController = exports3;
+module.exports.AbortSignal = c249_6;

_bundle/ActionLog.js

@@ -0,0 +1,189 @@
+// Metro module 651 (f652).
+import { Logger } from "./log";
+import { EventEmitter } from "./EventEmitter_652";
+import { performance } from "./Module653";
+let c574_4;
+let c574_3 = new Logger("Flux");
+class ActionLogger extends EventEmitter {
+  constructor(r1 = {}) {
+    let persist = r1.persist;
+    if (persist === void 0) {
+      persist = false;
+    }
+    super();
+    this.logs = [];
+    this.persist = persist;
+  }
+  log(a0, a1) {
+    let c12427_1 = a0;
+    const actionLog = new ActionLog(a0);
+    let c12427_0 = actionLog;
+    actionLog.startTime = performance.now();
+    try {
+      try {
+        a1((a0, a1) => {
+          let r23;
+          const r1 = {
+            name: a0,
+            time: -1
+          };
+          const r21 = performance.now();
+          try {
+            r23 = a1();
+          } catch (r36) {
+            r1.time = performance.now() - r21;
+            if (this.persist) {
+              c12427_0.traces.push(r1);
+            }
+            this.emit("trace", c12427_1.type, a0, r1.time);
+            throw r36;
+          }
+          r1.time = performance.now() - r21;
+          if (this.persist) {
+            c12427_0.traces.push(r1);
+          }
+          this.emit("trace", c12427_1.type, a0, r1.time);
+          return r23;
+        });
+      } catch (error) {
+        actionLog.error = error;
+        throw error;
+      }
+    } catch (r44) {
+      actionLog.totalTime = performance.now() - actionLog.startTime;
+      if (this.persist && actionLog.totalTime > 0) {
+        this.logs.push(actionLog);
+      }
+      if (this.logs.length > 1000) {
+        this.logs.shift();
+      }
+      this.emit("log", a0);
+      throw r44;
+    }
+    actionLog.totalTime = performance.now() - actionLog.startTime;
+    if (this.persist && actionLog.totalTime > 0) {
+      this.logs.push(actionLog);
+    }
+    if (this.logs.length > 1000) {
+      this.logs.shift();
+    }
+    this.emit("log", a0);
+    return actionLog;
+  }
+  getSlowestActions(a0) {
+    let c12428_1, c12428_2;
+    let length = arguments[1];
+    if (length === void 0) {
+      length = 20;
+    }
+    c12428_1 = void 0;
+    c12428_2 = void 0;
+    const r0 = [];
+    for (const log3 of this.logs) {
+      if (a0 != null && log3.name !== a0) {
+        continue;
+      }
+      for (const trace of log3.traces) {
+        r0.push([trace.name, log3.name, trace.time]);
+      }
+    }
+    r0.sort((a, b) => b[2] - a[2]);
+    if (r0.length > length) {
+      r0.length = length;
+    }
+    c12428_1 = 0;
+    c12428_2 = 0;
+    const r63 = r0.map((item) => {
+      const [r8, r11, r31] = item;
+      const r39 = `${r8}`;
+      const r42 = a0 == null ? r39 + `<${r11}>` : r39;
+      c12428_1 = Math.max(r42.length, c12428_1);
+      return [r42, r31];
+    }).map((item) => {
+      const [r27, r9] = item;
+      c12428_2 = c12428_2 + r9;
+      return `${r27.padEnd(c12428_1 + 1, " ")} - ${r9}ms`;
+    }).join("\n");
+    if (!(r0.length === 0 || r0[0][2] < 10 || c12428_2 < 20)) {
+      c574_3.log("Using Hermes:", !(global?.HermesInternal === void 0));
+      c574_3.log(`${a0 != null ? `
+  
+  === ${a0} ===` : ""}
+  ${r63}
+  `);
+      c574_3.log(`Total Time: ${c12428_2}ms`);
+    }
+    return r0;
+  }
+  getLastActionMetrics(a0, length = 20) {
+    let c12429_0, c12429_1;
+    c12429_0 = void 0;
+    c12429_1 = void 0;
+    const r4 = {};
+    for (const log3 of this.logs) {
+      for (const trace of log3.traces) {
+        r4[trace.name] = [trace.name, log3.name, trace.time];
+      }
+    }
+    const r46 = Object.values(r4);
+    r46.sort((a, b) => b[2] - a[2]);
+    if (r46.length > length) {
+      r46.length = length;
+    }
+    c12429_0 = 0;
+    c12429_1 = 0;
+    const r60 = r46.map((item) => {
+      const [r26, , r30] = item;
+      c12429_0 = Math.max(r26.length, c12429_0);
+      return [r26, r30];
+    }).map((item) => {
+      const [r27, r9] = item;
+      c12429_1 = c12429_1 + r9;
+      return `${r27.padEnd(c12429_0 + 1, " ")} - ${r9}ms`;
+    }).join("\n");
+    if (!(r46.length === 0 || c12429_1 < 8)) {
+      c574_3.log(`
+  Using Hermes: ${!(global?.HermesInternal === void 0)}`, `
+  
+  === ${a0} ===
+  ${r60}`, `
+  Total Time: ${c12429_1}ms
+  
+  `);
+    }
+    return r46;
+  }
+}
+c574_4 = 0;
+class ActionLog {
+  constructor(a0) {
+    const r6 = {
+      __proto__: new.target.prototype,
+      startTime: 0,
+      totalTime: 0,
+      traces: []
+    };
+    const id = +c574_4;
+    c574_4 = id + 1;
+    r6.id = id;
+    r6.action = a0;
+    r6.createdAt = new Date();
+    return r6;
+  }
+  get name() {
+    return this.action.type;
+  }
+  toJSON() {
+    if (this.createdAt == null) {
+      throw new Error("ActionLog.toJSON: You must complete your logging before calling toJSON");
+    }
+    return {
+      actionType: this.action.type,
+      created_at: this.createdAt,
+      totalTime: this.totalTime,
+      traces: this.traces
+    };
+  }
+}
+export { ActionLogger };
+export { ActionLog };

_bundle/Activity.js

@@ -0,0 +1,234 @@
+// Metro module 13536 (f13537).
+import { RPCCommand, joiEnum } from "./Module13537";
+import { OAuth2Scopes } from "./Module8174";
+let Activity, User, ActionRowComponent, ButtonComponent;
+const r11 = {};
+r11[RPCCommand.INITIATE_IMAGE_UPLOAD] = {
+  request: void 0,
+  response: (a0) => ({
+    image_url: a0.string().required()
+  })
+};
+r11[RPCCommand.OPEN_SHARE_MOMENT_DIALOG] = {
+  response: void 0,
+  request: (a0) => ({
+    mediaUrl: a0.string().required().max(1024)
+  })
+};
+r11[RPCCommand.AUTHENTICATE] = {
+  request: (a0) => ({
+    access_token: a0.string().allow(null).optional()
+  }),
+  response: (a0) => {
+    const r3 = {
+      access_token: a0.string().required(),
+      user: a0.object({
+        username: a0.string().required(),
+        discriminator: a0.string().required(),
+        id: a0.string().required(),
+        avatar: a0.string().allow(null),
+        public_flags: a0.number().required(),
+        global_name: a0.string().allow(null)
+      }).required(),
+      scopes: null,
+      expires: null,
+      application: null
+    };
+    const r46 = a0.array();
+    const r49 = a0.string();
+    r3.scopes = r46.items(r49.valid.apply(r49, [...joiEnum(OAuth2Scopes)])).required();
+    r3.expires = a0.string().required();
+    r3.application = a0.object({
+      description: a0.string().required(),
+      icon: a0.string().allow(null),
+      id: a0.string().required(),
+      rpc_origins: a0.array().items(a0.string()).optional(),
+      name: a0.string().required()
+    }).required();
+    return r3;
+  }
+};
+r11[RPCCommand.GET_ACTIVITY_INSTANCE_CONNECTED_PARTICIPANTS] = {
+  request: void 0,
+  response: (a0) => ({
+    participants: a0.array().items(User(a0).keys({
+      nickname: a0.string().description("Server nickname. Not unique.")
+    }).required()).required()
+  })
+};
+r11[RPCCommand.SHARE_INTERACTION] = {
+  request: (a0) => {
+    const r3 = {
+      command: a0.string().required(),
+      options: a0.array().items(a0.object({
+        name: a0.string().required(),
+        value: a0.string().required()
+      })),
+      content: a0.string().max(2000),
+      require_launch_channel: a0.boolean(),
+      preview_image: a0.object({
+        height: a0.number().required(),
+        url: a0.string().required(),
+        width: a0.number().required()
+      }),
+      components: null,
+      pid: null
+    };
+    const r52 = a0.array();
+    r3.components = r52.items(a0.object.call(a0, {
+      type: a0.number().valid(1).required(),
+      components: a0.array().max(5).items(a0.object({
+        type: a0.number().valid(2).required(),
+        style: a0.number().min(1).max(5).required(),
+        label: a0.string().max(80).description("Text that appears on the button"),
+        custom_id: a0.string().max(100).description("Developer-defined identifier for the button; max 100 characters")
+      }))
+    }));
+    r3.pid = a0.number();
+    return r3;
+  },
+  response: (a0) => ({
+    success: a0.boolean().required()
+  })
+};
+r11[RPCCommand.SHARE_LINK] = {
+  request: (a0) => ({
+    custom_id: a0.string().max(64),
+    message: a0.string().max(1000).required(),
+    link_id: a0.string().max(64)
+  }),
+  response: (a0) => ({
+    success: a0.boolean().required(),
+    didCopyLink: a0.boolean().required(),
+    didSendMessage: a0.boolean().required()
+  })
+};
+r11[RPCCommand.GET_RELATIONSHIPS] = {
+  request: void 0,
+  response: (a0) => {
+    const r5 = a0.array().required();
+    const object = a0.object;
+    const r22 = {
+      type: a0.number().required(),
+      user: User(a0).required(),
+      presence: a0.object.call(a0, {
+        status: a0.string().required(),
+        activity: a0.object.call(a0, {
+          session_id: a0.string().optional(),
+          type: a0.number().optional(),
+          name: a0.string().required(),
+          url: a0.string().allow(null).optional(),
+          application_id: a0.string().optional(),
+          status_display_type: a0.number().optional(),
+          state: a0.string().optional(),
+          state_url: a0.string().optional(),
+          details: a0.string().optional(),
+          details_url: a0.string().optional(),
+          emoji: a0.object({
+            name: a0.string().required(),
+            id: a0.string().allow(null).optional(),
+            animated: a0.bool().optional().allow(null)
+          }).allow(null).optional(),
+          assets: a0.object({
+            large_image: a0.string().optional(),
+            large_text: a0.string().optional(),
+            large_url: a0.string().optional(),
+            small_image: a0.string().optional(),
+            small_text: a0.string().optional(),
+            small_url: a0.string().optional()
+          }).optional(),
+          timestamps: a0.object({
+            start: a0.number().optional(),
+            end: a0.number().optional()
+          }).optional(),
+          party: a0.object({
+            id: a0.string().optional(),
+            size: a0.array().items(a0.number()).length(2).optional(),
+            privacy: a0.number().optional()
+          }).optional(),
+          secrets: a0.object({
+            match: a0.string().optional(),
+            join: a0.string().optional()
+          }).optional(),
+          sync_id: a0.string().optional(),
+          created_at: a0.number().optional(),
+          instance: a0.bool().optional(),
+          flags: a0.number().optional(),
+          metadata: a0.object().optional(),
+          platform: a0.string().optional(),
+          supported_platforms: a0.array().items(a0.string()).optional(),
+          buttons: a0.array().items(a0.string()).optional(),
+          hangStatus: a0.string().optional()
+        }).allow(null)
+      })
+    };
+    return {
+      relationships: r5.items(object.call(a0, r22))
+    };
+  }
+};
+r11[RPCCommand.INVITE_USER_EMBEDDED] = {
+  request: (a0) => ({
+    user_id: a0.string().required(),
+    content: a0.string().min(0).max(1024)
+  }),
+  response: void 0
+};
+r11[RPCCommand.GET_USER] = {
+  request: (a0) => ({
+    id: a0.string().max(64).required()
+  }),
+  response: (a0) => User(a0).allow(null)
+};
+r11[RPCCommand.GET_QUEST_ENROLLMENT_STATUS] = {
+  request: (a0) => ({
+    quest_id: a0.string().required()
+  }),
+  response: (a0) => ({
+    quest_id: a0.string().required(),
+    is_enrolled: a0.boolean().required(),
+    enrolled_at: a0.string().allow(null).optional()
+  })
+};
+r11[RPCCommand.QUEST_START_TIMER] = {
+  request: (a0) => ({
+    quest_id: a0.string().required()
+  }),
+  response: (a0) => ({
+    success: a0.boolean().required()
+  })
+};
+r11[RPCCommand.GET_QUEST] = {
+  request: void 0,
+  response: (a0) => ({
+    quest_id: a0.string().required(),
+    enrolled_at: a0.string().allow(null).optional(),
+    completed_at: a0.string().allow(null).optional(),
+    external_cta_url: a0.string().required()
+  })
+};
+r11[RPCCommand.REQUEST_PROXY_TICKET_REFRESH] = {
+  request: void 0,
+  response: (a0) => ({
+    ticket: a0.string().required()
+  })
+};
+Activity = (a0) => {};
+User = (a0) => a0.object({
+  id: a0.string().required().description("User ID"),
+  username: a0.string().required(),
+  global_name: a0.string().allow(null).description("Global Discord name. Not unique."),
+  discriminator: a0.string().required().description("Global name discriminator. Will be 0 if a unique username"),
+  avatar: a0.string().allow(null).description("User Avatar ID"),
+  flags: a0.number().required().description("Public user flags"),
+  bot: a0.bool().required().description("If a bot user."),
+  avatar_decoration_data: a0.object({
+    asset: a0.string().allow(null),
+    skuId: a0.string(),
+    expiresAt: a0.number()
+  }).allow(null).description("Details about avatar decoration"),
+  premium_type: a0.number().allow(null).description("Nitro premium type")
+}).description("Discord User");
+ActionRowComponent = (a0) => {};
+ButtonComponent = (a0) => {};
+export { r11 as RPCCommandSchemas };

_bundle/ActivityIndicator.jsx

@@ -0,0 +1,50 @@
+// Metro module 18 (f19).
+import ProgressBarAndroid from "./ProgressBarAndroid";
+import View from "./View";
+import Module254 from "./Module254";
+let styles;
+const ActivityIndicator = (props) => {
+  let size2, sizeSmall;
+  const { ref, animating = true, color = null, hidesWhenStopped = true, onLayout, size = "small", style, ...rest } = props;
+  if (size === "small") {
+    sizeSmall = styles.sizeSmall;
+    size2 = "small";
+  } else if (size === "large") {
+    sizeSmall = styles.sizeLarge;
+    size2 = "large";
+  } else {
+    sizeSmall = {
+      height: size,
+      width: size
+    };
+    size2 = void 0;
+  }
+  const props2 = {
+    animating,
+    color,
+    hidesWhenStopped,
+    ...rest,
+    ref,
+    style: sizeSmall,
+    size: size2
+  };
+  return <View onLayout={onLayout} style={Module254.compose(styles.container, style)}>
+    <ProgressBarAndroid {...props2} styleAttr="Normal" indeterminate />
+  </View>;
+};
+ActivityIndicator.displayName = "ActivityIndicator";
+styles = Module254.create({
+  container: {
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  sizeSmall: {
+    width: 20,
+    height: 20
+  },
+  sizeLarge: {
+    width: 36,
+    height: 36
+  }
+});
+export default ActivityIndicator;

_bundle/AgeRangeThresholdManager.js

@@ -0,0 +1,68 @@
+// Metro module 16291 (f16292).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+let env11708 = {};
+const AgeRangeThresholdManager = function AgeRangeThresholdManager() {
+  _classCallCheck(this, AgeRangeThresholdManager);
+  this.thresholds = null;
+};
+export const ageRangeThresholdManager = _createClass(AgeRangeThresholdManager, [{
+  key: "setAgeRangeThresholds",
+  value: function setAgeRangeThresholds(a0) {
+    if (a0[0] !== void 0 && a0[0] !== null) {
+      if (!(a0[0] < 1) && !(a0[0] > 18)) {
+        const r16 = 1 < a0.length;
+        let r17 = 1;
+        if (r16) {
+          do {
+            const r7 = a0[r17];
+            const r18 = a0[r17 - 1];
+            const r19 = r17;
+            if (r7 !== void 0 && r18 !== void 0 && r7 <= r18) {
+              throw new Error("PlayAgeRangeDeclaration: Age range thresholds must be in ascending order");
+            }
+            r17 = r19 + 1;
+          } while (r17 < a0.length);
+        }
+        const r22 = 1 < a0.length;
+        let r24 = 1;
+        if (r22) {
+          do {
+            const r25 = a0[r24];
+            const r26 = a0[r24 - 1];
+            const r27 = r24;
+            if (r25 !== void 0 && r26 !== void 0 && r25 - r26 < 2) {
+              throw new Error("PlayAgeRangeDeclaration: Age range thresholds must be at least 2 years apart");
+            }
+            r24 = r27 + 1;
+          } while (r24 < a0.length);
+        }
+        this.thresholds = [a0[0], a0[1], a0[2]];
+        return void 0;
+      }
+      throw new Error("PlayAgeRangeDeclaration: setAgeRangeThresholds: Age range thresholds must be between 1 and 18 (inclusive)");
+    }
+    throw new Error("PlayAgeRangeDeclaration: First threshold age is required");
+  }
+}, {
+  key: "getThresholds",
+  value: function getThresholds() {
+    if (this.thresholds === null) {
+      throw new Error("PlayAgeRangeDeclaration: ageRangeThresholds not set");
+    }
+    return this.thresholds;
+  }
+}], [{
+  key: "getInstance",
+  value: function getInstance() {
+    if (!AgeRangeThresholdManager.instance) {
+      const instance = {
+        __proto__: AgeRangeThresholdManager.prototype
+      };
+      _classCallCheck(instance, AgeRangeThresholdManager);
+      instance.thresholds = null;
+      AgeRangeThresholdManager.instance = instance;
+    }
+    return AgeRangeThresholdManager.instance;
+  }
+}]).getInstance();

_bundle/Agent.js

@@ -0,0 +1,183 @@
+// Metro module 583 (f584).
+let length2;
+const _createForOfIteratorHelper = function _createForOfIteratorHelper(a0, a1) {
+  let r19;
+  let c12375_2, c12375_3, done, c12375_5;
+  let c12375_0 = a0;
+  const Symbol2 = globalThis.Symbol;
+  const r6 = (typeof Symbol2 !== "undefined" ? a0[Symbol.iterator] : typeof Symbol2 !== "undefined") || a0["@@iterator"];
+  let c12375_1 = r6;
+  if (r6) {
+    done = true;
+    c12375_5 = false;
+    return {
+      s: function() {
+        c12375_1 = c12375_1.call(c12375_0);
+      },
+      n: function n() {
+        const r3 = c12375_1.next();
+        done = r3.done;
+        return r3;
+      },
+      e: function e(a0) {
+        c12375_5 = true;
+        c12375_3 = a0;
+      },
+      f: function f() {
+        try {
+          if (!(done || c12375_1.return == null)) {
+            c12375_1.return();
+          }
+        } catch (r11) {
+          if (c12375_5) {
+            throw c12375_3;
+          }
+          throw r11;
+        }
+        if (c12375_5) {
+          throw c12375_3;
+        }
+      }
+    };
+  }
+  if (!Array.isArray(a0)) {
+    L25: {
+      r19 = void 0;
+      if (a0) {
+        if (typeof a0 === "string") {
+          const length2 = a0.length;
+          const array2 = new Array(length2);
+          let r52 = 0;
+          const r53 = 0 < length2;
+          r19 = array2;
+          if (r53) {
+            do {
+              array2[r52] = a0[r52];
+              r52 = r52 + 1;
+              r19 = array2;
+            } while (r52 < length2);
+          }
+        } else {
+          const r25 = Object.prototype.toString.call(a0).slice(8, -1);
+          const r10 = r25 === "Object" && a0.constructor ? a0.constructor.name : r25;
+          if (r10 !== "Map" && r10 !== "Set") {
+            if (r10 !== "Arguments") {
+              const r34 = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r10);
+              r19 = void 0;
+              if (!r34) {
+                break L25;
+              }
+            }
+            const length = a0.length;
+            const array = new Array(length);
+            let r40 = 0;
+            const r3 = 0 < length;
+            r19 = array;
+            if (!r3) {
+              break L25;
+            }
+            while (true) {
+              array[r40] = a0[r40];
+              r40 = r40 + 1;
+              r19 = array;
+              if (!(r40 < length)) {
+                break L25;
+              }
+            }
+          }
+          r19 = Array.from(a0);
+        }
+      }
+    }
+    c12375_1 = r19;
+    if (!r19) {
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+  }
+  const r62 = c12375_1;
+  if (r62) {
+    c12375_0 = r62;
+  }
+  c12375_2 = 0;
+  const F = function F() {};
+  return {
+    s: F,
+    n: function n() {
+      let r8;
+      const r1 = c12375_2;
+      if (r1 >= c12375_0.length) {
+        r8 = {
+          done: true
+        };
+      } else {
+        const r6 = +c12375_2;
+        c12375_2 = r6 + 1;
+        r8 = {
+          done: false,
+          value: c12375_0[r6]
+        };
+      }
+      return r8;
+    },
+    e: function e(a0) {
+      throw a0;
+    },
+    f: F
+  };
+};
+const Agent = function Agent() {
+  this._defaults = [];
+};
+const r9 = ["use", "on", "once", "set", "query", "type", "accept", "auth", "withCredentials", "sortQuery", "retry", "ok", "redirects", "timeout", "buffer", "serialize", "parse", "ca", "key", "pfx", "cert", "disableTLSCerts"];
+const length = r9.length;
+let r1 = 0;
+const r5 = 0 < length;
+let r0 = 0;
+if (r5) {
+  do {
+    const fn = r9[r0];
+    Agent.prototype[fn] = function() {
+      const length = arguments.length;
+      const array = new Array(length);
+      let r0 = 0;
+      while (r0 < length) {
+        array[r0] = arguments[r0];
+        r0 = r0 + 1;
+      }
+      this._defaults.push({
+        fn,
+        args: array
+      });
+      return this;
+    };
+    r0 = r1 + 1;
+    length2 = r9.length;
+    r1 = r0;
+  } while (r1 < length2);
+}
+Agent.prototype._setDefaults = function(a0) {
+  let r29;
+  const r13 = _createForOfIteratorHelper(this._defaults);
+  try {
+    try {
+      r13.s();
+      const r17 = r13.n();
+      let r18 = r17;
+      if (!r17.done) {
+        do {
+          const value = r18.value;
+          a0[value.fn].apply(a0, [...value.args]);
+          r29 = r13.n();
+          r18 = r29;
+        } while (!r29.done);
+      }
+    } catch ($e) {
+      r13.e($e);
+    }
+  } catch (r36) {
+    r13.f();
+    throw r36;
+  }
+  r13.f();
+};
+module.exports = Agent;

_bundle/Alert.js

@@ -0,0 +1,67 @@
+// Metro module 231 (f232).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import * as _Module232 from "./Module232";
+let env254 = {};
+const Alert = function Alert() {
+  _classCallCheck(this, Alert);
+};
+export default _createClass(Alert, null, [{
+  key: "alert",
+  value: function alert(a0, a1, a2, a3) {
+    let constants, c23627_2, c23627_3, c23627_4;
+    if (_Module232.default) {
+      let title = a0;
+      constants = _Module232.default.getConstants();
+      if (!a0) {
+        title = "";
+      }
+      const r16 = {
+        title,
+        message: a1 ? a1 : "",
+        cancelable: false
+      };
+      if (a3 ? a3.cancelable : a3) {
+        r16.cancelable = a3.cancelable;
+      }
+      const r9 = a2 ? a2.slice(0, 3) : [{
+        text: "OK"
+      }];
+      const r23 = r9.pop();
+      c23627_2 = r23;
+      const r25 = r9.pop();
+      c23627_3 = r25;
+      const r27 = r9.pop();
+      c23627_4 = r27;
+      if (r27) {
+        r16.buttonNeutral = r27.text || "";
+      }
+      if (r25) {
+        r16.buttonNegative = r25.text || "";
+      }
+      if (r23) {
+        r16.buttonPositive = r23.text || "OK";
+      }
+      _Module232.default.showAlert(r16, (a0) => console.warn(a0), (a0, a1) => {
+        if (a0 === constants.buttonClicked) {
+          if (a1 === constants.buttonNeutral) {
+            if (c23627_4.onPress) {
+              c23627_4.onPress();
+            }
+          } else if (a1 === constants.buttonNegative) {
+            if (c23627_3.onPress) {
+              c23627_3.onPress();
+            }
+          } else if (a1 === constants.buttonPositive && c23627_2.onPress) {
+            c23627_2.onPress();
+          }
+        } else if (a0 === constants.dismissed && a3 && a3.onDismiss) {
+          a3.onDismiss();
+        }
+      });
+    }
+  }
+}, {
+  key: "prompt",
+  value: function prompt(a0, a1, a2) {}
+}]);

_bundle/AnimatedAddition.js

@@ -0,0 +1,107 @@
+// Metro module 355 (f356).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import AnimatedValue from "./AnimatedValue";
+import mapStringToNumericComponents from "./mapStringToNumericComponents";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66215($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedAddition;
+let env368 = {};
+env368[6] = function _isNativeReflectConstruct() {
+  let c12271_0;
+  try {
+    c12271_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12271_0;
+  };
+  env368[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedAddition = function AnimatedAddition(a0, a1, a2) {
+  _classCallCheck(this, AnimatedAddition);
+  const r9 = [a2];
+  const r8 = _getPrototypeOf(AnimatedAddition);
+  const r26 = _possibleConstructorReturn(this, (0, env368[6])() ? Reflect.construct(r8, r9, _getPrototypeOf(this).constructor) : r8.apply(this, r9));
+  r26._a = typeof a0 === "number" ? new AnimatedValue(a0) : a0;
+  r26._b = typeof a1 === "number" ? new AnimatedValue(a1) : a1;
+  return r26;
+};
+_inherits(AnimatedAddition, AnimatedWithChildren);
+export default _createClass(AnimatedAddition, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23686;
+    this._a.__makeNative(a0);
+    this._b.__makeNative(a0);
+    const r13 = env23686 = {};
+    env23686[0] = this;
+    env23686[1] = void 0;
+    let r18 = _get(_getPrototypeOf(AnimatedAddition.prototype), "__makeNative", this);
+    env23686[1] = r18;
+    if (typeof r18 === "function") {
+      r18 = $mk66215(r13);
+    }
+    r18([a0]);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    return this._a.__getValue() + this._b.__getValue();
+  }
+}, {
+  key: "interpolate",
+  value: function interpolate(a0) {
+    return new mapStringToNumericComponents(this, a0);
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    let env23687;
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+    const r12 = env23687 = {};
+    env23687[0] = this;
+    env23687[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedAddition.prototype), "__attach", this);
+    env23687[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66215(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23688;
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    const r12 = env23688 = {};
+    env23688[0] = this;
+    env23688[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedAddition.prototype), "__detach", this);
+    env23688[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66215(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    return {
+      type: "addition",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+      debugID: this.__getDebugID()
+    };
+  }
+}]);

_bundle/AnimatedChild.jsx

@@ -0,0 +1,107 @@
+// Metro module 16045 (f16046).
+import { memo, useState } from "react";
+import { View, StyleSheet } from "react-native";
+import * as _Module1606 from "./Module1606";
+import Module1606, { useAnimatedStyle, useSharedValue, useFrameCallback, useAnimatedReaction } from "./Module1606";
+let __initData2, __initData3, __initData4, styles;
+const __initData = {
+  code: "function pnpm_indexTsx1(){const{index,textWidth,spacing,anim}=this.__closure;return{position:'absolute',left:index*(textWidth.value+spacing),transform:[{translateX:-(anim.value%(textWidth.value+spacing))}]};}"
+};
+const AnimatedChild = (props) => {
+  const { index, children: children2, anim, textWidth, spacing } = props;
+  const c = function c() {
+    return {
+      position: "absolute",
+      left: index * (textWidth.value + spacing),
+      transform: [{
+        translateX: -anim.value % (textWidth.value + spacing)
+      }]
+    };
+  };
+  c.__closure = {
+    index,
+    textWidth,
+    spacing,
+    anim
+  };
+  c.__workletHash = 9107973864402;
+  c.__initData = __initData;
+  return <Module1606.View style={useAnimatedStyle(c, [index, spacing, textWidth])}>{children2}</Module1606.View>;
+};
+__initData2 = {
+  code: "function pnpm_indexTsx2(){const{anim,speed}=this.__closure;anim.value+=speed;}"
+};
+__initData3 = {
+  code: "function pnpm_indexTsx3(){const{textWidth,parentWidth}=this.__closure;if(textWidth.value===0||parentWidth.value===0){return 0;}return Math.round(parentWidth.value/textWidth.value)+1;}"
+};
+__initData4 = {
+  code: "function pnpm_indexTsx4(v){const{runOnJS,setCloneTimes}=this.__closure;if(v===0){return;}runOnJS(setCloneTimes)(v*2);}"
+};
+const r34 = memo((a0) => {
+  let speed = a0.speed;
+  if (speed === void 0) {
+    speed = 1;
+  }
+  let c22759_0 = speed;
+  const { children, spacing: spacing3 = 0 } = a0;
+  const spacing2 = spacing3;
+  const style = a0.style;
+  const sharedValue = useSharedValue(0);
+  const sharedValue2 = useSharedValue(0);
+  const [state, setState] = useState(0);
+  const sharedValue3 = useSharedValue(0);
+  const w = function w() {
+    sharedValue3.value = sharedValue3.value + c22759_0;
+  };
+  w.__closure = {
+    anim: sharedValue3,
+    speed
+  };
+  w.__workletHash = 5612715942613;
+  w.__initData = __initData2;
+  useFrameCallback(w, true);
+  const W = function W() {
+    return sharedValue2.value !== 0 ? sharedValue.value !== 0 ? Math.round(sharedValue.value / sharedValue2.value) + 1 : 0 : 0;
+  };
+  W.__closure = {
+    textWidth: sharedValue2,
+    parentWidth: sharedValue
+  };
+  W.__workletHash = 4132969599661;
+  W.__initData = __initData3;
+  const y = function y(a0) {
+    if (a0 !== 0) {
+      _Module1606.runOnJS(setState)(2 * a0);
+    }
+  };
+  y.__closure = {
+    runOnJS: _Module1606.runOnJS,
+    setCloneTimes: setState
+  };
+  y.__workletHash = 8842395428122;
+  y.__initData = __initData4;
+  useAnimatedReaction(W, y, []);
+  return <Module1606.View style={style} onLayout={(event) => {
+    sharedValue.value = event.nativeEvent.layout.width;
+  }} pointerEvents="box-none">
+    <Module1606.View style={styles.row} pointerEvents="box-none">
+      <Module1606.ScrollView horizontal style={styles.hidden} pointerEvents="box-none">
+        <View onLayout={(event) => {
+          sharedValue2.value = event.nativeEvent.layout.width;
+        }}>{children}</View>
+      </Module1606.ScrollView>
+      {state > 0 && [...Array(state).keys()].map((item) => <AnimatedChild key={`clone-${item}`} index={item} anim={sharedValue3} textWidth={sharedValue2} spacing={spacing2}>{children}</AnimatedChild>)}
+    </Module1606.View>
+  </Module1606.View>;
+});
+styles = StyleSheet.create({
+  hidden: {
+    opacity: 0,
+    zIndex: -9999
+  },
+  row: {
+    flexDirection: "row",
+    overflow: "hidden"
+  }
+});
+export { r34 as Marquee };

_bundle/AnimatedCircularProgress.jsx

@@ -0,0 +1,110 @@
+// Metro module 14086 (f14087).
+import _objectWithoutProperties from "./_objectWithoutProperties";
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import Module19 from "react";
+import * as _Module17 from "react-native";
+import CircularProgress from "./CircularProgress";
+import Module12253 from "./Module12253";
+let _excluded, Component;
+let AnimatedCircularProgress;
+let env9852 = {};
+env9852[7] = function _isNativeReflectConstruct() {
+  let c20891_0;
+  try {
+    c20891_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c20891_0;
+  };
+  env9852[7] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+_excluded = ["fill", "prefill"];
+const { Animated: Animated2, Easing } = _Module17;
+Component = Animated2.createAnimatedComponent(CircularProgress);
+const PureComponent = Module19.PureComponent;
+AnimatedCircularProgress = function AnimatedCircularProgress(a0) {
+  let c27622_0 = a0;
+  _classCallCheck(this, AnimatedCircularProgress);
+  const r11 = [a0];
+  const r10 = _getPrototypeOf(AnimatedCircularProgress);
+  const r26 = _possibleConstructorReturn(this, (0, env9852[7])() ? Reflect.construct(r10, r11, _getPrototypeOf(this).constructor) : r10.apply(this, r11));
+  r26.state = {
+    fillAnimation: new _Module17.Animated.Value(a0.prefill)
+  };
+  if (a0.onFillChange) {
+    r26.state.fillAnimation.addListener((a0) => c27622_0.onFillChange(a0.value));
+  }
+  return r26;
+};
+_inherits(AnimatedCircularProgress, PureComponent);
+const r59 = _createClass(AnimatedCircularProgress, [{
+  key: "componentDidMount",
+  value: function componentDidMount() {
+    this.animate();
+  }
+}, {
+  key: "componentDidUpdate",
+  value: function componentDidUpdate(a0) {
+    if (a0.fill !== this.props.fill) {
+      this.animate();
+    }
+  }
+}, {
+  key: "reAnimate",
+  value: function reAnimate(a0, c27623_1, c27623_2, c27623_0) {
+    this.setState({
+      fillAnimation: new _Module17.Animated.Value(a0)
+    }, () => this.animate(c27623_1, c27623_2, c27623_0));
+  }
+}, {
+  key: "animate",
+  value: function animate(a0, a1, a2) {
+    const r18 = _Module17.Animated.timing(this.state.fillAnimation, {
+      useNativeDriver: this.props.useNativeDriver,
+      toValue: a0 >= 0 ? a0 : this.props.fill,
+      easing: a2 ? a2 : this.props.easing,
+      duration: a1 ? a1 : this.props.duration,
+      delay: this.props.delay
+    });
+    r18.start(this.props.onAnimationComplete);
+    return r18;
+  }
+}, {
+  key: "animateColor",
+  value: function animateColor() {
+    return this.props.tintColorSecondary ? this.state.fillAnimation.interpolate({
+      inputRange: [0, 100],
+      outputRange: [this.props.tintColor, this.props.tintColorSecondary]
+    }) : this.props.tintColor;
+  }
+}, {
+  key: "render",
+  value: function render() {
+    const props = this.props;
+    props.fill;
+    props.prefill;
+    return <Component {..._objectWithoutProperties(props, _excluded)} fill={this.state.fillAnimation} tintColor={this.animateColor()} />;
+  }
+}]);
+r59.propTypes = {
+  ...CircularProgress.propTypes,
+  prefill: Module12253.number,
+  duration: Module12253.number,
+  easing: Module12253.func,
+  onAnimationComplete: Module12253.func,
+  useNativeDriver: Module12253.bool,
+  delay: Module12253.number
+};
+r59.defaultProps = {
+  duration: 500,
+  easing: Easing.out(Easing.ease),
+  prefill: 0,
+  useNativeDriver: false,
+  delay: 0
+};
+export default r59;

_bundle/AnimatedDiffClamp.js

@@ -0,0 +1,113 @@
+// Metro module 372 (f373).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import mapStringToNumericComponents from "./mapStringToNumericComponents";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66339($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedDiffClamp;
+let env392 = {};
+env392[6] = function _isNativeReflectConstruct() {
+  let c12286_0;
+  try {
+    c12286_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12286_0;
+  };
+  env392[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedDiffClamp = function AnimatedDiffClamp(a0, a1, a2, a3) {
+  _classCallCheck(this, AnimatedDiffClamp);
+  const r8 = [a3];
+  const r7 = _getPrototypeOf(AnimatedDiffClamp);
+  const r24 = _possibleConstructorReturn(this, (0, env392[6])() ? Reflect.construct(r7, r8, _getPrototypeOf(this).constructor) : r7.apply(this, r8));
+  r24._a = a0;
+  r24._min = a1;
+  r24._max = a2;
+  const _lastValue = r24._a.__getValue();
+  r24._lastValue = _lastValue;
+  r24._value = _lastValue;
+  return r24;
+};
+_inherits(AnimatedDiffClamp, AnimatedWithChildren);
+export default _createClass(AnimatedDiffClamp, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23721;
+    this._a.__makeNative(a0);
+    const r10 = env23721 = {};
+    env23721[0] = this;
+    env23721[1] = void 0;
+    let r15 = _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__makeNative", this);
+    env23721[1] = r15;
+    if (typeof r15 === "function") {
+      r15 = $mk66339(r10);
+    }
+    r15([a0]);
+  }
+}, {
+  key: "interpolate",
+  value: function interpolate(a0) {
+    return new mapStringToNumericComponents(this, a0);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    const _lastValue = this._a.__getValue();
+    const r9 = _lastValue - this._lastValue;
+    this._lastValue = _lastValue;
+    this._value = Math.min(Math.max(this._value + r9, this._min), this._max);
+    return this._value;
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    let env23722;
+    this._a.__addChild(this);
+    const r9 = env23722 = {};
+    env23722[0] = this;
+    env23722[1] = void 0;
+    let r14 = _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__attach", this);
+    env23722[1] = r14;
+    if (typeof r14 === "function") {
+      r14 = $mk66339(r9);
+    }
+    r14([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23723;
+    this._a.__removeChild(this);
+    const r9 = env23723 = {};
+    env23723[0] = this;
+    env23723[1] = void 0;
+    let r14 = _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__detach", this);
+    env23723[1] = r14;
+    if (typeof r14 === "function") {
+      r14 = $mk66339(r9);
+    }
+    r14([]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    return {
+      type: "diffclamp",
+      input: this._a.__getNativeTag(),
+      min: this._min,
+      max: this._max,
+      debugID: this.__getDebugID()
+    };
+  }
+}]);

_bundle/AnimatedDivision.js

@@ -0,0 +1,127 @@
+// Metro module 369 (f370).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import AnimatedNode from "./AnimatedNode";
+import AnimatedValue from "./AnimatedValue";
+import mapStringToNumericComponents from "./mapStringToNumericComponents";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66309($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedDivision;
+let env386 = {};
+env386[6] = function _isNativeReflectConstruct() {
+  let c12283_0;
+  try {
+    c12283_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12283_0;
+  };
+  env386[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedDivision = function AnimatedDivision(a0, a1, a2) {
+  _classCallCheck(this, AnimatedDivision);
+  const r13 = [a2];
+  const r12 = _getPrototypeOf(AnimatedDivision);
+  const r30 = _possibleConstructorReturn(this, (0, env386[6])() ? Reflect.construct(r12, r13, _getPrototypeOf(this).constructor) : r12.apply(this, r13));
+  r30._warnedAboutDivideByZero = false;
+  if (a1 === 0 || a1 instanceof AnimatedNode && a1.__getValue() === 0) {
+    console.error("Detected potential division by zero in AnimatedDivision");
+  }
+  r30._a = typeof a0 === "number" ? new AnimatedValue(a0) : a0;
+  r30._b = typeof a1 === "number" ? new AnimatedValue(a1) : a1;
+  return r30;
+};
+_inherits(AnimatedDivision, AnimatedWithChildren);
+export default _createClass(AnimatedDivision, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23712;
+    this._a.__makeNative(a0);
+    this._b.__makeNative(a0);
+    const r13 = env23712 = {};
+    env23712[0] = this;
+    env23712[1] = void 0;
+    let r18 = _get(_getPrototypeOf(AnimatedDivision.prototype), "__makeNative", this);
+    env23712[1] = r18;
+    if (typeof r18 === "function") {
+      r18 = $mk66309(r13);
+    }
+    r18([a0]);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    let r10;
+    const r7 = this._a.__getValue();
+    const r9 = this._b.__getValue();
+    if (r9 === 0) {
+      const _warnedAboutDivideByZero = this._warnedAboutDivideByZero;
+      r10 = 0;
+      if (!_warnedAboutDivideByZero) {
+        console.error("Detected division by zero in AnimatedDivision");
+        this._warnedAboutDivideByZero = true;
+        r10 = 0;
+      }
+    } else {
+      this._warnedAboutDivideByZero = false;
+      r10 = r7 / r9;
+    }
+    return r10;
+  }
+}, {
+  key: "interpolate",
+  value: function interpolate(a0) {
+    return new mapStringToNumericComponents(this, a0);
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    let env23713;
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+    const r12 = env23713 = {};
+    env23713[0] = this;
+    env23713[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedDivision.prototype), "__attach", this);
+    env23713[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66309(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23714;
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    const r12 = env23714 = {};
+    env23714[0] = this;
+    env23714[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedDivision.prototype), "__detach", this);
+    env23714[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66309(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    return {
+      type: "division",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+      debugID: this.__getDebugID()
+    };
+  }
+}]);

_bundle/AnimatedEvent.js

@@ -0,0 +1,237 @@
+// Metro module 384 (f385).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import AnimatedValue from "./AnimatedValue";
+import AnimatedValueXY from "./AnimatedValueXY";
+import Module38 from "./Module38";
+import { findNodeHandle } from "./Module114";
+import Module357 from "./Module357";
+function $mk66464($env) {
+  return (a0, a1) => {
+    const r4 = $env;
+    const r5 = $env.$parent;
+    const r6 = r5[1];
+    const r14 = r5[2];
+    if (a0 instanceof r6(r14[2])) {
+      a0.__makeNative(r4[1]);
+      r4[2].push({
+        nativeEventPath: a1,
+        animatedValueTag: a0.__getNativeTag()
+      });
+    } else if (a0 instanceof r6(r14[3])) {
+      const r24 = r4[3];
+      r24(a0.x, a1.concat("x"));
+      r24(a0.y, a1.concat("y"));
+    } else if (typeof a0 === "object") {
+      for (const key in a0) {
+        (0, r4[3])(a0[key], a1.concat(key));
+      }
+    }
+  };
+}
+function $mk66465($env) {
+  return (a0) => {
+    const r1 = $env;
+    const r2 = $env.$parent;
+    (0, r2[1])(r2[2][6]).API.addAnimatedEventToView(r1[4], r1[0], a0);
+  };
+}
+function $mk66466($env) {
+  return () => {
+    const r1 = $env;
+    if (r1[4] != null) {
+      r1[2].forEach($mk101222(r1));
+    }
+  };
+}
+function $mk101222($env) {
+  return (a0) => {
+    const r1 = $env;
+    const r2 = $env.$parent;
+    (0, r2[1])(r2[2][6]).API.removeAnimatedEventFromView(r1[4], r1[0], a0.animatedValueTag);
+  };
+}
+let env412 = {};
+const AnimatedEvent = function AnimatedEvent(a0, a1) {
+  const _this = this;
+  let r2 = a1;
+  _classCallCheck(this, AnimatedEvent);
+  this._listeners = [];
+  this._callListeners = function(...c28648_0) {
+    _this._listeners.forEach((_listener) => _listener.apply(void 0, [...c28648_0]));
+  };
+  this._argMapping = a0;
+  if (a1 == null) {
+    console.warn("Animated.event now requires a second argument for options");
+    r2 = {
+      useNativeDriver: false
+    };
+  }
+  if (r2.listener) {
+    this.__addListener(r2.listener);
+  }
+  this._attachedEvent = null;
+  this.__isNative = Module357.shouldUseNativeDriver(r2);
+  this.__platformConfig = r2.platformConfig;
+};
+const r29 = _createClass(AnimatedEvent, [{
+  key: "__addListener",
+  value: function __addListener(a0) {
+    this._listeners.push(a0);
+  }
+}, {
+  key: "__removeListener",
+  value: function __removeListener(c23759_0) {
+    this._listeners = this._listeners.filter((_listener) => _listener !== c23759_0);
+  }
+}, {
+  key: "__attach",
+  value: function __attach(a0, a1) {
+    let env23760;
+    Module38(this.__isNative, "Only native driven events need to be attached.");
+    const _argMapping = this._argMapping;
+    const __platformConfig = this.__platformConfig;
+    const r16 = env23760 = {
+      $parent: env412
+    };
+    env23760[0] = a1;
+    env23760[1] = __platformConfig;
+    env23760[4] = void 0;
+    const r18 = [];
+    env23760[2] = r18;
+    const r10 = $mk66464(r16);
+    env23760[3] = r10;
+    Module38(_argMapping[0] && _argMapping[0].nativeEvent, "Native driven events only support animated values contained inside `nativeEvent`.");
+    r10(_argMapping[0].nativeEvent, []);
+    const r31 = findNodeHandle(a0);
+    env23760[4] = r31;
+    if (r31 != null) {
+      r18.forEach($mk66465(r16));
+    }
+    this._attachedEvent = {
+      detach: $mk66466(r16)
+    };
+  }
+}, {
+  key: "__detach",
+  value: function __detach(a0, a1) {
+    Module38(this.__isNative, "Only native driven events need to be detached.");
+    if (this._attachedEvent) {
+      this._attachedEvent.detach();
+    }
+  }
+}, {
+  key: "__getHandler",
+  value: function __getHandler() {
+    const _this2 = this;
+    if (this.__isNative) {
+      return this._callListeners;
+    }
+    return function(...args) {
+      let c28649_0 = args;
+      const traverse2 = (a0, a1) => {
+        if (a0 instanceof AnimatedValue) {
+          if (typeof a1 === "number") {
+            a0.setValue(a1);
+          }
+        } else if (a0 instanceof AnimatedValueXY) {
+          if (typeof a1 === "object") {
+            traverse2(a0.x, a1.x);
+            traverse2(a0.y, a1.y);
+          }
+        } else if (typeof a0 === "object") {
+          for (const key in a0) {
+            traverse2(a0[key], a1[key]);
+          }
+        }
+      };
+      _this2._argMapping.forEach((item, index) => {
+        const r24 = c28649_0[index];
+        if (item instanceof AnimatedValue) {
+          if (typeof r24 === "number") {
+            item.setValue(r24);
+          }
+        } else if (item instanceof AnimatedValueXY) {
+          if (typeof r24 === "object") {
+            const r51 = item.x;
+            const r52 = r24.x;
+            if (r51 instanceof AnimatedValue) {
+              if (typeof r52 === "number") {
+                r51.setValue(r52);
+              }
+            } else if (r51 instanceof AnimatedValueXY) {
+              if (typeof r52 === "object") {
+                traverse2(r51.x, r52.x);
+                traverse2(r51.y, r52.y);
+              }
+            } else if (typeof r51 === "object") {
+              for (const key3 in r51) {
+                traverse2(r51[key3], r52[key3]);
+              }
+            }
+            const r80 = item.y;
+            const r81 = r24.y;
+            if (r80 instanceof AnimatedValue) {
+              if (typeof r81 === "number") {
+                r80.setValue(r81);
+              }
+            } else if (r80 instanceof AnimatedValueXY) {
+              if (typeof r81 === "object") {
+                traverse2(r80.x, r81.x);
+                traverse2(r80.y, r81.y);
+              }
+            } else if (typeof r80 === "object") {
+              for (const key4 in r80) {
+                const r96 = key4;
+                traverse2(r80[r96], r81[r96]);
+              }
+            }
+          }
+        } else if (typeof item === "object") {
+          for (const key in item) {
+            const r18 = item[key];
+            const r17 = r24[key];
+            if (r18 instanceof AnimatedValue) {
+              if (typeof r17 === "number") {
+                r18.setValue(r17);
+              }
+            } else if (r18 instanceof AnimatedValueXY) {
+              if (typeof r17 === "object") {
+                traverse2(r18.x, r17.x);
+                traverse2(r18.y, r17.y);
+              }
+            } else if (typeof r18 === "object") {
+              for (const key2 in r18) {
+                traverse2(r18[key2], r17[key2]);
+              }
+            }
+          }
+        }
+      });
+      _this2._callListeners.apply(_this2, [...args]);
+    };
+  }
+}]);
+export function attachNativeEventImpl(a0, a1, a2, a3) {
+  let env12296;
+  const r3 = env12296 = {
+    $parent: env412
+  };
+  env12296[0] = a1;
+  env12296[1] = a3;
+  const r5 = [];
+  env12296[2] = r5;
+  const r9 = $mk66464(r3);
+  env12296[3] = r9;
+  Module38(a2[0] && a2[0].nativeEvent, "Native driven events only support animated values contained inside `nativeEvent`.");
+  r9(a2[0].nativeEvent, []);
+  const r25 = findNodeHandle(a0);
+  env12296[4] = r25;
+  if (r25 != null) {
+    r5.forEach($mk66465(r3));
+  }
+  return {
+    detach: $mk66466(r3)
+  };
+}
+export { r29 as AnimatedEvent };

_bundle/AnimatedModulo.js

@@ -0,0 +1,104 @@
+// Metro module 371 (f372).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import mapStringToNumericComponents from "./mapStringToNumericComponents";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66329($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedModulo;
+let env390 = {};
+env390[6] = function _isNativeReflectConstruct() {
+  let c12285_0;
+  try {
+    c12285_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12285_0;
+  };
+  env390[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedModulo = function AnimatedModulo(a0, a1, a2) {
+  _classCallCheck(this, AnimatedModulo);
+  const r8 = [a2];
+  const r7 = _getPrototypeOf(AnimatedModulo);
+  const r23 = _possibleConstructorReturn(this, (0, env390[6])() ? Reflect.construct(r7, r8, _getPrototypeOf(this).constructor) : r7.apply(this, r8));
+  r23._a = a0;
+  r23._modulus = a1;
+  return r23;
+};
+_inherits(AnimatedModulo, AnimatedWithChildren);
+export default _createClass(AnimatedModulo, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23718;
+    this._a.__makeNative(a0);
+    const r10 = env23718 = {};
+    env23718[0] = this;
+    env23718[1] = void 0;
+    let r15 = _get(_getPrototypeOf(AnimatedModulo.prototype), "__makeNative", this);
+    env23718[1] = r15;
+    if (typeof r15 === "function") {
+      r15 = $mk66329(r10);
+    }
+    r15([a0]);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
+  }
+}, {
+  key: "interpolate",
+  value: function interpolate(a0) {
+    return new mapStringToNumericComponents(this, a0);
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    let env23719;
+    this._a.__addChild(this);
+    const r9 = env23719 = {};
+    env23719[0] = this;
+    env23719[1] = void 0;
+    let r14 = _get(_getPrototypeOf(AnimatedModulo.prototype), "__attach", this);
+    env23719[1] = r14;
+    if (typeof r14 === "function") {
+      r14 = $mk66329(r9);
+    }
+    r14([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23720;
+    this._a.__removeChild(this);
+    const r9 = env23720 = {};
+    env23720[0] = this;
+    env23720[1] = void 0;
+    let r14 = _get(_getPrototypeOf(AnimatedModulo.prototype), "__detach", this);
+    env23720[1] = r14;
+    if (typeof r14 === "function") {
+      r14 = $mk66329(r9);
+    }
+    r14([]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    return {
+      type: "modulus",
+      input: this._a.__getNativeTag(),
+      modulus: this._modulus,
+      debugID: this.__getDebugID()
+    };
+  }
+}]);

_bundle/AnimatedMultiplication.js

@@ -0,0 +1,107 @@
+// Metro module 370 (f371).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import AnimatedValue from "./AnimatedValue";
+import mapStringToNumericComponents from "./mapStringToNumericComponents";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66319($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedMultiplication;
+let env388 = {};
+env388[6] = function _isNativeReflectConstruct() {
+  let c12284_0;
+  try {
+    c12284_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12284_0;
+  };
+  env388[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedMultiplication = function AnimatedMultiplication(a0, a1, a2) {
+  _classCallCheck(this, AnimatedMultiplication);
+  const r9 = [a2];
+  const r8 = _getPrototypeOf(AnimatedMultiplication);
+  const r26 = _possibleConstructorReturn(this, (0, env388[6])() ? Reflect.construct(r8, r9, _getPrototypeOf(this).constructor) : r8.apply(this, r9));
+  r26._a = typeof a0 === "number" ? new AnimatedValue(a0) : a0;
+  r26._b = typeof a1 === "number" ? new AnimatedValue(a1) : a1;
+  return r26;
+};
+_inherits(AnimatedMultiplication, AnimatedWithChildren);
+export default _createClass(AnimatedMultiplication, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23715;
+    this._a.__makeNative(a0);
+    this._b.__makeNative(a0);
+    const r13 = env23715 = {};
+    env23715[0] = this;
+    env23715[1] = void 0;
+    let r18 = _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__makeNative", this);
+    env23715[1] = r18;
+    if (typeof r18 === "function") {
+      r18 = $mk66319(r13);
+    }
+    r18([a0]);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    return this._a.__getValue() * this._b.__getValue();
+  }
+}, {
+  key: "interpolate",
+  value: function interpolate(a0) {
+    return new mapStringToNumericComponents(this, a0);
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    let env23716;
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+    const r12 = env23716 = {};
+    env23716[0] = this;
+    env23716[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__attach", this);
+    env23716[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66319(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23717;
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    const r12 = env23717 = {};
+    env23717[0] = this;
+    env23717[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__detach", this);
+    env23717[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66319(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    return {
+      type: "multiplication",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+      debugID: this.__getDebugID()
+    };
+  }
+}]);

_bundle/AnimatedNode.js

@@ -0,0 +1,147 @@
+// Metro module 367 (f368).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import Module357 from "./Module357";
+import Module38 from "./Module38";
+let AnimatedNode;
+let env382 = {};
+env382[3] = 1;
+env382[4] = () => {
+  Module357.assertNativeAnimatedModule();
+  env382[4] = null;
+};
+AnimatedNode = function AnimatedNode(a0) {
+  _classCallCheck(this, AnimatedNode);
+  this._platformConfig = void 0;
+  this.__isNative = false;
+  this.__nativeTag = void 0;
+  this.__disableBatchingForNativeCreate = void 0;
+  this.__debugID = void 0;
+  this._listeners = new Map();
+  this.__disableBatchingForNativeCreate = a0?.unstable_disableBatchingForNativeCreate;
+};
+export default _createClass(AnimatedNode, [{
+  key: "__attach",
+  value: function __attach() {}
+}, {
+  key: "__detach",
+  value: function __detach() {
+    this.removeAllListeners();
+    if (this.__isNative && this.__nativeTag != null) {
+      Module357.API.dropAnimatedNode(this.__nativeTag);
+      this.__nativeTag = void 0;
+    }
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {}
+}, {
+  key: "__getAnimatedValue",
+  value: function __getAnimatedValue() {
+    return this.__getValue();
+  }
+}, {
+  key: "__addChild",
+  value: function __addChild(a0) {}
+}, {
+  key: "__removeChild",
+  value: function __removeChild(a0) {}
+}, {
+  key: "__getChildren",
+  value: function __getChildren() {
+    return [];
+  }
+}, {
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    Module38(this.__isNative, "This node cannot be made a \"native\" animated node");
+    this._platformConfig = a0;
+  }
+}, {
+  key: "addListener",
+  value: function addListener(a0) {
+    const r2 = String;
+    const r6 = +env382[3];
+    env382[3] = r6 + 1;
+    const r7 = r2(r6);
+    this._listeners.set(r7, a0);
+    return r7;
+  }
+}, {
+  key: "removeListener",
+  value: function removeListener(a0) {
+    this._listeners.delete(a0);
+  }
+}, {
+  key: "removeAllListeners",
+  value: function removeAllListeners() {
+    this._listeners.clear();
+  }
+}, {
+  key: "hasListeners",
+  value: function hasListeners() {
+    return this._listeners.size > 0;
+  }
+}, {
+  key: "__onAnimatedValueUpdateReceived",
+  value: function __onAnimatedValueUpdateReceived(a0, a1) {
+    this.__callListeners(a0 + a1);
+  }
+}, {
+  key: "__callListeners",
+  value: function __callListeners(a0) {
+    let c23708_0 = {
+      value: a0
+    };
+    this._listeners.forEach((_listener) => {
+      _listener(c23708_0);
+    });
+  }
+}, {
+  key: "__getNativeTag",
+  value: function __getNativeTag() {
+    let __nativeTag = this.__nativeTag;
+    if (__nativeTag == null) {
+      if (env382[4] != null) {
+        Module357.assertNativeAnimatedModule();
+        env382[4] = null;
+      }
+      Module38(this.__isNative, "Attempt to get native tag from node not marked as \"native\"");
+      const __nativeTag2 = Module357.generateNewNodeTag();
+      this.__nativeTag = __nativeTag2;
+      const r28 = this.__getNativeConfig();
+      if (this._platformConfig) {
+        r28.platformConfig = this._platformConfig;
+      }
+      if (this.__disableBatchingForNativeCreate) {
+        r28.disableBatchingForNativeCreate = true;
+      }
+      Module357.API.createAnimatedNode(__nativeTag2, r28);
+      __nativeTag = __nativeTag2;
+    }
+    return __nativeTag;
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    throw new Error("This JS animated node type cannot be used as native animated node");
+  }
+}, {
+  key: "__getPlatformConfig",
+  value: function __getPlatformConfig() {
+    return this._platformConfig;
+  }
+}, {
+  key: "__setPlatformConfig",
+  value: function __setPlatformConfig(a0) {
+    this._platformConfig = a0;
+  }
+}, {
+  key: "toJSON",
+  value: function toJSON() {
+    return this.__getValue();
+  }
+}, {
+  key: "__getDebugID",
+  value: function __getDebugID() {}
+}]);

_bundle/AnimatedProps.js

@@ -0,0 +1,370 @@
+// Metro module 380 (f381).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import _classPrivateFieldBase from "./_classPrivateFieldBase";
+import _classPrivateFieldKey from "./_classPrivateFieldKey";
+import flattenStyle from "./flattenStyle";
+import AnimatedStyle from "./AnimatedStyle";
+import AnimatedNode from "./AnimatedNode";
+import flatAnimatedNodes from "./flatAnimatedNodes";
+import { AnimatedEvent } from "./AnimatedEvent";
+import Module357 from "./Module357";
+import Module38 from "./Module38";
+import { findNodeHandle } from "./Module114";
+import { cxxNativeAnimatedEnabled, useSharedAnimatedBackend } from "./Module27";
+import { getNodeFromPublicInstance } from "./Module272";
+function $mk66412($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let _connectAnimatedView2, _connectShadowNode2, _disconnectAnimatedView2, c404_11, c404_12, c404_13, hasOwnProperty, hasOwn;
+let AnimatedProps;
+let env404 = {};
+env404[10] = function _isNativeReflectConstruct() {
+  let c12291_0;
+  try {
+    c12291_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12291_0;
+  };
+  env404[10] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+_connectAnimatedView2 = function _connectAnimatedView2(a0) {
+  Module38(this.__isNative, "Expected node to be marked as \"native\"");
+  const connectedViewTag = findNodeHandle(a0.instance);
+  if (connectedViewTag == null) {
+    throw new Error("Unable to locate attached view in the native tree");
+  }
+  Module357.API.connectAnimatedNodeToView(this.__getNativeTag(), connectedViewTag);
+  a0.connectedViewTag = connectedViewTag;
+};
+_connectShadowNode2 = function _connectShadowNode2(a0) {
+  if (cxxNativeAnimatedEnabled() && useSharedAnimatedBackend()) {
+    Module38(this.__isNative, "Expected node to be marked as \"native\"");
+    const nodeFromPublicInstance = getNodeFromPublicInstance(a0.instance);
+    if (nodeFromPublicInstance != null) {
+      Module357.API.connectAnimatedNodeToShadowNodeFamily(this.__getNativeTag(), nodeFromPublicInstance);
+    }
+  }
+};
+_disconnectAnimatedView2 = function _disconnectAnimatedView2(a0) {
+  Module38(this.__isNative, "Expected node to be marked as \"native\"");
+  const connectedViewTag = a0.connectedViewTag;
+  if (connectedViewTag != null) {
+    Module357.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), connectedViewTag);
+    a0.connectedViewTag = null;
+  }
+};
+c404_11 = _classPrivateFieldKey("connectAnimatedView");
+c404_12 = _classPrivateFieldKey("connectShadowNode");
+c404_13 = _classPrivateFieldKey("disconnectAnimatedView");
+AnimatedProps = function AnimatedProps(a0, a1, a2, a3, a4) {
+  let r68, r72;
+  _classCallCheck(this, AnimatedProps);
+  const r14 = [a4];
+  const r13 = _getPrototypeOf(AnimatedProps);
+  const r36 = _possibleConstructorReturn(this, (0, env404[10])() ? Reflect.construct(r13, r14, _getPrototypeOf(this).constructor) : r13.apply(this, r14));
+  Object.defineProperty(r36, c404_13, {
+    value: _disconnectAnimatedView2
+  });
+  Object.defineProperty(r36, c404_12, {
+    value: _connectShadowNode2
+  });
+  Object.defineProperty(r36, c404_11, {
+    value: _connectAnimatedView2
+  });
+  r36._target = null;
+  r36._rootTag = void 0;
+  const r56 = [];
+  const r57 = [];
+  const r58 = {};
+  const r61 = Object.keys(a0);
+  const length = r61.length;
+  let r0 = 0;
+  while (r0 < length) {
+    const r17 = r61[r0];
+    const r23 = a0[r17];
+    const r1 = r0;
+    if (a2 != null && !hasOwn(a2, r17)) {
+      r58[r17] = r23;
+    } else {
+      if (r17 === "style") {
+        r68 = void 0;
+        r72 = r23;
+        if (typeof r23 === "object") {
+          const r73 = r23 != null;
+          r68 = void 0;
+          r72 = r23;
+          if (r73) {
+            const r76 = flattenStyle(r23);
+            r68 = AnimatedStyle.from(r76, a2?.style, r23);
+            r72 = r76;
+          }
+        }
+      } else {
+        r68 = r23 instanceof AnimatedNode ? r23 : flatAnimatedNodes.from(r23);
+        r72 = r23;
+      }
+      if (r68 == null) {
+        r58[r17] = r72;
+      } else {
+        r56.push(r17);
+        r57.push(r68);
+        r58[r17] = r68;
+      }
+    }
+    r0 = r1 + 1;
+  }
+  const [_nodeKeys, _nodes, _props] = [r56, r57, r58];
+  r36._nodeKeys = _nodeKeys;
+  r36._nodes = _nodes;
+  r36._props = _props;
+  r36._callback = a1;
+  r36._rootTag = a3;
+  return r36;
+};
+_inherits(AnimatedProps, AnimatedNode);
+const r70 = _createClass(AnimatedProps, [{
+  key: "__getValue",
+  value: function __getValue() {
+    const r5 = {};
+    const r16 = Object.keys(this._props);
+    const length = r16.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r11 = r16[r0];
+      const r12 = this._props[r11];
+      const r21 = r12 instanceof AnimatedNode;
+      const r1 = r0;
+      if (r21) {
+        r5[r11] = r12.__getValue();
+      } else if (r12 instanceof AnimatedEvent) {
+        r5[r11] = r12.__getHandler();
+      } else {
+        r5[r11] = r12;
+      }
+      r0 = r1 + 1;
+    }
+    return r5;
+  }
+}, {
+  key: "__getValueWithStaticProps",
+  value: function __getValueWithStaticProps(a0) {
+    let r45;
+    const r6 = {
+      ...a0
+    };
+    const r9 = Object.keys(a0);
+    const length = r9.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r14 = r9[r0];
+      const r16 = this._props[r14];
+      const r1 = r0;
+      if (r14 === "style") {
+        const style = a0.style;
+        const r41 = flattenStyle(style);
+        if (r16 instanceof AnimatedStyle) {
+          if (r41 == null) {
+            r45 = {};
+          } else {
+            r45 = r41;
+            if (r45 === style) {
+              r45 = {
+                ...r41
+              };
+            }
+          }
+          r16.__replaceAnimatedNodeWithValues(r45);
+          r6[r14] = r16.__getValueForStyle(r45);
+        } else {
+          r6[r14] = r41;
+        }
+      } else if (r16 instanceof AnimatedNode) {
+        r6[r14] = r16.__getValue();
+      } else if (r16 instanceof AnimatedEvent) {
+        r6[r14] = r16.__getHandler();
+      }
+      r0 = r1 + 1;
+    }
+    return r6;
+  }
+}, {
+  key: "__getNativeAnimatedEventTuples",
+  value: function __getNativeAnimatedEventTuples() {
+    const r5 = [];
+    const r15 = Object.keys(this._props);
+    const length = r15.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r13 = r15[r0];
+      const r12 = this._props[r13];
+      let r22 = r12 instanceof AnimatedEvent;
+      const r1 = r0;
+      if (r22) {
+        r22 = r12.__isNative;
+      }
+      if (r22) {
+        r5.push([r13, r12]);
+      }
+      r0 = r1 + 1;
+    }
+    return r5;
+  }
+}, {
+  key: "__getAnimatedValue",
+  value: function __getAnimatedValue() {
+    const r4 = {};
+    const _nodeKeys = this._nodeKeys;
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      r4[_nodeKeys[r0]] = _nodes[r0].__getAnimatedValue();
+      r0 = r0 + 1;
+    }
+    return r4;
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__addChild(this);
+      r0 = r0 + 1;
+    }
+    let env23740;
+    const r13 = env23740 = {};
+    env23740[0] = this;
+    let r20 = _get(_getPrototypeOf(AnimatedProps.prototype), "__attach", this);
+    env23740[1] = r20;
+    if (typeof r20 === "function") {
+      r20 = $mk66412(r13);
+    }
+    r20([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    if (this.__isNative && this._target != null) {
+      _classPrivateFieldBase(this, c404_13)[c404_13](this._target);
+    }
+    this._target = null;
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__removeChild(this);
+      r0 = r0 + 1;
+    }
+    let env23741;
+    const r25 = env23741 = {};
+    env23741[0] = this;
+    let r32 = _get(_getPrototypeOf(AnimatedProps.prototype), "__detach", this);
+    env23741[1] = r32;
+    if (typeof r32 === "function") {
+      r32 = $mk66412(r25);
+    }
+    r32([]);
+  }
+}, {
+  key: "update",
+  value: function update() {
+    this._callback();
+  }
+}, {
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__makeNative(a0);
+      r0 = r0 + 1;
+    }
+    if (!this.__isNative) {
+      let env23742;
+      this.__isNative = true;
+      const r18 = env23742 = {};
+      env23742[0] = this;
+      env23742[1] = void 0;
+      let r24 = _get(_getPrototypeOf(AnimatedProps.prototype), "__setPlatformConfig", this);
+      env23742[1] = r24;
+      if (typeof r24 === "function") {
+        r24 = $mk66412(r18);
+      }
+      r24([a0]);
+      if (this._target != null) {
+        const _target = this._target;
+        _classPrivateFieldBase(this, c404_11)[c404_11](_target);
+        _classPrivateFieldBase(this, c404_12)[c404_12](_target);
+      }
+    }
+  }
+}, {
+  key: "setNativeView",
+  value: function setNativeView(a0) {
+    if (this._target?.instance !== a0) {
+      const _target = {
+        instance: a0,
+        connectedViewTag: null
+      };
+      this._target = _target;
+      if (this.__isNative) {
+        _classPrivateFieldBase(this, c404_11)[c404_11](_target);
+        _classPrivateFieldBase(this, c404_12)[c404_12](_target);
+      }
+    }
+  }
+}, {
+  key: "__restoreDefaultValues",
+  value: function __restoreDefaultValues() {
+    if (this.__isNative) {
+      Module357.API.restoreDefaultValues(this.__getNativeTag());
+    }
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    const r9 = this.__getPlatformConfig();
+    const props = {};
+    const _nodeKeys = this._nodeKeys;
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r11 = _nodeKeys[r0];
+      const r12 = _nodes[r0];
+      r12.__makeNative(r9);
+      props[r11] = r12.__getNativeTag();
+      r0 = r0 + 1;
+    }
+    let _rootTag = this._rootTag;
+    if (_rootTag == null) {
+      _rootTag = void 0;
+    }
+    return {
+      type: "props",
+      props,
+      rootTag: _rootTag,
+      debugID: this.__getDebugID()
+    };
+  }
+}]);
+hasOwnProperty = Object.prototype.hasOwnProperty;
+let hasOwn2 = Object.hasOwn;
+if (hasOwn2 == null) {
+  hasOwn2 = (a0, a1) => hasOwnProperty.call(a0, a1);
+}
+hasOwn = hasOwn2;
+export default r70;

_bundle/AnimatedScrollViewWithOrWithoutInvertedRefreshControl.jsx

@@ -0,0 +1,42 @@
+// Metro module 402 (f403).
+import _slicedToArray from "./_slicedToArray";
+import { cloneElement, useMemo } from "react";
+import splitLayoutProps from "./splitLayoutProps";
+import flattenStyle from "./flattenStyle";
+import Module404 from "./Module404";
+import useMergeRefs from "./useMergeRefs";
+import Wrapper from "./Wrapper_349";
+import Module254 from "./Module254";
+import createAnimatedComponent from "./createAnimatedComponent";
+let Component;
+const AnimatedScrollViewWithInvertedRefreshControl = function AnimatedScrollViewWithInvertedRefreshControl(props) {
+  const { ref, ...rest } = props;
+  let c12314_0 = rest;
+  const memo = useMemo(() => {
+    const r15 = splitLayoutProps(flattenStyle(c12314_0.style));
+    return {
+      intermediatePropsForRefreshControl: {
+        style: r15.outer
+      },
+      intermediatePropsForScrollView: {
+        ...c12314_0,
+        style: r15.inner
+      }
+    };
+  }, [rest]);
+  const { intermediatePropsForRefreshControl, intermediatePropsForScrollView } = memo;
+  const r9 = _slicedToArray(Module404(intermediatePropsForRefreshControl), 2);
+  const r27 = r9[0];
+  const refreshControl = cloneElement(rest.refreshControl, {
+    ...r27,
+    ref: r9[1]
+  });
+  const r36 = _slicedToArray(Module404(intermediatePropsForScrollView), 2);
+  const props2 = r36[0];
+  return <Wrapper {...props2} ref={useMergeRefs(r36[1], ref)} refreshControl={refreshControl} style={Module254.compose(props2.style, r27.style)} />;
+};
+Component = createAnimatedComponent(Wrapper);
+export default function AnimatedScrollViewWithOrWithoutInvertedRefreshControl(props) {
+  const { ref, ...props2 } = props;
+  return props2.refreshControl != null && props2.style != null ? <AnimatedScrollViewWithInvertedRefreshControl scrollEventThrottle={0.0001} {...props2} ref={ref} refreshControl={props2.refreshControl} /> : <Component scrollEventThrottle={0.0001} {...props2} ref={ref} />;
+};

_bundle/AnimatedStyle.js

@@ -0,0 +1,244 @@
+// Metro module 381 (f382).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import { shouldUseAnimatedObjectForTransform } from "./Module27";
+import flatAnimatedNodes from "./flatAnimatedNodes";
+import AnimatedTransform from "./AnimatedTransform";
+import AnimatedNode from "./AnimatedNode";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66427($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let hasOwnProperty, hasOwn;
+let AnimatedStyle;
+let env406 = {};
+env406[8] = function _isNativeReflectConstruct() {
+  let c12292_0;
+  try {
+    c12292_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12292_0;
+  };
+  env406[8] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedStyle = function AnimatedStyle(a0, a1, a2, a3, a4) {
+  _classCallCheck(this, AnimatedStyle);
+  const r8 = [a4];
+  const r7 = _getPrototypeOf(AnimatedStyle);
+  const r24 = _possibleConstructorReturn(this, (0, env406[8])() ? Reflect.construct(r7, r8, _getPrototypeOf(this).constructor) : r7.apply(this, r8));
+  r24._nodeKeys = a0;
+  r24._nodes = a1;
+  r24._style = a2;
+  return r24;
+};
+_inherits(AnimatedStyle, AnimatedWithChildren);
+const r53 = _createClass(AnimatedStyle, [{
+  key: "__getValue",
+  value: function __getValue() {
+    const r6 = {};
+    const r15 = Object.keys(this._style);
+    const length = r15.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r11 = r15[r0];
+      const r12 = this._style[r11];
+      const r21 = r12 instanceof AnimatedNode;
+      const r1 = r0;
+      if (r21) {
+        r6[r11] = r12.__getValue();
+      } else {
+        r6[r11] = r12;
+      }
+      r0 = r1 + 1;
+    }
+    return this.__getValueForStyle(r6);
+  }
+}, {
+  key: "__getValueForStyle",
+  value: function __getValueForStyle(a0) {
+    return a0;
+  }
+}, {
+  key: "__replaceAnimatedNodeWithValues",
+  value: function __replaceAnimatedNodeWithValues(a0) {
+    const r7 = Object.keys(a0);
+    const length = r7.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r13 = r7[r0];
+      const r15 = this._style[r13];
+      const r1 = r0;
+      if (r13 === "transform" && r15 instanceof AnimatedTransform) {
+        a0[r13] = r15.__getValueWithStaticTransforms(Array.isArray(a0[r13]) ? a0[r13] : []);
+      } else if (r15 instanceof flatAnimatedNodes) {
+        a0[r13] = r15.__getValueWithStaticObject(a0[r13]);
+      } else if (r15 instanceof AnimatedNode) {
+        a0[r13] = r15.__getValue();
+      }
+      r0 = r1 + 1;
+    }
+  }
+}, {
+  key: "__getAnimatedValue",
+  value: function __getAnimatedValue() {
+    const r4 = {};
+    const _nodeKeys = this._nodeKeys;
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      r4[_nodeKeys[r0]] = _nodes[r0].__getAnimatedValue();
+      r0 = r0 + 1;
+    }
+    return r4;
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__addChild(this);
+      r0 = r0 + 1;
+    }
+    let env23743;
+    const r13 = env23743 = {};
+    env23743[0] = this;
+    let r20 = _get(_getPrototypeOf(AnimatedStyle.prototype), "__attach", this);
+    env23743[1] = r20;
+    if (typeof r20 === "function") {
+      r20 = $mk66427(r13);
+    }
+    r20([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__removeChild(this);
+      r0 = r0 + 1;
+    }
+    let env23744;
+    const r13 = env23744 = {};
+    env23744[0] = this;
+    let r20 = _get(_getPrototypeOf(AnimatedStyle.prototype), "__detach", this);
+    env23744[1] = r20;
+    if (typeof r20 === "function") {
+      r20 = $mk66427(r13);
+    }
+    r20([]);
+  }
+}, {
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__makeNative(a0);
+      r0 = r0 + 1;
+    }
+    let env23745;
+    const r14 = env23745 = {};
+    env23745[0] = this;
+    let r21 = _get(_getPrototypeOf(AnimatedStyle.prototype), "__makeNative", this);
+    env23745[1] = r21;
+    if (typeof r21 === "function") {
+      r21 = $mk66427(r14);
+    }
+    r21([a0]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    const r9 = this.__getPlatformConfig();
+    const style = {};
+    const _nodeKeys = this._nodeKeys;
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r11 = _nodeKeys[r0];
+      const r12 = _nodes[r0];
+      r12.__makeNative(r9);
+      style[r11] = r12.__getNativeTag();
+      r0 = r0 + 1;
+    }
+    return {
+      type: "style",
+      style,
+      debugID: this.__getDebugID()
+    };
+  }
+}], [{
+  key: "from",
+  value: function from(a0, a1, a2) {
+    if (a0 == null) {
+      return null;
+    }
+    const r11 = [];
+    const r10 = [];
+    const r7 = {};
+    const r13 = Object.keys(a0);
+    const length = r13.length;
+    const r5 = 0 < length;
+    let r0 = 0;
+    if (r5) {
+      do {
+        const r18 = r13[r0];
+        const r17 = a0[r18];
+        const r1 = r0;
+        if (a1 != null && !hasOwn(a1, r18)) {
+          r7[r18] = r17;
+        } else {
+          const r31 = r17 != null && r18 === "transform" ? shouldUseAnimatedObjectForTransform() ? flatAnimatedNodes.from(r17) : AnimatedTransform.from(r17) : r17 instanceof AnimatedNode ? r17 : flatAnimatedNodes.from(r17);
+          if (r31 == null) {
+            r7[r18] = r17;
+          } else {
+            r11.push(r18);
+            r10.push(r31);
+            r7[r18] = r31;
+          }
+        }
+        r0 = r1 + 1;
+      } while (r0 < length);
+    }
+    const [_nodeKeys, _nodes, _style] = [r11, r10, r7];
+    const length2 = _nodes.length;
+    let r61 = null;
+    if (length2 !== 0) {
+      const r65 = {
+        __proto__: AnimatedStyle.prototype
+      };
+      _classCallCheck(r65, AnimatedStyle);
+      const r68 = [void 0];
+      const r70 = _getPrototypeOf(AnimatedStyle);
+      const r80 = _possibleConstructorReturn(r65, (0, env406[8])() ? Reflect.construct(r70, r68, _getPrototypeOf(r65).constructor) : r70.apply(r65, r68));
+      r80._nodeKeys = _nodeKeys;
+      r80._nodes = _nodes;
+      r80._style = _style;
+      r61 = r80 instanceof Object ? r80 : r65;
+    }
+    return r61;
+  }
+}]);
+hasOwnProperty = Object.prototype.hasOwnProperty;
+let hasOwn2 = Object.hasOwn;
+if (hasOwn2 == null) {
+  hasOwn2 = (a0, a1) => hasOwnProperty.call(a0, a1);
+}
+hasOwn = hasOwn2;
+export default r53;

_bundle/AnimatedSubtraction.js

@@ -0,0 +1,107 @@
+// Metro module 368 (f369).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import AnimatedValue from "./AnimatedValue";
+import mapStringToNumericComponents from "./mapStringToNumericComponents";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66299($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedSubtraction;
+let env384 = {};
+env384[6] = function _isNativeReflectConstruct() {
+  let c12282_0;
+  try {
+    c12282_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12282_0;
+  };
+  env384[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedSubtraction = function AnimatedSubtraction(a0, a1, a2) {
+  _classCallCheck(this, AnimatedSubtraction);
+  const r9 = [a2];
+  const r8 = _getPrototypeOf(AnimatedSubtraction);
+  const r26 = _possibleConstructorReturn(this, (0, env384[6])() ? Reflect.construct(r8, r9, _getPrototypeOf(this).constructor) : r8.apply(this, r9));
+  r26._a = typeof a0 === "number" ? new AnimatedValue(a0) : a0;
+  r26._b = typeof a1 === "number" ? new AnimatedValue(a1) : a1;
+  return r26;
+};
+_inherits(AnimatedSubtraction, AnimatedWithChildren);
+export default _createClass(AnimatedSubtraction, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23709;
+    this._a.__makeNative(a0);
+    this._b.__makeNative(a0);
+    const r13 = env23709 = {};
+    env23709[0] = this;
+    env23709[1] = void 0;
+    let r18 = _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__makeNative", this);
+    env23709[1] = r18;
+    if (typeof r18 === "function") {
+      r18 = $mk66299(r13);
+    }
+    r18([a0]);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    return this._a.__getValue() - this._b.__getValue();
+  }
+}, {
+  key: "interpolate",
+  value: function interpolate(a0) {
+    return new mapStringToNumericComponents(this, a0);
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    let env23710;
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+    const r12 = env23710 = {};
+    env23710[0] = this;
+    env23710[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__attach", this);
+    env23710[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66299(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23711;
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    const r12 = env23711 = {};
+    env23711[0] = this;
+    env23711[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__detach", this);
+    env23711[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66299(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    return {
+      type: "subtraction",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+      debugID: this.__getDebugID()
+    };
+  }
+}]);

_bundle/AnimatedTracking.js

@@ -0,0 +1,122 @@
+// Metro module 375 (f376).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import Module357 from "./Module357";
+import AnimatedNode from "./AnimatedNode";
+function $mk66385($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedTracking;
+let env398 = {};
+env398[6] = function _isNativeReflectConstruct() {
+  let c12289_0;
+  try {
+    c12289_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12289_0;
+  };
+  env398[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedTracking = function AnimatedTracking(a0, a1, a2, a3, a4, a5) {
+  _classCallCheck(this, AnimatedTracking);
+  const r7 = [a5];
+  const r6 = _getPrototypeOf(AnimatedTracking);
+  const r26 = _possibleConstructorReturn(this, (0, env398[6])() ? Reflect.construct(r6, r7, _getPrototypeOf(this).constructor) : r6.apply(this, r7));
+  r26._value = a0;
+  r26._parent = a1;
+  r26._animationClass = a2;
+  r26._animationConfig = a3;
+  r26._useNativeDriver = Module357.shouldUseNativeDriver(a3);
+  r26._callback = a4;
+  r26.__attach();
+  return r26;
+};
+_inherits(AnimatedTracking, AnimatedNode);
+export default _createClass(AnimatedTracking, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23733;
+    this.__isNative = true;
+    this._parent.__makeNative(a0);
+    const r10 = env23733 = {};
+    env23733[0] = this;
+    env23733[1] = void 0;
+    let r16 = _get(_getPrototypeOf(AnimatedTracking.prototype), "__makeNative", this);
+    env23733[1] = r16;
+    if (typeof r16 === "function") {
+      r16 = $mk66385(r10);
+    }
+    r16([a0]);
+    this._value.__makeNative(a0);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    return this._parent.__getValue();
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    this._parent.__addChild(this);
+    if (this._useNativeDriver) {
+      this.__makeNative(this._animationConfig.platformConfig);
+    }
+    let env23734;
+    const r14 = env23734 = {};
+    env23734[0] = this;
+    let r19 = _get(_getPrototypeOf(AnimatedTracking.prototype), "__attach", this);
+    env23734[1] = r19;
+    if (typeof r19 === "function") {
+      r19 = $mk66385(r14);
+    }
+    r19([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23735;
+    this._parent.__removeChild(this);
+    const r9 = env23735 = {};
+    env23735[0] = this;
+    env23735[1] = void 0;
+    let r14 = _get(_getPrototypeOf(AnimatedTracking.prototype), "__detach", this);
+    env23735[1] = r14;
+    if (typeof r14 === "function") {
+      r14 = $mk66385(r9);
+    }
+    r14([]);
+  }
+}, {
+  key: "update",
+  value: function update() {
+    this._value.animate(new this._animationClass({
+      ...this._animationConfig,
+      toValue: this._animationConfig.toValue.__getValue()
+    }), this._callback);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    const animationConfig = new this._animationClass({
+      ...this._animationConfig,
+      toValue: void 0
+    }).__getNativeAnimationConfig();
+    return {
+      type: "tracking",
+      animationId: Module357.generateNewAnimationId(),
+      animationConfig,
+      toValue: this._parent.__getNativeTag(),
+      value: this._value.__getNativeTag(),
+      debugID: this.__getDebugID()
+    };
+  }
+}]);

_bundle/AnimatedTransform.js

@@ -0,0 +1,245 @@
+// Metro module 383 (f384).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import AnimatedNode from "./AnimatedNode";
+import Module357 from "./Module357";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66453($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+function $mk66454($env) {
+  return (a0) => {
+    const r13 = $env;
+    const r6 = {};
+    const r7 = $env.$parent;
+    for (const key in a0) {
+      const r16 = a0[key];
+      if (r16 instanceof (0, r7[0])(r7[1][6])) {
+        r6[key] = (0, r13[0])(r16);
+      } else if (Array.isArray(r16)) {
+        r6[key] = r16.map($mk101217(r13));
+      } else if (typeof r16 === "object") {
+        const r29 = {};
+        for (const key2 in r16) {
+          const r23 = r16[key2];
+          r29[key2] = r23 instanceof (0, r7[0])(r7[1][6]) ? (0, r13[0])(r23) : r23;
+        }
+        r6[key] = r29;
+      } else {
+        r6[key] = r16;
+      }
+    }
+    return r6;
+  };
+}
+function $mk101217($env) {
+  return (a0) => {
+    const r2 = $env.$parent;
+    return a0 instanceof (0, r2[0])(r2[1][6]) ? (0, $env[0])(a0) : a0;
+  };
+}
+let AnimatedTransform;
+let env410 = {};
+env410[6] = function _isNativeReflectConstruct() {
+  let c12295_0;
+  try {
+    c12295_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12295_0;
+  };
+  env410[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedTransform = function AnimatedTransform(a0, a1, a2) {
+  _classCallCheck(this, AnimatedTransform);
+  const r8 = [a2];
+  const r7 = _getPrototypeOf(AnimatedTransform);
+  const r23 = _possibleConstructorReturn(this, (0, env410[6])() ? Reflect.construct(r7, r8, _getPrototypeOf(this).constructor) : r7.apply(this, r8));
+  r23._nodes = a0;
+  r23._transforms = a1;
+  return r23;
+};
+_inherits(AnimatedTransform, AnimatedWithChildren);
+export default _createClass(AnimatedTransform, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__makeNative(a0);
+      r0 = r0 + 1;
+    }
+    let env23750;
+    const r14 = env23750 = {};
+    env23750[0] = this;
+    let r21 = _get(_getPrototypeOf(AnimatedTransform.prototype), "__makeNative", this);
+    env23750[1] = r21;
+    if (typeof r21 === "function") {
+      r21 = $mk66453(r14);
+    }
+    r21([a0]);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    let env23751;
+    const _transforms = this._transforms;
+    const r4 = env23751 = {
+      $parent: env410
+    };
+    env23751[0] = (a0) => a0.__getValue();
+    return _transforms.map($mk66454(r4));
+  }
+}, {
+  key: "__getValueWithStaticTransforms",
+  value: function __getValueWithStaticTransforms(a0) {
+    let env23753;
+    let env23754;
+    let c23752_0 = [];
+    const _transforms = this._transforms;
+    const r6 = env23753 = {
+      $parent: env410
+    };
+    env23753[0] = (a0) => {
+      c23752_0.push(a0.__getValue());
+    };
+    _transforms.map($mk66454(r6));
+    const r10 = env23754 = {
+      $parent: env410
+    };
+    env23754[0] = () => c23752_0.shift();
+    return a0.map($mk66454(r10));
+  }
+}, {
+  key: "__getAnimatedValue",
+  value: function __getAnimatedValue() {
+    let env23755;
+    const _transforms = this._transforms;
+    const r4 = env23755 = {
+      $parent: env410
+    };
+    env23755[0] = (a0) => a0.__getAnimatedValue();
+    return _transforms.map($mk66454(r4));
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__addChild(this);
+      r0 = r0 + 1;
+    }
+    let env23756;
+    const r13 = env23756 = {};
+    env23756[0] = this;
+    let r20 = _get(_getPrototypeOf(AnimatedTransform.prototype), "__attach", this);
+    env23756[1] = r20;
+    if (typeof r20 === "function") {
+      r20 = $mk66453(r13);
+    }
+    r20([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    const _nodes = this._nodes;
+    const length = _nodes.length;
+    let r0 = 0;
+    while (r0 < length) {
+      _nodes[r0].__removeChild(this);
+      r0 = r0 + 1;
+    }
+    let env23757;
+    const r13 = env23757 = {};
+    env23757[0] = this;
+    let r20 = _get(_getPrototypeOf(AnimatedTransform.prototype), "__detach", this);
+    env23757[1] = r20;
+    if (typeof r20 === "function") {
+      r20 = $mk66453(r13);
+    }
+    r20([]);
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    const transforms = [];
+    const _transforms = this._transforms;
+    const length = _transforms.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r15 = _transforms[r0];
+      const r1 = r0;
+      for (const key in r15) {
+        const property = key;
+        const r19 = r15[property];
+        if (r19 instanceof AnimatedNode) {
+          transforms.push({
+            type: "animated",
+            property,
+            nodeTag: r19.__getNativeTag()
+          });
+        } else {
+          transforms.push({
+            type: "static",
+            property,
+            value: Module357.transformDataType(r19)
+          });
+        }
+      }
+      r0 = r1 + 1;
+    }
+    return {
+      type: "transform",
+      transforms,
+      debugID: this.__getDebugID()
+    };
+  }
+}], [{
+  key: "from",
+  value: function from(a0) {
+    const r10 = Array.isArray(a0) ? a0 : [];
+    const _nodes = [];
+    const length = r10.length;
+    const r7 = 0 < length;
+    let r0 = 0;
+    if (r7) {
+      do {
+        const r17 = r10[r0];
+        const r1 = r0;
+        for (const key in r17) {
+          const r19 = r17[key];
+          if (r19 instanceof AnimatedNode) {
+            _nodes.push(r19);
+          }
+        }
+        r0 = r1 + 1;
+      } while (r0 < length);
+    }
+    const length2 = _nodes.length;
+    let r31 = null;
+    if (length2 !== 0) {
+      const r35 = {
+        __proto__: AnimatedTransform.prototype
+      };
+      _classCallCheck(r35, AnimatedTransform);
+      const r38 = [void 0];
+      const r40 = _getPrototypeOf(AnimatedTransform);
+      const r50 = _possibleConstructorReturn(r35, (0, env410[6])() ? Reflect.construct(r40, r38, _getPrototypeOf(r35).constructor) : r40.apply(r35, r38));
+      r50._nodes = _nodes;
+      r50._transforms = a0;
+      r31 = r50 instanceof Object ? r50 : r35;
+    }
+    return r31;
+  }
+}]);

_bundle/AnimatedValue.js

@@ -0,0 +1,350 @@
+// Metro module 356 (f357).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import Module357 from "./Module357";
+import mapStringToNumericComponents from "./mapStringToNumericComponents";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66225($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+function $mk66226($env) {
+  return function findAnimatedStyles(a0) {
+    const r1 = $env;
+    if (typeof a0.update === "function") {
+      r1[0].add(a0);
+    } else {
+      a0.__getChildren().forEach(r1[1]);
+    }
+  };
+}
+function $mk66227() {
+  return (a0) => a0.update();
+}
+let AnimatedValue;
+let env370 = {};
+env370[6] = function _isNativeReflectConstruct() {
+  let c12272_0;
+  try {
+    c12272_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12272_0;
+  };
+  env370[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+AnimatedValue = function AnimatedValue(a0, a1) {
+  _classCallCheck(this, AnimatedValue);
+  const r10 = [a1];
+  const r9 = _getPrototypeOf(AnimatedValue);
+  const r27 = _possibleConstructorReturn(this, (0, env370[6])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  if (typeof a0 !== "number") {
+    throw new Error("AnimatedValue: Attempting to set value to undefined");
+  }
+  r27._listenerCount = 0;
+  r27._updateSubscription = null;
+  r27._value = a0;
+  r27._startingValue = a0;
+  r27._offset = 0;
+  r27._animation = null;
+  if (a1 ? a1.useNativeDriver : a1) {
+    r27.__makeNative();
+  }
+  return r27;
+};
+_inherits(AnimatedValue, AnimatedWithChildren);
+export default _createClass(AnimatedValue, [{
+  key: "__detach",
+  value: function __detach() {
+    const _this = this;
+    if (this.__isNative) {
+      Module357.API.getValue(this.__getNativeTag(), (a0) => {
+        _this._value = a0 - _this._offset;
+      });
+    }
+    let env23690;
+    this.stopAnimation();
+    const r20 = env23690 = {};
+    env23690[0] = this;
+    env23690[1] = void 0;
+    let r27 = _get(_getPrototypeOf(AnimatedValue.prototype), "__detach", this);
+    env23690[1] = r27;
+    if (typeof r27 === "function") {
+      r27 = $mk66225(r20);
+    }
+    r27([]);
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    return this._value + this._offset;
+  }
+}, {
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23691;
+    const r7 = env23691 = {};
+    env23691[0] = this;
+    let r12 = _get(_getPrototypeOf(AnimatedValue.prototype), "__makeNative", this);
+    env23691[1] = r12;
+    if (typeof r12 === "function") {
+      r12 = $mk66225(r7);
+    }
+    r12([a0]);
+    if (this._listenerCount > 0) {
+      this.__ensureUpdateSubscriptionExists();
+    }
+  }
+}, {
+  key: "addListener",
+  value: function addListener(a0) {
+    let env23692;
+    const r6 = env23692 = {};
+    env23692[0] = this;
+    let r11 = _get(_getPrototypeOf(AnimatedValue.prototype), "addListener", this);
+    env23692[1] = r11;
+    if (typeof r11 === "function") {
+      r11 = $mk66225(r6);
+    }
+    const r14 = r11([a0]);
+    this._listenerCount = this._listenerCount + 1;
+    if (this.__isNative) {
+      this.__ensureUpdateSubscriptionExists();
+    }
+    return r14;
+  }
+}, {
+  key: "removeListener",
+  value: function removeListener(a0) {
+    let env23693;
+    const r8 = env23693 = {};
+    env23693[0] = this;
+    let r13 = _get(_getPrototypeOf(AnimatedValue.prototype), "removeListener", this);
+    env23693[1] = r13;
+    if (typeof r13 === "function") {
+      r13 = $mk66225(r8);
+    }
+    r13([a0]);
+    this._listenerCount = this._listenerCount - 1;
+    if (this.__isNative && this._listenerCount === 0) {
+      const _updateSubscription = this._updateSubscription;
+      if (_updateSubscription != null) {
+        _updateSubscription.remove();
+      }
+    }
+  }
+}, {
+  key: "removeAllListeners",
+  value: function removeAllListeners() {
+    let env23694;
+    const r8 = env23694 = {};
+    env23694[0] = this;
+    let r13 = _get(_getPrototypeOf(AnimatedValue.prototype), "removeAllListeners", this);
+    env23694[1] = r13;
+    if (typeof r13 === "function") {
+      r13 = $mk66225(r8);
+    }
+    r13([]);
+    this._listenerCount = 0;
+    if (this.__isNative) {
+      const _updateSubscription = this._updateSubscription;
+      if (_updateSubscription != null) {
+        _updateSubscription.remove();
+      }
+    }
+  }
+}, {
+  key: "__ensureUpdateSubscriptionExists",
+  value: function __ensureUpdateSubscriptionExists() {
+    let c23695_0, c23695_1;
+    if (this._updateSubscription == null) {
+      const r7 = this.__getNativeTag();
+      c23695_1 = r7;
+      Module357.API.startListeningToAnimatedNodeValue(r7);
+      c23695_0 = Module357.nativeEventEmitter.addListener("onAnimatedValueUpdate", (a0) => {
+        if (a0.tag === c23695_1) {
+          this.__onAnimatedValueUpdateReceived(a0.value, a0.offset);
+        }
+      });
+      this._updateSubscription = {
+        remove: () => {
+          if (this._updateSubscription != null) {
+            this._updateSubscription = null;
+            c23695_0.remove();
+            Module357.API.stopListeningToAnimatedNodeValue(c23695_1);
+          }
+        }
+      };
+    }
+  }
+}, {
+  key: "setValue",
+  value: function setValue(a0) {
+    if (this._animation) {
+      this._animation.stop();
+      this._animation = null;
+    }
+    this._updateValue(a0, !this.__isNative);
+    if (this.__isNative) {
+      const r19 = this.__getNativeTag().toString();
+      Module357.API.setWaitingForIdentifier(r19);
+      Module357.API.setAnimatedNodeValue(this.__getNativeTag(), a0);
+      Module357.API.unsetWaitingForIdentifier(r19);
+    }
+  }
+}, {
+  key: "setOffset",
+  value: function setOffset(a0) {
+    this._offset = a0;
+    if (this.__isNative) {
+      Module357.API.setAnimatedNodeOffset(this.__getNativeTag(), a0);
+    }
+  }
+}, {
+  key: "flattenOffset",
+  value: function flattenOffset() {
+    this._value = this._value + this._offset;
+    this._offset = 0;
+    if (this.__isNative) {
+      Module357.API.flattenAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+}, {
+  key: "extractOffset",
+  value: function extractOffset() {
+    this._offset = this._offset + this._value;
+    this._value = 0;
+    if (this.__isNative) {
+      const r14 = this.__getNativeTag().toString();
+      Module357.API.setWaitingForIdentifier(r14);
+      Module357.API.extractAnimatedNodeOffset(this.__getNativeTag());
+      Module357.API.unsetWaitingForIdentifier(r14);
+    }
+  }
+}, {
+  key: "stopAnimation",
+  value: function stopAnimation(a0) {
+    this.stopTracking();
+    if (this._animation) {
+      this._animation.stop();
+    }
+    this._animation = null;
+    if (a0) {
+      if (this.__isNative) {
+        Module357.API.getValue(this.__getNativeTag(), a0);
+      } else {
+        a0(this.__getValue());
+      }
+    }
+  }
+}, {
+  key: "resetAnimation",
+  value: function resetAnimation(a0) {
+    this.stopAnimation(a0);
+    this._value = this._startingValue;
+    if (this.__isNative) {
+      Module357.API.setAnimatedNodeValue(this.__getNativeTag(), this._startingValue);
+    }
+  }
+}, {
+  key: "__onAnimatedValueUpdateReceived",
+  value: function __onAnimatedValueUpdateReceived(a0, a1) {
+    this._updateValue(a0, false);
+    if (a1 != null) {
+      this._offset = a1;
+    }
+  }
+}, {
+  key: "interpolate",
+  value: function interpolate(a0) {
+    return new mapStringToNumericComponents(this, a0);
+  }
+}, {
+  key: "animate",
+  value: function animate(a0, c23696_0) {
+    const _animation = this._animation;
+    if (this._animation) {
+      this._animation.stop();
+    }
+    this._animation = a0;
+    a0.start(this._value, (a0) => {
+      this._updateValue(a0, true);
+    }, (a0) => {
+      this._animation = null;
+      if (c23696_0) {
+        c23696_0(a0);
+      }
+    }, _animation, this);
+  }
+}, {
+  key: "stopTracking",
+  value: function stopTracking() {
+    if (this._tracking) {
+      this._tracking.__detach();
+    }
+    this._tracking = null;
+  }
+}, {
+  key: "track",
+  value: function track(a0) {
+    this.stopTracking();
+    this._tracking = a0;
+    if (this._tracking) {
+      this._tracking.update();
+    }
+  }
+}, {
+  key: "_updateValue",
+  value: function _updateValue(a0, a1) {
+    if (a0 === void 0) {
+      throw new Error("AnimatedValue: Attempting to set value to undefined");
+    }
+    this._value = a0;
+    if (a1) {
+      let env23697;
+      const r8 = env23697 = {};
+      const set = new Set();
+      env23697[0] = set;
+      const r5 = $mk66226(r8);
+      env23697[1] = r5;
+      if (typeof this.update === "function") {
+        set.add(this);
+      } else {
+        this.__getChildren().forEach(r5);
+      }
+      set.forEach($mk66227());
+    }
+    this.__callListeners(this.__getValue());
+  }
+}, {
+  key: "__getNativeConfig",
+  value: function __getNativeConfig() {
+    return {
+      type: "value",
+      value: this._value,
+      offset: this._offset,
+      debugID: this.__getDebugID()
+    };
+  }
+}]);
+export function flushValue(a0) {
+  let env12273;
+  const r1 = env12273 = {};
+  const set = new Set();
+  env12273[0] = set;
+  const r5 = $mk66226(r1);
+  env12273[1] = r5;
+  if (typeof a0.update === "function") {
+    set.add(a0);
+  } else {
+    a0.__getChildren().forEach(r5);
+  }
+  set.forEach($mk66227());
+}

_bundle/AnimatedValueXY.js

@@ -0,0 +1,205 @@
+// Metro module 373 (f374).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import AnimatedValue from "./AnimatedValue";
+import Module38 from "./Module38";
+import AnimatedWithChildren from "./AnimatedWithChildren";
+function $mk66349($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let AnimatedValueXY;
+let env394 = {};
+env394[6] = function _isNativeReflectConstruct() {
+  let c12287_0;
+  try {
+    c12287_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12287_0;
+  };
+  env394[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+env394[7] = 1;
+AnimatedValueXY = function AnimatedValueXY(a0, a1) {
+  _classCallCheck(this, AnimatedValueXY);
+  const r12 = [a1];
+  const r11 = _getPrototypeOf(AnimatedValueXY);
+  const r23 = (0, env394[6])() ? Reflect.construct(r11, r12, _getPrototypeOf(this).constructor) : r11.apply(this, r12);
+  let r27 = a0;
+  const r28 = _possibleConstructorReturn(this, r23);
+  if (!a0) {
+    r27 = {
+      x: 0,
+      y: 0
+    };
+  }
+  if (typeof r27.x === "number" && typeof r27.y === "number") {
+    r28.x = new AnimatedValue(r27.x);
+    r28.y = new AnimatedValue(r27.y);
+  } else {
+    Module38(r27.x instanceof AnimatedValue && r27.y instanceof AnimatedValue, "AnimatedValueXY must be initialized with an object of numbers or AnimatedValues.");
+    r28.x = r27.x;
+    r28.y = r27.y;
+  }
+  r28._listeners = {};
+  if (a1 ? a1.useNativeDriver : a1) {
+    r28.__makeNative();
+  }
+  return r28;
+};
+_inherits(AnimatedValueXY, AnimatedWithChildren);
+export default _createClass(AnimatedValueXY, [{
+  key: "setValue",
+  value: function setValue(a0) {
+    this.x.setValue(a0.x);
+    this.y.setValue(a0.y);
+  }
+}, {
+  key: "setOffset",
+  value: function setOffset(a0) {
+    this.x.setOffset(a0.x);
+    this.y.setOffset(a0.y);
+  }
+}, {
+  key: "flattenOffset",
+  value: function flattenOffset() {
+    this.x.flattenOffset();
+    this.y.flattenOffset();
+  }
+}, {
+  key: "extractOffset",
+  value: function extractOffset() {
+    this.x.extractOffset();
+    this.y.extractOffset();
+  }
+}, {
+  key: "__getValue",
+  value: function __getValue() {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue()
+    };
+  }
+}, {
+  key: "resetAnimation",
+  value: function resetAnimation(a0) {
+    this.x.resetAnimation();
+    this.y.resetAnimation();
+    if (a0) {
+      a0(this.__getValue());
+    }
+  }
+}, {
+  key: "stopAnimation",
+  value: function stopAnimation(a0) {
+    this.x.stopAnimation();
+    this.y.stopAnimation();
+    if (a0) {
+      a0(this.__getValue());
+    }
+  }
+}, {
+  key: "addListener",
+  value: function addListener(c23724_0) {
+    const r3 = String;
+    const r10 = +env394[7];
+    env394[7] = r10 + 1;
+    const r11 = r3(r10);
+    const jointCallback = (a0) => {
+      a0.value;
+      c23724_0(this.__getValue());
+    };
+    this._listeners[r11] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback)
+    };
+    return r11;
+  }
+}, {
+  key: "removeListener",
+  value: function removeListener(a0) {
+    this.x.removeListener(this._listeners[a0].x);
+    this.y.removeListener(this._listeners[a0].y);
+    delete this._listeners[a0];
+  }
+}, {
+  key: "removeAllListeners",
+  value: function removeAllListeners() {
+    this.x.removeAllListeners();
+    this.y.removeAllListeners();
+    this._listeners = {};
+  }
+}, {
+  key: "getLayout",
+  value: function getLayout() {
+    return {
+      left: this.x,
+      top: this.y
+    };
+  }
+}, {
+  key: "getTranslateTransform",
+  value: function getTranslateTransform() {
+    return [{
+      translateX: this.x
+    }, {
+      translateY: this.y
+    }];
+  }
+}, {
+  key: "__attach",
+  value: function __attach() {
+    let env23725;
+    this.x.__addChild(this);
+    this.y.__addChild(this);
+    const r12 = env23725 = {};
+    env23725[0] = this;
+    env23725[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedValueXY.prototype), "__attach", this);
+    env23725[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66349(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__detach",
+  value: function __detach() {
+    let env23726;
+    this.x.__removeChild(this);
+    this.y.__removeChild(this);
+    const r12 = env23726 = {};
+    env23726[0] = this;
+    env23726[1] = void 0;
+    let r17 = _get(_getPrototypeOf(AnimatedValueXY.prototype), "__detach", this);
+    env23726[1] = r17;
+    if (typeof r17 === "function") {
+      r17 = $mk66349(r12);
+    }
+    r17([]);
+  }
+}, {
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    let env23727;
+    this.x.__makeNative(a0);
+    this.y.__makeNative(a0);
+    const r13 = env23727 = {};
+    env23727[0] = this;
+    env23727[1] = void 0;
+    let r18 = _get(_getPrototypeOf(AnimatedValueXY.prototype), "__makeNative", this);
+    env23727[1] = r18;
+    if (typeof r18 === "function") {
+      r18 = $mk66349(r13);
+    }
+    r18([a0]);
+  }
+}]);

_bundle/AnimatedWithChildren.js

@@ -0,0 +1,131 @@
+// Metro module 366 (f367).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _get from "./_get";
+import _inherits from "./_inherits";
+import Module357 from "./Module357";
+import AnimatedNode from "./AnimatedNode";
+function $mk66269($env) {
+  return function(a0) {
+    const r0 = $env;
+    return r0[1].apply(r0[0], a0);
+  };
+}
+let connectAnimatedNodes, disconnectAnimatedNodes;
+let AnimatedWithChildren;
+let env380 = {};
+env380[4] = function _isNativeReflectConstruct() {
+  let c12281_0;
+  try {
+    c12281_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12281_0;
+  };
+  env380[4] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+connectAnimatedNodes = Module357.API.connectAnimatedNodes;
+disconnectAnimatedNodes = Module357.API.disconnectAnimatedNodes;
+AnimatedWithChildren = function AnimatedWithChildren(...args) {
+  _classCallCheck(this, AnimatedWithChildren);
+  const r9 = [...args];
+  const r8 = _getPrototypeOf(AnimatedWithChildren);
+  const r26 = _possibleConstructorReturn(this, (0, env380[4])() ? Reflect.construct(r8, r9, _getPrototypeOf(this).constructor) : r8.apply(this, r9));
+  r26._children = [];
+  return r26;
+};
+_inherits(AnimatedWithChildren, AnimatedNode);
+export default _createClass(AnimatedWithChildren, [{
+  key: "__makeNative",
+  value: function __makeNative(a0) {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      const _children = this._children;
+      const length = _children.length;
+      if (length > 0) {
+        const r4 = 0 < length;
+        let r16 = 0;
+        if (r4) {
+          do {
+            const r13 = _children[r16];
+            r13.__makeNative(a0);
+            connectAnimatedNodes(this.__getNativeTag(), r13.__getNativeTag());
+            r16 = r16 + 1;
+          } while (r16 < length);
+        }
+      }
+    }
+    let env23706;
+    const r25 = env23706 = {};
+    env23706[0] = this;
+    let r32 = _get(_getPrototypeOf(AnimatedWithChildren.prototype), "__makeNative", this);
+    env23706[1] = r32;
+    if (typeof r32 === "function") {
+      r32 = $mk66269(r25);
+    }
+    r32([a0]);
+  }
+}, {
+  key: "__addChild",
+  value: function __addChild(a0) {
+    if (this._children.length === 0) {
+      this.__attach();
+    }
+    this._children.push(a0);
+    if (this.__isNative) {
+      a0.__makeNative(this.__getPlatformConfig());
+      connectAnimatedNodes(this.__getNativeTag(), a0.__getNativeTag());
+    }
+  }
+}, {
+  key: "__removeChild",
+  value: function __removeChild(a0) {
+    const r5 = this._children.indexOf(a0);
+    if (r5 !== -1) {
+      if (this.__isNative && a0.__isNative) {
+        disconnectAnimatedNodes(this.__getNativeTag(), a0.__getNativeTag());
+      }
+      this._children.splice(r5, 1);
+      if (this._children.length === 0) {
+        this.__detach();
+      }
+    } else {
+      console.warn("Trying to remove a child that doesn't exist");
+    }
+  }
+}, {
+  key: "__getChildren",
+  value: function __getChildren() {
+    return this._children;
+  }
+}, {
+  key: "__callListeners",
+  value: function __callListeners(a0) {
+    let env23707;
+    const r10 = env23707 = {};
+    env23707[0] = this;
+    let r15 = _get(_getPrototypeOf(AnimatedWithChildren.prototype), "__callListeners", this);
+    env23707[1] = r15;
+    if (typeof r15 === "function") {
+      r15 = $mk66269(r10);
+    }
+    r15([a0]);
+    if (!this.__isNative) {
+      const _children = this._children;
+      const length = _children.length;
+      let r0 = 0;
+      while (r0 < length) {
+        const r22 = _children[r0];
+        const __getValue = r22.__getValue;
+        const r1 = r0;
+        if (__getValue) {
+          r22.__callListeners(r22.__getValue());
+        }
+        r0 = r1 + 1;
+      }
+    }
+  }
+}]);

_bundle/Animation.js

@@ -0,0 +1,120 @@
+// Metro module 379 (f380).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import Module357 from "./Module357";
+import AnimatedProps from "./AnimatedProps";
+import { cxxNativeAnimatedEnabled } from "./Module27";
+let env402 = {};
+env402[4] = 1;
+const Animation = function Animation(a0) {
+  _classCallCheck(this, Animation);
+  this._useNativeDriver = Module357.shouldUseNativeDriver(a0);
+  this.__active = false;
+  let isInteraction = a0.isInteraction;
+  if (isInteraction == null) {
+    isInteraction = !this._useNativeDriver;
+  }
+  this.__isInteraction = isInteraction;
+  this.__isLooping = a0.isLooping;
+  let iterations = a0.iterations;
+  if (iterations == null) {
+    iterations = 1;
+  }
+  this.__iterations = iterations;
+};
+export default _createClass(Animation, [{
+  key: "start",
+  value: function start(a0, a1, a2, a3, a4) {
+    if (!this._useNativeDriver && a4.__isNative === true) {
+      throw new Error("Attempting to run JS driven animation on animated node that has been moved to \"native\" earlier by starting an animation with `useNativeDriver: true`");
+    }
+    this._onEnd = a2;
+    this.__active = true;
+  }
+}, {
+  key: "stop",
+  value: function stop() {
+    let r2, r5;
+    if (this._nativeID != null) {
+      const _nativeID = this._nativeID;
+      const r15 = `${_nativeID}:stopAnimation`;
+      try {
+        r5 = importDefault;
+        r2 = dependencyMap;
+        Module357.API.setWaitingForIdentifier(r15);
+        Module357.API.stopAnimation(_nativeID);
+      } catch (r35) {
+        Module357.API.unsetWaitingForIdentifier(r15);
+        throw r35;
+      }
+      r5(r2[2]).API.unsetWaitingForIdentifier(r15);
+    }
+    this.__active = false;
+  }
+}, {
+  key: "__getNativeAnimationConfig",
+  value: function __getNativeAnimationConfig() {
+    throw new Error("This animation type cannot be offloaded to native");
+  }
+}, {
+  key: "__findAnimatedPropsNodes",
+  value: function __findAnimatedPropsNodes(a0) {
+    const r0 = [];
+    if (a0 instanceof AnimatedProps) {
+      r0.push(a0);
+      return r0;
+    }
+    for (const item of a0.__getChildren()) {
+      r0.push.apply(r0, [...this.__findAnimatedPropsNodes(item)]);
+    }
+    return r0;
+  }
+}, {
+  key: "__startAnimationIfNative",
+  value: function __startAnimationIfNative(a0) {
+    let c23739_0 = a0;
+    if (this._useNativeDriver) {
+      const r20 = `${env402[4]}:startAnimation`;
+      env402[4] = env402[4] + 1;
+      Module357.API.setWaitingForIdentifier(r20);
+      try {
+        try {
+          const r9 = this.__getNativeAnimationConfig();
+          a0.__makeNative(r9.platformConfig);
+          this._nativeID = Module357.generateNewAnimationId();
+          Module357.API.startAnimatingNode(this._nativeID, a0.__getNativeTag(), r9, (a0) => {
+            this.__notifyAnimationEnd(a0);
+            const { value, offset } = a0;
+            if (value != null) {
+              c23739_0.__onAnimatedValueUpdateReceived(value, offset);
+              if (!cxxNativeAnimatedEnabled() && this.__isLooping === true) {
+                return void 0;
+              }
+              this.__findAnimatedPropsNodes(c23739_0).forEach((item) => item.update());
+            }
+          });
+        } catch ($e) {
+          throw $e;
+        }
+      } catch (r51) {
+        Module357.API.unsetWaitingForIdentifier(r20);
+        throw r51;
+      }
+      Module357.API.unsetWaitingForIdentifier(r20);
+      return true;
+    }
+    return false;
+  }
+}, {
+  key: "__notifyAnimationEnd",
+  value: function __notifyAnimationEnd(a0) {
+    const _onEnd = this._onEnd;
+    if (_onEnd != null) {
+      this._onEnd = null;
+      _onEnd(a0);
+    }
+  }
+}, {
+  key: "__getDebugID",
+  value: function __getDebugID() {}
+}]);

_bundle/ApexExperimentStore.js

@@ -0,0 +1,598 @@
+// Metro module 1213 (f1214).
+import _objectWithoutProperties from "./_objectWithoutProperties";
+import { WebAnalyticsEvents } from "./Module505";
+import { Logger } from "./log";
+import * as _Module1214 from "./Module1214";
+import { UnitType, UnitTypeToKind, ExperimentFlags, LOGGED_OUT_USER_ID_SENTINEL } from "./Module1215";
+import MurmurHashV3 from "./MurmurHashV3";
+import Module589 from "./Module589";
+import { Storage } from "./Module595";
+let c1021_7, c1021_8, evaluatedExperiments, c1021_10, clientOverrides, c1021_12, c1021_13, c1021_14, c1021_15, c1021_16, c1021_17, c1021_18, c1021_19, c1021_20;
+const _toPropertyKey = function _toPropertyKey(a0) {
+  let r2 = a0;
+  if (typeof a0 === "object") {
+    r2 = a0;
+    if (a0) {
+      const r5 = a0[Symbol.toPrimitive];
+      if (r5 !== void 0) {
+        r2 = r5.call(a0, "string");
+        if (typeof r2 === "object") {
+          throw new TypeError("@@toPrimitive must return a primitive value.");
+        }
+      } else {
+        r2 = String(a0);
+      }
+    }
+  }
+  let r19 = r2;
+  if (typeof r19 !== "symbol") {
+    r19 = "" + r2;
+  }
+  return r19;
+};
+c1021_7 = new Logger("ApexExperimentStore");
+const window2 = globalThis.window;
+if (!(typeof window2 !== "undefined" ? window.TextEncoder != null && window.TextDecoder != null : typeof window2 === "undefined")) {
+  _Module1214;
+}
+c1021_8 = [UnitType.User, UnitType.Installation];
+evaluatedExperiments = {
+  user: {},
+  guild: {},
+  installation: {}
+};
+c1021_10 = {};
+clientOverrides = {};
+c1021_12 = {};
+c1021_13 = {};
+c1021_14 = {};
+c1021_15 = new Set();
+c1021_16 = new Set();
+c1021_17 = "apexTrackedExposures";
+c1021_18 = 604800000;
+c1021_19 = {};
+c1021_20 = {};
+class BaseApexExperimentStore extends Module589.PersistedStore {
+  static displayName = "ApexExperimentStore";
+  static persistKey = "ApexExperimentStore";
+  track = () => Promise.resolve();
+  surface = "unset";
+  loadStoredState(a0, a1) {
+    if (a0 != null && a0.version === 3) {
+      clientOverrides = a0.clientOverrides;
+      evaluatedExperiments = a0.evaluatedExperiments;
+    } else if (a0 != null && a0.version === 2) {
+      clientOverrides = a0.clientOverrides;
+      evaluatedExperiments = {
+        ...a0.evaluatedExperiments,
+        installation: {}
+      };
+    }
+    c1021_13 = {};
+    for (const key in a1) {
+      let hashedName = c1021_20[key];
+      if (hashedName == null) {
+        const r33 = MurmurHashV3.v3(key);
+        c1021_20[key] = r33;
+        hashedName = r33;
+      }
+      c1021_13[key] = {
+        hashedName,
+        variantId: a1[key],
+        isOverride: true,
+        exposureTrackingEnabled: false,
+        useAsEligibility: false
+      };
+    }
+    c1021_19 = this.loadTrackedExposures();
+  }
+  getState() {
+    return {
+      version: 3,
+      evaluatedExperiments,
+      clientOverrides
+    };
+  }
+  setExperimentAssignments(a0, a1) {
+    if (a0 == null && a1 == null) {
+      return false;
+    }
+    this.clearSessionOverrides();
+    if (a0 != null) {
+      for (const item of c1021_8) {
+        const r58 = UnitTypeToKind[item];
+        const r60 = a0.assignments[item];
+        if (r60 != null && r58 != null) {
+          const r65 = evaluatedExperiments[r58];
+          for (const key in r60) {
+            c1021_16.add(key);
+            const r72 = r60[key];
+            let evaluation_id4 = r72.evaluation_id;
+            const assignments2 = r72.assignments;
+            if (evaluation_id4 == null) {
+              evaluation_id4 = void 0;
+            }
+            const r75 = {
+              evaluationId: evaluation_id4,
+              assignments: {}
+            };
+            r65[key] = r75;
+            for (const item2 of assignments2) {
+              const [r88, variantId, r90, revision2, trackedVariantId, config] = item2;
+              let r91 = r90;
+              if (r90 == null) {
+                r91 = 0;
+              }
+              const assignments = r75.assignments;
+              const r33 = r91;
+              assignments[r88] = {
+                hashedName: r88,
+                variantId,
+                trackedVariantId,
+                isOverride: !!(r33 & ExperimentFlags.IsOverride),
+                revision: revision2,
+                exposureTrackingEnabled: !!(r33 & ExperimentFlags.ExposureTrackingEnabled),
+                useAsEligibility: !!(r33 & ExperimentFlags.UseAsEligibility),
+                config
+              };
+            }
+          }
+        }
+      }
+    }
+    if (a1 != null) {
+      this.setGuildExperimentAssignments(a1);
+    }
+    return true;
+  }
+  setGuildExperimentAssignments(a0) {
+    let r3 = a0;
+    const guild = evaluatedExperiments.guild;
+    const r2 = Object;
+    if (a0 == null) {
+      r3 = {};
+    }
+    for (const item of r2.entries(r3)) {
+      const [r48, r49] = item;
+      let evaluation_id4 = r49.evaluation_id;
+      const assignments = r49.assignments;
+      if (evaluation_id4 == null) {
+        evaluation_id4 = void 0;
+      }
+      const r52 = {
+        evaluationId: evaluation_id4,
+        assignments: {}
+      };
+      guild[r48] = r52;
+      for (const item2 of assignments) {
+        const [r63, variantId, r65, revision2, trackedVariantId] = item2;
+        let r66 = r65;
+        if (r65 == null) {
+          r66 = 0;
+        }
+        const r22 = r66;
+        r52.assignments[r63] = {
+          hashedName: r63,
+          variantId,
+          trackedVariantId,
+          isOverride: !!(r22 & ExperimentFlags.IsOverride),
+          revision: revision2,
+          exposureTrackingEnabled: !!(r22 & ExperimentFlags.ExposureTrackingEnabled),
+          useAsEligibility: !!(r22 & ExperimentFlags.UseAsEligibility)
+        };
+      }
+    }
+  }
+  createOverride(a0, a1) {
+    const r1 = {
+      ...clientOverrides
+    };
+    let hashedName = c1021_20[a0];
+    if (hashedName == null) {
+      const r15 = MurmurHashV3.v3(a0);
+      c1021_20[a0] = r15;
+      hashedName = r15;
+    }
+    r1[a0] = {
+      hashedName,
+      variantId: a1,
+      isOverride: true,
+      exposureTrackingEnabled: false
+    };
+    clientOverrides = r1;
+    this.trackExposureSuppression(a0, "client_override");
+  }
+  deleteOverride(a0) {
+    const r4 = clientOverrides;
+    r4[a0];
+    clientOverrides = _objectWithoutProperties(r4, [a0].map(_toPropertyKey));
+  }
+  createSessionOverride(a0, a1) {
+    const r1 = {
+      ...c1021_12
+    };
+    let hashedName = c1021_20[a0];
+    if (hashedName == null) {
+      const r15 = MurmurHashV3.v3(a0);
+      c1021_20[a0] = r15;
+      hashedName = r15;
+    }
+    r1[a0] = {
+      hashedName,
+      variantId: a1,
+      isOverride: true,
+      exposureTrackingEnabled: false
+    };
+    c1021_12 = r1;
+  }
+  deleteSessionOverride(a0) {
+    const r4 = c1021_12;
+    r4[a0];
+    c1021_12 = _objectWithoutProperties(r4, [a0].map(_toPropertyKey));
+  }
+  setExperimentsMetadata(a0) {
+    c1021_14 = {
+      ...c1021_14,
+      ...Object.fromEntries(a0.map((item) => [item.name, item]))
+    };
+  }
+  getExperimentsMetadata() {
+    return c1021_14;
+  }
+  getClientOverrides() {
+    return clientOverrides;
+  }
+  getSessionOverrides() {
+    return c1021_12;
+  }
+  getExperimentClientOverride(a0) {
+    return clientOverrides[a0];
+  }
+  getExperimentSessionOverride(a0) {
+    return c1021_12[a0];
+  }
+  handleLogout(a0) {
+    if (!a0) {
+      this.clearUserServerAssignments();
+      this.clearSessionOverrides();
+    }
+    Storage.remove(c1021_17);
+    this.clearAllTrackedExposures();
+  }
+  registerExperiment(a0) {
+    c1021_10[a0.name] = a0;
+    if (c1021_13[a0.name] != null) {
+      this.trackExposureSuppression(a0.name, "cookie_override");
+    }
+  }
+  getRegisteredExperiments() {
+    return c1021_10;
+  }
+  getAssignment(a0, a1, a2) {
+    let r7 = this.getOverride(a2);
+    if (r7 == null) {
+      r7 = this.getServerAssignment(a0, a1, a2);
+    }
+    return r7;
+  }
+  getServerAssignment(a0, a1, a2) {
+    let r3 = c1021_20[a2];
+    if (r3 == null) {
+      const r11 = MurmurHashV3.v3(a2);
+      c1021_20[a2] = r11;
+      r3 = r11;
+    }
+    const r16 = evaluatedExperiments[a0][a1];
+    if (r16 != null) {
+      return r16.assignments[r3];
+    }
+  }
+  getEvaluation(a0, a1) {
+    return evaluatedExperiments[a0][a1]?.evaluationId;
+  }
+  getEvaluationAndAssignmentInner(a0, a1, a2) {
+    let r14;
+    const override = this.getOverride(a2);
+    if (override != null) {
+      return [void 0, override];
+    }
+    const r12 = evaluatedExperiments[a0][a1];
+    if (r12 == null) {
+      r14 = [void 0, void 0];
+    } else {
+      r14 = [r12.evaluationId, ,];
+      const assignments = r12.assignments;
+      let r16 = c1021_20[a2];
+      if (r16 == null) {
+        const r22 = MurmurHashV3.v3(a2);
+        c1021_20[a2] = r22;
+        r16 = r22;
+      }
+      r14[1] = assignments[r16];
+    }
+    return r14;
+  }
+  getEvaluationAndAssignment(a0, a1, a2, a3) {
+    const [r14, r15] = this.getEvaluationAndAssignmentInner(a0, a1, a2);
+    if (a0 !== "guild") {
+      return [r14, r15];
+    }
+    let r16 = a3;
+    const getEvaluationAndAssignmentInner2 = this.getEvaluationAndAssignmentInner;
+    if (a3 == null) {
+      r16 = LOGGED_OUT_USER_ID_SENTINEL;
+    }
+    const [, r25] = getEvaluationAndAssignmentInner2.call(this, "user", r16, a2);
+    return r25 == null ? [void 0, void 0] : r25.isOverride ? [r14, r25] : r25.useAsEligibility ? r15 == null ? [void 0, void 0] : r15.variantId != null ? [r14, r15] : [void 0, void 0] : [void 0, void 0];
+  }
+  trackExperimentExposure(evaluation_id, a1, a2, a3, a4, a5, a6) {
+    const experiment = a1;
+    const exposure_location = a2;
+    const unit_type = a3;
+    const revision = a4;
+    const tracked_variation_id = a5;
+    const installation_id = a6;
+    const r7 = `${a1}|${a4}|${a5}|${a2}|${a6}|1`;
+    let r28 = c1021_20[r7];
+    if (r28 == null) {
+      const r35 = MurmurHashV3.v3(r7);
+      c1021_20[r7] = r35;
+      r28 = r35;
+    }
+    if (a3 === "user") {
+      this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_USER_EVALUATION_EXPOSED, {
+        evaluation_id,
+        experiment,
+        exposure_location,
+        unit_type,
+        tracked_variation_id
+      }, {
+        flush: true
+      }));
+    } else if (a3 === "installation") {
+      this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, {
+        evaluation_id,
+        installation_id,
+        experiment,
+        exposure_location,
+        unit_type,
+        tracked_variation_id
+      }, {
+        flush: true
+      }));
+    } else if (a3 === "guild") {
+      this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_GUILD_EVALUATION_EXPOSED, {
+        evaluation_id,
+        guild_id: installation_id,
+        experiment,
+        exposure_location,
+        unit_type,
+        tracked_variation_id,
+        revision
+      }, {
+        flush: true
+      }));
+    }
+  }
+  trackCommonTriggerPointExposures(exposure_location2) {
+    const _this = this;
+    const _loop = function _loop(a0) {
+      const evaluation_id2 = a0;
+      const r11 = `${a0}|${exposure_location2}`;
+      let r13 = c1021_20[r11];
+      if (r13 == null) {
+        const r20 = MurmurHashV3.v3(r11);
+        c1021_20[r11] = r20;
+        r13 = r20;
+      }
+      _this.withExposureTracking(r13, () => _this.track(WebAnalyticsEvents.EXPERIMENT_USER_EVALUATION_EXPOSED, {
+        evaluation_id: evaluation_id2,
+        exposure_location: exposure_location2,
+        unit_type: "user"
+      }, {
+        flush: true
+      }));
+    };
+    for (const item of this.evaluationsWithUnitIds("user")) {
+      _loop(item.evaluationId);
+    }
+    const _loop2 = function _loop2(a0, installation_id2) {
+      const evaluation_id3 = a0;
+      const r12 = `${a0}|${exposure_location2}`;
+      let r14 = c1021_20[r12];
+      if (r14 == null) {
+        const r21 = MurmurHashV3.v3(r12);
+        c1021_20[r12] = r21;
+        r14 = r21;
+      }
+      _this.withExposureTracking(r14, () => _this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, {
+        evaluation_id: evaluation_id3,
+        exposure_location: exposure_location2,
+        unit_type: "installation",
+        installation_id: installation_id2
+      }, {
+        flush: true
+      }));
+    };
+    for (const item2 of this.evaluationsWithUnitIds("installation")) {
+      _loop2(item2.evaluationId, item2.unitId);
+    }
+  }
+  withExposureTracking(a0, a1) {
+    if (this.shouldTrackExposure(a0)) {
+      a1();
+      c1021_19[a0] = Date.now();
+      this.saveTrackedExposures(c1021_19);
+    }
+  }
+  trackExposureSuppression(a0, a1) {
+    const r6 = c1021_10[a0];
+    if (r6 != null) {
+      if (r6.kind === "user") {
+        this.track(WebAnalyticsEvents.EXPERIMENT_USER_EXPOSURE_SUPPRESSED, {
+          experiment: a0,
+          unit_type: r6.kind,
+          suppression_source: a1
+        }, {
+          flush: true
+        });
+      } else if (r6.kind === "installation") {
+        const installation_id3 = Object.keys(evaluatedExperiments.installation)[0];
+        if (installation_id3 != null) {
+          this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EXPOSURE_SUPPRESSED, {
+            experiment: a0,
+            unit_type: r6.kind,
+            suppression_source: a1,
+            installation_id: installation_id3
+          }, {
+            flush: true
+          });
+        }
+      } else if (r6.kind === "guild") {
+        const guild_id = Object.keys(evaluatedExperiments.guild)[0];
+        if (guild_id != null) {
+          this.track(WebAnalyticsEvents.EXPERIMENT_GUILD_EXPOSURE_SUPPRESSED, {
+            experiment: a0,
+            unit_type: r6.kind,
+            suppression_source: a1,
+            guild_id
+          }, {
+            flush: true
+          });
+        }
+      }
+    }
+  }
+  evaluationIds(a0) {
+    return Object.values(evaluatedExperiments[a0]).map((item) => item.evaluationId).filter((item) => item != null);
+  }
+  evaluationsWithUnitIds(a0) {
+    return Object.entries(evaluatedExperiments[a0]).filter((item) => {
+      const [, r13] = item;
+      return r13.evaluationId != null;
+    }).map((item) => {
+      const [unitId, r14] = item;
+      return {
+        evaluationId: r14.evaluationId,
+        unitId
+      };
+    });
+  }
+  shouldTrackExposure(a0) {
+    const r6 = c1021_19[a0];
+    return r6 == null || Date.now() - r6 > c1021_18;
+  }
+  loadTrackedExposures() {
+    let r3;
+    const r19 = Storage.get(c1021_17);
+    if (r19 != null && r19.version === 2) {
+      const exposures = r19.exposures;
+      const r11 = Date.now();
+      let r2 = false;
+      let r27 = false;
+      for (const key in exposures) {
+        r3 = r2;
+        r27 = r3;
+        const r30 = r11 - exposures[key];
+        r2 = r3;
+        if (r30 > c1021_18) {
+          delete exposures[key];
+          r2 = true;
+        }
+      }
+      r3 = r2;
+      r27 = r3;
+      if (r27) {
+        this.saveTrackedExposures(exposures);
+      }
+      return exposures;
+    }
+    return {};
+  }
+  saveTrackedExposures(a0) {
+    try {
+      Storage.set(c1021_17, {
+        version: 2,
+        exposures: a0
+      });
+    } catch ($e) {
+      c1021_7.error("Error saving tracked exposures", $e);
+      this.track(WebAnalyticsEvents.EXPERIMENT_SAVE_EXPOSURE_FAILED, {
+        module: this.surface,
+        call: "ApexExperimentStore.saveTrackedExposures"
+      }, {
+        flush: true
+      });
+    }
+  }
+  clearForTests() {
+    this.clearAllServerAssignments();
+    this.clearAllOverrides();
+    this.clearAllTrackedExposures();
+    c1021_15.clear();
+    c1021_16.clear();
+  }
+  clearAllServerAssignments() {
+    evaluatedExperiments = {
+      user: {},
+      guild: {},
+      installation: {}
+    };
+  }
+  clearUserServerAssignments() {
+    evaluatedExperiments = {
+      user: {},
+      guild: {},
+      installation: evaluatedExperiments.installation
+    };
+  }
+  clearAllOverrides() {
+    clientOverrides = {};
+    c1021_12 = {};
+    c1021_13 = {};
+  }
+  clearSessionOverrides() {
+    c1021_12 = {};
+  }
+  clearAllTrackedExposures() {
+    c1021_19 = {};
+  }
+  getHash(a0) {
+    let r1 = c1021_20[a0];
+    if (r1 == null) {
+      const r11 = MurmurHashV3.v3(a0);
+      c1021_20[a0] = r11;
+      r1 = r11;
+    }
+    return r1;
+  }
+  handleFetchStart(a0) {
+    c1021_15.add(a0);
+  }
+  handleFetchSuccess(a0, a1) {
+    c1021_15.delete(a0);
+    c1021_16.add(a0);
+    this.setExperimentAssignments(a1);
+  }
+  handleFetchFailure(a0) {
+    c1021_15.delete(a0);
+    c1021_16.add(a0);
+  }
+  isFetching(a0) {
+    return c1021_15.has(a0);
+  }
+  hasLoaded(a0) {
+    return c1021_16.has(a0);
+  }
+  getOverride(a0) {
+    let r5 = c1021_12[a0];
+    if (r5 == null) {
+      r5 = clientOverrides[a0];
+    }
+    if (r5 == null) {
+      r5 = c1021_13[a0];
+    }
+    return r5;
+  }
+}
+export default BaseApexExperimentStore;

_bundle/AppStateImpl.js

@@ -0,0 +1,64 @@
+// Metro module 456 (f457).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import Module457 from "./Module457";
+import NativeEventEmitter from "./NativeEventEmitter";
+import _default from "./_default_459";
+let env462 = {};
+const AppStateImpl = function AppStateImpl() {
+  let c23784_0, c23784_1;
+  _classCallCheck(this, AppStateImpl);
+  this.currentState = null;
+  if (Module457 == null) {
+    this.isAvailable = false;
+  } else {
+    this.isAvailable = true;
+    const nativeEventEmitter = new NativeEventEmitter(null);
+    c23784_1 = nativeEventEmitter;
+    this._emitter = nativeEventEmitter;
+    this.currentState = Module457.getConstants().initialAppState;
+    c23784_0 = false;
+    nativeEventEmitter.addListener("appStateDidChange", (a0) => {
+      c23784_0 = true;
+      this.currentState = a0.app_state;
+    });
+    Module457.getCurrentAppState((a0) => {
+      if (!(c23784_0 || this.currentState === a0.app_state)) {
+        this.currentState = a0.app_state;
+        c23784_1.emit("appStateDidChange", a0);
+      }
+    }, _default);
+  }
+};
+export default new (_createClass(AppStateImpl, [{
+  key: "addEventListener",
+  value: function(a0, a1) {
+    let c23785_1, c23785_2;
+    let c23785_0 = a0;
+    const _emitter = this._emitter;
+    if (_emitter == null) {
+      throw new Error("Cannot use AppState when `isAvailable` is false.");
+    }
+    if (a0 === "change") {
+      c23785_1 = a1;
+      return _emitter.addListener("appStateDidChange", (a0) => {
+        c23785_1(a0.app_state);
+      });
+    }
+    if (a0 === "memoryWarning") {
+      return _emitter.addListener("memoryWarning", a1);
+    }
+    if (a0 !== "blur" && a0 !== "focus") {
+      throw new Error("Trying to subscribe to unknown event: " + a0);
+    }
+    c23785_2 = a1;
+    return _emitter.addListener("appStateFocusChange", (a0) => {
+      if (!(c23785_0 !== "blur" || a0)) {
+        c23785_2();
+      }
+      if (c23785_0 === "focus" && a0) {
+        c23785_2();
+      }
+    });
+  }
+}]))();

_bundle/ArrayCreate.js

@@ -0,0 +1,29 @@
+// Metro module 4474 (f4475).
+import * as _GetIntrinsic from "./GetIntrinsic";
+import * as _isInteger from "./isInteger";
+import * as _Module541 from "./Module541";
+import * as _Module4475 from "./Module4475";
+import * as _Module560 from "./Module560";
+import * as _Module4476 from "./Module4476";
+import * as _Module562 from "./Module562";
+let c2692_2 = _GetIntrinsic("%Array.prototype%");
+module.exports = function ArrayCreate(a0) {
+  if (_isInteger(a0) && !(a0 < 0)) {
+    if (a0 > _Module4475) {
+      throw new _Module560("length is greater than (2**32 - 1)");
+    }
+    const r20 = arguments.length > 1 ? arguments[1] : c2692_2;
+    const r21 = [];
+    if (r20 !== c2692_2) {
+      if (!_Module4476) {
+        throw new _Module562("ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]");
+      }
+      _Module4476(r21, r20);
+    }
+    if (a0 !== 0) {
+      r21.length = a0;
+    }
+    return r21;
+  }
+  throw new _Module541("Assertion failed: `length` must be an integer Number >= 0");
+};

_bundle/ArraySpeciesCreate.js

@@ -0,0 +1,36 @@
+// Metro module 4470 (f4471).
+import * as _GetIntrinsic from "./GetIntrinsic";
+import * as _isInteger from "./isInteger";
+import * as _Module541 from "./Module541";
+import * as _Module4472 from "./Module4472";
+import * as _ArrayCreate from "./ArrayCreate";
+import * as _Get from "./Get_4480";
+import * as _isObject from "./isObject_4434";
+import * as _Module4482 from "./Module4482";
+let c2689_2 = _GetIntrinsic("%Symbol.species%", true);
+module.exports = function ArraySpeciesCreate(a0, a1) {
+  if (_isInteger(a1) && !(a1 < 0)) {
+    if (_Module4472(a0)) {
+      const r10 = _Get(a0, "constructor");
+      let r25 = c2689_2 ? _isObject(r10) : c2689_2;
+      let r28 = r10;
+      if (r25) {
+        const r31 = _Get(r10, c2689_2);
+        r25 = r31 === null;
+        r28 = r31;
+      }
+      if (r25) {
+        r28 = void 0;
+      }
+      if (r28 === void 0) {
+        return _ArrayCreate(a1);
+      }
+      if (_Module4482(r28)) {
+        return new r28(a1);
+      }
+      throw new _Module541("C must be a constructor");
+    }
+    return _ArrayCreate(a1);
+  }
+  throw new _Module541("Assertion failed: length must be an integer >= 0");
+};

_bundle/AssetSourceResolver.js

@@ -0,0 +1,109 @@
+// Metro module 85 (f86).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import { pickScale } from "./Module86";
+import * as _PixelRatio from "./PixelRatio";
+import { getBasePath, getAndroidResourceIdentifier, getAndroidResourceFolderName } from "./Module102";
+import * as _Module38 from "./Module38";
+let env84 = {};
+const AssetSourceResolver = function AssetSourceResolver(a0, a1, a2) {
+  _classCallCheck(this, AssetSourceResolver);
+  this.serverUrl = a0;
+  this.jsbundleUrl = a1;
+  this.asset = a2;
+};
+const r39 = _createClass(AssetSourceResolver, [{
+  key: "isLoadedFromServer",
+  value: function isLoadedFromServer() {
+    return this.serverUrl != null && this.serverUrl !== "" && !(this.asset.type === "xml");
+  }
+}, {
+  key: "isLoadedFromFileSystem",
+  value: function isLoadedFromFileSystem() {
+    let r6 = this.jsbundleUrl != null;
+    if (r6) {
+      const jsbundleUrl = this.jsbundleUrl;
+      r6 = jsbundleUrl == null ? void 0 : jsbundleUrl.startsWith("file://");
+    }
+    return r6;
+  }
+}, {
+  key: "defaultAsset",
+  value: function defaultAsset() {
+    return this.isLoadedFromServer() ? this.assetServerURL() : this.asset.resolver != null ? this.getAssetUsingResolver(this.asset.resolver) : this.isLoadedFromFileSystem() ? this.drawableFolderInBundle() : this.resourceIdentifierWithoutScale();
+  }
+}, {
+  key: "getAssetUsingResolver",
+  value: function getAssetUsingResolver(a0) {
+    if (a0 === "android") {
+      return this.isLoadedFromFileSystem() ? this.drawableFolderInBundle() : this.resourceIdentifierWithoutScale();
+    }
+    if (a0 === "generic") {
+      return this.scaledAssetURLNearBundle();
+    }
+    throw new Error("Don't know how to get asset via provided resolver: " + a0 + "\nAsset: " + JSON.stringify(this.asset, null, "\t") + "\nPossible resolvers are:" + JSON.stringify(["android", "generic"], null, "\t"));
+  }
+}, {
+  key: "assetServerURL",
+  value: function assetServerURL() {
+    _Module38(this.serverUrl != null, "need server to load from");
+    const fromSource2 = this.fromSource;
+    const serverUrl = this.serverUrl;
+    const asset = this.asset;
+    const r25 = pickScale(asset.scales, _PixelRatio.default.get());
+    const r26 = r25 !== 1 ? "@" + r25 + "x" : "";
+    return fromSource2.call(this, serverUrl + (HermesInternal.concat.call(getBasePath(asset) + "/" + asset.name, r26, ".") + asset.type) + "?platform=android&hash=" + this.asset.hash);
+  }
+}, {
+  key: "scaledAssetPath",
+  value: function scaledAssetPath() {
+    const fromSource2 = this.fromSource;
+    const asset = this.asset;
+    const r17 = pickScale(asset.scales, _PixelRatio.default.get());
+    const r18 = r17 !== 1 ? "@" + r17 + "x" : "";
+    return fromSource2.call(this, HermesInternal.concat.call(getBasePath(asset) + "/" + asset.name, r18, ".") + asset.type);
+  }
+}, {
+  key: "scaledAssetURLNearBundle",
+  value: function scaledAssetURLNearBundle() {
+    let jsbundleUrl = this.jsbundleUrl;
+    if (jsbundleUrl == null) {
+      jsbundleUrl = "file://";
+    }
+    const fromSource2 = this.fromSource;
+    const asset = this.asset;
+    const r19 = pickScale(asset.scales, _PixelRatio.default.get());
+    const r20 = r19 !== 1 ? "@" + r19 + "x" : "";
+    return fromSource2.call(this, jsbundleUrl + (HermesInternal.concat.call(getBasePath(asset) + "/" + asset.name, r20, ".") + asset.type).replace(/\.\.\//g, "_"));
+  }
+}, {
+  key: "resourceIdentifierWithoutScale",
+  value: function resourceIdentifierWithoutScale() {
+    _Module38(true, "resource identifiers work on Android");
+    return this.fromSource(getAndroidResourceIdentifier(this.asset));
+  }
+}, {
+  key: "drawableFolderInBundle",
+  value: function drawableFolderInBundle() {
+    let jsbundleUrl = this.jsbundleUrl;
+    if (jsbundleUrl == null) {
+      jsbundleUrl = "file://";
+    }
+    const fromSource2 = this.fromSource;
+    const asset = this.asset;
+    return fromSource2.call(this, jsbundleUrl + (getAndroidResourceFolderName(asset, pickScale(asset.scales, _PixelRatio.default.get())) + "/" + getAndroidResourceIdentifier(asset) + "." + asset.type));
+  }
+}, {
+  key: "fromSource",
+  value: function fromSource(a0) {
+    return {
+      __packager_asset: true,
+      width: this.asset.width,
+      height: this.asset.height,
+      uri: a0,
+      scale: pickScale(this.asset.scales, _PixelRatio.default.get())
+    };
+  }
+}]);
+r39.pickScale = pickScale;
+export default r39;

_bundle/AstBuilder.js

@@ -0,0 +1,120 @@
+// Metro module 1286 (f1287).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+import * as _possibleConstructorReturn from "./_possibleConstructorReturn";
+import * as _getPrototypeOf from "./_getPrototypeOf";
+import * as __inherits from "./_inherits";
+import { FormatBuilder } from "./isRichTextTag";
+let c1052_0, c1052_5, c1052_6;
+let AstBuilder;
+let env1052 = {};
+env1052[4] = function _isNativeReflectConstruct() {
+  let c12948_0;
+  try {
+    c12948_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12948_0;
+  };
+  env1052[4] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+export function formatToAst(a0, a1) {
+  return typeof a0 === "string" ? [{
+    type: c1052_0.Text,
+    content: a0
+  }] : this.bindFormatValues(c1052_6, a0, a1);
+}
+c1052_0 = {};
+export { c1052_0 as RichTextNodeType };
+c1052_0.Text = "text";
+c1052_0.Strong = "strong";
+c1052_0.Emphasis = "em";
+c1052_0.Strikethrough = "s";
+c1052_0.Code = "inlineCode";
+c1052_0.Link = "link";
+c1052_0.Paragraph = "paragraph";
+c1052_5 = {
+  $b: (a0) => ({
+    type: c1052_0.Strong,
+    content: a0
+  }),
+  $i: (a0) => ({
+    type: c1052_0.Emphasis,
+    content: a0
+  }),
+  $del: (a0) => ({
+    type: c1052_0.Strikethrough,
+    content: a0
+  }),
+  $code: (a0) => ({
+    type: c1052_0.Code,
+    content: a0
+  }),
+  $link: (a0, a1, a2) => {
+    const [target] = a2;
+    return {
+      type: c1052_0.Link,
+      target,
+      content: a0
+    };
+  },
+  $p: (a0) => ({
+    type: c1052_0.Paragraph,
+    content: a0
+  })
+};
+AstBuilder = function AstBuilder() {
+  _classCallCheck(this, AstBuilder);
+  const r8 = _getPrototypeOf(AstBuilder);
+  const r23 = _possibleConstructorReturn(this, (0, env1052[4])() ? Reflect.construct(r8, arguments, _getPrototypeOf(this).constructor) : r8.apply(this, arguments));
+  r23.result = [];
+  return r23;
+};
+__inherits(AstBuilder, FormatBuilder);
+const builder = __createClass(AstBuilder, [{
+  key: "pushRichTextTag",
+  value: function pushRichTextTag(a0, a1, a2) {
+    if (a0 in c1052_5) {
+      const r19 = c1052_5[a0](a1, "", a2);
+      const isArray = Array.isArray(r19);
+      const result = this.result;
+      const push = result.push;
+      if (isArray) {
+        push.apply(result, [...r19]);
+      } else {
+        push.call(result, r19);
+      }
+      return void 0;
+    }
+    throw `${a0} is not a known rich text formatting tag`;
+  }
+}, {
+  key: "pushLiteralText",
+  value: function pushLiteralText(a0) {
+    const r10 = this.result[this.result.length - 1];
+    if (r10 != null && r10.type === c1052_0.Text) {
+      r10.content = r10.content + a0;
+    } else {
+      this.result.push({
+        type: c1052_0.Text,
+        content: a0
+      });
+    }
+  }
+}, {
+  key: "pushObject",
+  value: function pushObject(a0) {
+    this.result.push(a0);
+  }
+}, {
+  key: "finish",
+  value: function finish() {
+    return this.result;
+  }
+}]);
+c1052_6 = builder;
+export const astFormatter = {
+  format: formatToAst,
+  builder
+};

_bundle/AsyncExpiringMap.js

@@ -0,0 +1,131 @@
+// Metro module 1163 (f1164).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+let env966 = {};
+const AsyncExpiringMap = function AsyncExpiringMap(r3 = {}) {
+  const { cleanupInterval = 5000, ttl: ttl2 = 2000 } = r3;
+  _classCallCheck(this, AsyncExpiringMap);
+  this._ttl = ttl2;
+  this._map = new Map();
+  this._cleanupIntervalMs = cleanupInterval;
+  this.startCleanup();
+};
+exports.AsyncExpiringMap = _createClass(AsyncExpiringMap, [{
+  key: "set",
+  value: function set(a0, a1) {
+    let c24264_0;
+    if (!this._cleanupInterval) {
+      this.startCleanup();
+    }
+    if (typeof a1 === "object" && (a1 && "then" in a1)) {
+      const r19 = {
+        value: void 0,
+        expiresAt: null,
+        promise: a1
+      };
+      c24264_0 = r19;
+      this._map.set(a0, r19);
+      a1.then((result) => {
+        c24264_0.value = result;
+        c24264_0.expiresAt = Date.now() + this._ttl;
+        c24264_0.promise = null;
+      }, () => {
+        c24264_0.expiresAt = Date.now() + this._ttl;
+        c24264_0.promise = null;
+      });
+    } else {
+      this._map.set(a0, {
+        value: a1,
+        expiresAt: Date.now() + this._ttl,
+        promise: null
+      });
+    }
+  }
+}, {
+  key: "pop",
+  value: function pop(a0) {
+    const r4 = this.get(a0);
+    this._map.delete(a0);
+    return r4;
+  }
+}, {
+  key: "get",
+  value: function get(a0) {
+    let promise;
+    const r8 = this._map.get(a0);
+    if (r8) {
+      if (r8.promise) {
+        promise = r8.promise;
+      } else {
+        if (r8.expiresAt && r8.expiresAt <= Date.now()) {
+          this._map.delete(a0);
+        }
+        promise = r8.value;
+      }
+      return promise;
+    }
+  }
+}, {
+  key: "has",
+  value: function has(a0) {
+    const r10 = this._map.get(a0);
+    let r11 = !!r10;
+    if (r11) {
+      let r13 = !!r10.promise;
+      if (!r13) {
+        const r14 = r10.expiresAt && r10.expiresAt <= Date.now();
+        let r2 = !r14;
+        if (r14) {
+          this._map.delete(a0);
+          r2 = false;
+        }
+        r13 = r2;
+      }
+      r11 = r13;
+    }
+    return r11;
+  }
+}, {
+  key: "ttl",
+  value: function ttl(a0) {
+    const r6 = this._map.get(a0);
+    if (r6?.expiresAt) {
+      const r14 = r6.expiresAt - Date.now();
+      return r14 > 0 ? r14 : 0;
+    }
+  }
+}, {
+  key: "cleanup",
+  value: function cleanup() {
+    const r5 = Date.now();
+    for (const item of this._map.entries()) {
+      const [r34, r35] = item;
+      if (r35.expiresAt && r35.expiresAt <= r5) {
+        this._map.delete(r34);
+      }
+    }
+    if (!this._map.size) {
+      this.stopCleanup();
+    }
+  }
+}, {
+  key: "clear",
+  value: function clear() {
+    if (this._cleanupInterval) {
+      clearInterval(this._cleanupInterval);
+    }
+    this._map.clear();
+  }
+}, {
+  key: "stopCleanup",
+  value: function stopCleanup() {
+    if (this._cleanupInterval) {
+      clearInterval(this._cleanupInterval);
+    }
+  }
+}, {
+  key: "startCleanup",
+  value: function startCleanup() {
+    this._cleanupInterval = setInterval(() => this.cleanup(), this._cleanupIntervalMs);
+  }
+}]);

_bundle/AsyncFromSyncIterator_976.js

@@ -0,0 +1,975 @@
+// Metro module 976 (f977).
+import * as _awaitAsyncGenerator from "./_awaitAsyncGenerator";
+import * as _wrapAsyncGenerator from "./_wrapAsyncGenerator";
+import { SPAN_STATUS_ERROR } from "./Module840";
+import { captureException } from "./captureCheckIn";
+import { GEN_AI_RESPONSE_STREAMING_ATTRIBUTE, GEN_AI_RESPONSE_ID_ATTRIBUTE, GEN_AI_RESPONSE_MODEL_ATTRIBUTE, GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE, GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE, GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE, GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE, GEN_AI_RESPONSE_TEXT_ATTRIBUTE, GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE } from "./Module958";
+import { HermesBuiltin, $createGenerator } from "../_hermes/prelude";
+function $mk101540($env) {
+  return function(a0) {
+    return {
+      value: a0,
+      done: $env[0]
+    };
+  };
+}
+let processChunk;
+let env803 = {};
+env803[4] = function AsyncFromSyncIterator(a0) {
+  const AsyncFromSyncIterator2 = function AsyncFromSyncIterator(a0) {
+    this.s = a0;
+    this.n = a0.next;
+  };
+  env803[4] = AsyncFromSyncIterator2;
+  AsyncFromSyncIterator2.prototype = {
+    s: null,
+    n: null,
+    next: function next() {
+      let r23;
+      const r12 = this.n.apply(this.s, arguments);
+      const r15 = Object(r12);
+      if (r15 !== r12) {
+        r23 = Promise.reject(new TypeError(r12 + " is not an object."));
+      } else {
+        let env23943;
+        const r16 = env23943 = {};
+        env23943[0] = r12.done;
+        r23 = Promise.resolve(r12.value).then($mk101540(r16));
+      }
+      return r23;
+    },
+    return: function(a0) {
+      let r24;
+      const return2 = this.s.return;
+      if (return2 === void 0) {
+        r24 = Promise.resolve({
+          value: a0,
+          done: true
+        });
+      } else {
+        const r13 = return2.apply(this.s, arguments);
+        const r16 = Object(r13);
+        if (r16 !== r13) {
+          r24 = Promise.reject(new TypeError(r13 + " is not an object."));
+        } else {
+          let env23944;
+          const r17 = env23944 = {};
+          env23944[0] = r13.done;
+          r24 = Promise.resolve(r13.value).then($mk101540(r17));
+        }
+      }
+      return r24;
+    },
+    throw: function(a0) {
+      let r24;
+      const return2 = this.s.return;
+      if (return2 === void 0) {
+        r24 = Promise.reject(a0);
+      } else {
+        const r13 = return2.apply(this.s, arguments);
+        const r16 = Object(r13);
+        if (r16 !== r13) {
+          r24 = Promise.reject(new TypeError(r13 + " is not an object."));
+        } else {
+          let env23945;
+          const r17 = env23945 = {};
+          env23945[0] = r13.done;
+          r24 = Promise.resolve(r13.value).then($mk101540(r17));
+        }
+      }
+      return r24;
+    }
+  };
+  return new env803[4](a0);
+};
+processChunk = function processChunk(a0, a1, a2, a3) {
+  let r3 = a0;
+  if (a0) {
+    const promptFeedback = a0?.promptFeedback;
+    const blockReason = promptFeedback?.blockReason;
+    let r15 = false;
+    if (blockReason) {
+      let blockReasonMessage = promptFeedback.blockReasonMessage;
+      if (blockReasonMessage == null) {
+        blockReasonMessage = promptFeedback.blockReason;
+      }
+      a3.setStatus.call(a3, {
+        code: SPAN_STATUS_ERROR,
+        message: `Content blocked: ${blockReasonMessage}`
+      });
+      captureException(`Content blocked: ${blockReasonMessage}`, {
+        mechanism: {
+          handled: false,
+          type: "auto.ai.google_genai"
+        }
+      });
+      r15 = true;
+    }
+    r3 = !r15;
+  }
+  if (r3) {
+    if (typeof a0.responseId === "string") {
+      a1.responseId = a0.responseId;
+    }
+    if (typeof a0.modelVersion === "string") {
+      a1.responseModel = a0.modelVersion;
+    }
+    const usageMetadata = a0.usageMetadata;
+    if (usageMetadata) {
+      if (typeof usageMetadata.promptTokenCount === "number") {
+        a1.promptTokens = usageMetadata.promptTokenCount;
+      }
+      if (typeof usageMetadata.candidatesTokenCount === "number") {
+        a1.completionTokens = usageMetadata.candidatesTokenCount;
+      }
+      if (typeof usageMetadata.totalTokenCount === "number") {
+        a1.totalTokens = usageMetadata.totalTokenCount;
+      }
+    }
+    (function handleCandidateContent(a0, a1, a2) {
+      if (Array.isArray(a0.functionCalls)) {
+        const toolCalls = a1.toolCalls;
+        toolCalls.push.apply(toolCalls, [...a0.functionCalls]);
+      }
+      let candidates = a0.candidates;
+      if (candidates == null) {
+        candidates = [];
+      }
+      for (const item of candidates) {
+        if (item?.finishReason && !a1.finishReasons.includes(item.finishReason)) {
+          a1.finishReasons.push(item.finishReason);
+        }
+        let r59 = item == null ? void 0 : item.content?.parts;
+        if (r59 == null) {
+          r59 = [];
+        }
+        for (const item2 of r59) {
+          if (a2 ? item2.text : a2) {
+            a1.responseTexts.push(item2.text);
+          }
+          if (item2.functionCall) {
+            const toolCalls2 = a1.toolCalls;
+            toolCalls2.push({
+              type: "function",
+              id: item2.functionCall.id,
+              name: item2.functionCall.name,
+              arguments: item2.functionCall.args
+            });
+          }
+        }
+      }
+    })(a0, a1, a2);
+  }
+};
+env803[6] = function _instrumentStream() {
+  const r8 = _wrapAsyncGenerator(function(c23946_0, c23946_1, c23946_2) {
+    let value, value2, value3, c23946_6, c23946_7, c23946_8, c23946_10;
+    let c23946_11 = 0;
+    let c23946_12 = 0;
+    let c23946_9 = 0;
+    return $createGenerator(function(a0, a1, a2) {
+      let value10, value11, value4, value5, value6, value7, value8, value9;
+      const r0 = c23946_12;
+      if (r0 === 2) {
+        c23946_12 = 3;
+        HermesBuiltin.throwTypeError("Generator functions may not be called on executing generators");
+        throw new Error("unreachable");
+      }
+      const r15 = env803;
+      if (r0 === 3) {
+        if (a0 === 1) {
+          throw a1;
+        }
+        if (a0 === 2) {
+          return {
+            value: a1,
+            done: true
+          };
+        }
+        return {
+          value: void 0,
+          done: true
+        };
+      }
+      while (true) {
+        L291: {
+          L289: {
+            L264: {
+              L256: {
+                L253: {
+                  L225: {
+                    L222: {
+                      L195: {
+                        L189: {
+                          L186: {
+                            L160: {
+                              L155: {
+                                L152: {
+                                  L117: {
+                                    L87: {
+                                      L57: {
+                                        L27: {
+                                          L320: {
+                                            try {
+                                              L295: {
+                                                L231: {
+                                                  L228: {
+                                                    L200: {
+                                                      L196: {
+                                                        L194: {
+                                                          L164: {
+                                                            L130: {
+                                                              c23946_12 = 2;
+                                                              switch (c23946_11) {
+                                                                case 0:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  if (a0 === 2) {
+                                                                    c23946_12 = 3;
+                                                                    break L291;
+                                                                  }
+                                                                  let env28700;
+                                                                  c23946_7 = r15;
+                                                                  const r1370 = env28700 = {
+                                                                    $parent: r15
+                                                                  };
+                                                                  c23946_8 = r1370;
+                                                                  env28700[0] = c23946_1;
+                                                                  env28700[1] = c23946_2;
+                                                                  env28700[3] = void 0;
+                                                                  env28700[6] = void 0;
+                                                                  env28700[7] = void 0;
+                                                                  env28700[8] = void 0;
+                                                                  env28700[9] = void 0;
+                                                                  env28700[2] = {
+                                                                    responseTexts: [],
+                                                                    finishReasons: [],
+                                                                    toolCalls: []
+                                                                  };
+                                                                  env28700[4] = false;
+                                                                  env28700[5] = false;
+                                                                  c23946_9 = 4;
+                                                                  const r1379 = (function _asyncIterator(a0) {
+                                                                    const Symbol2 = globalThis.Symbol;
+                                                                    let r12 = void 0;
+                                                                    let r11 = void 0;
+                                                                    if (typeof Symbol2 !== "undefined") {
+                                                                      r11 = Symbol.asyncIterator;
+                                                                      r12 = Symbol.iterator;
+                                                                    }
+                                                                    let r0 = 1;
+                                                                    while (true) {
+                                                                      const r1 = r0;
+                                                                      const r16 = r12;
+                                                                      const r17 = r11;
+                                                                      if (r17) {
+                                                                        const r18 = a0[r17];
+                                                                        if (r18 != null) {
+                                                                          return r18.call(a0);
+                                                                        }
+                                                                      }
+                                                                      if (r16) {
+                                                                        const r19 = a0[r16];
+                                                                        if (r19 != null) {
+                                                                          return new env803[4](r19.call(a0));
+                                                                        }
+                                                                      }
+                                                                      r0 = r1 - 1;
+                                                                      r12 = "@@iterator";
+                                                                      r11 = "@@asyncIterator";
+                                                                      if (!r1) {
+                                                                        throw new TypeError("Object is not async iterable");
+                                                                      }
+                                                                    }
+                                                                  })(c23946_0);
+                                                                  env28700[7] = r1379;
+                                                                  value11 = _awaitAsyncGenerator(r1379.next());
+                                                                  c23946_11 = 5;
+                                                                  c23946_12 = 1;
+                                                                  break L289;
+                                                                case 1:
+                                                                  const r1240 = c23946_10;
+                                                                  c23946_9 = 0;
+                                                                  const r1242 = {};
+                                                                  r1242[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                                  env28700[9] = r1242;
+                                                                  if (env28700[2].responseId) {
+                                                                    env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                                  }
+                                                                  if (env28700[2].responseModel) {
+                                                                    env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                                  }
+                                                                  if (env28700[2].promptTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                                  }
+                                                                  if (env28700[2].completionTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                                  }
+                                                                  if (env28700[2].totalTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                                  }
+                                                                  if (env28700[2].finishReasons.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].responseTexts.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].toolCalls.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                                  }
+                                                                  env28700[0].setAttributes(env28700[9]);
+                                                                  env28700[0].end();
+                                                                  throw r1240;
+                                                                case 2:
+                                                                  c23946_6 = c23946_10;
+                                                                  c23946_9 = 3;
+                                                                  if (!(env28700[4] && env28700[7].return != null)) {
+                                                                    break L295;
+                                                                  }
+                                                                  value10 = (0, _awaitAsyncGenerator)(env28700[7].return());
+                                                                  c23946_11 = 16;
+                                                                  c23946_12 = 1;
+                                                                  break L264;
+                                                                case 3:
+                                                                  const r1219 = c23946_10;
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  throw r1219;
+                                                                case 4:
+                                                                  const r1069 = c23946_10;
+                                                                  c23946_9 = 2;
+                                                                  env28700[5] = true;
+                                                                  env28700[3] = r1069;
+                                                                  break L228;
+                                                                case 5:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  value3 = a1;
+                                                                  if (a0 === 2) {
+                                                                    c23946_9 = 5;
+                                                                    if (env28700[4] && env28700[7].return != null) {
+                                                                      value8 = (0, _awaitAsyncGenerator)(env28700[7].return());
+                                                                      c23946_11 = 9;
+                                                                      c23946_12 = 1;
+                                                                      break L225;
+                                                                    }
+                                                                    break L200;
+                                                                  }
+                                                                  env28700[6] = a1;
+                                                                  const done2 = a1.done;
+                                                                  env28700[4] = !done2;
+                                                                  if (done2) {
+                                                                    break L196;
+                                                                  }
+                                                                  break L194;
+                                                                case 6:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  value = a1;
+                                                                  if (a0 === 2) {
+                                                                    c23946_9 = 7;
+                                                                    if (env28700[4] && env28700[7].return != null) {
+                                                                      value6 = (0, _awaitAsyncGenerator)(env28700[7].return());
+                                                                      c23946_11 = 13;
+                                                                      c23946_12 = 1;
+                                                                      break L189;
+                                                                    }
+                                                                    break L164;
+                                                                  }
+                                                                  env28700[4] = false;
+                                                                  value5 = (0, _awaitAsyncGenerator)(env28700[7].next());
+                                                                  c23946_11 = 7;
+                                                                  c23946_12 = 1;
+                                                                  break L160;
+                                                                case 7:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  value2 = a1;
+                                                                  if (a0 === 2) {
+                                                                    c23946_9 = 6;
+                                                                    if (env28700[4] && env28700[7].return != null) {
+                                                                      value4 = (0, _awaitAsyncGenerator)(env28700[7].return());
+                                                                      c23946_11 = 11;
+                                                                      c23946_12 = 1;
+                                                                      break L155;
+                                                                    }
+                                                                    break L130;
+                                                                  }
+                                                                  env28700[6] = a1;
+                                                                  const done = a1.done;
+                                                                  env28700[4] = !done;
+                                                                  if (done) {
+                                                                    break L196;
+                                                                  }
+                                                                  break L194;
+                                                                case 8:
+                                                                  const r593 = c23946_10;
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  throw r593;
+                                                                case 9:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  if (a0 !== 2) {
+                                                                    break L200;
+                                                                  }
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  c23946_9 = 0;
+                                                                  const r460 = {};
+                                                                  r460[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                                  env28700[9] = r460;
+                                                                  if (env28700[2].responseId) {
+                                                                    env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                                  }
+                                                                  if (env28700[2].responseModel) {
+                                                                    env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                                  }
+                                                                  if (env28700[2].promptTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                                  }
+                                                                  if (env28700[2].completionTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                                  }
+                                                                  if (env28700[2].totalTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                                  }
+                                                                  if (env28700[2].finishReasons.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].responseTexts.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].toolCalls.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                                  }
+                                                                  env28700[0].setAttributes(env28700[9]);
+                                                                  env28700[0].end();
+                                                                  c23946_12 = 3;
+                                                                  break L117;
+                                                                case 10:
+                                                                  const r453 = c23946_10;
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  throw r453;
+                                                                case 11:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  if (a0 !== 2) {
+                                                                    break L130;
+                                                                  }
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  c23946_9 = 0;
+                                                                  const r320 = {};
+                                                                  r320[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                                  env28700[9] = r320;
+                                                                  if (env28700[2].responseId) {
+                                                                    env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                                  }
+                                                                  if (env28700[2].responseModel) {
+                                                                    env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                                  }
+                                                                  if (env28700[2].promptTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                                  }
+                                                                  if (env28700[2].completionTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                                  }
+                                                                  if (env28700[2].totalTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                                  }
+                                                                  if (env28700[2].finishReasons.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].responseTexts.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].toolCalls.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                                  }
+                                                                  env28700[0].setAttributes(env28700[9]);
+                                                                  env28700[0].end();
+                                                                  c23946_12 = 3;
+                                                                  break L87;
+                                                                case 12:
+                                                                  const r313 = c23946_10;
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  throw r313;
+                                                                case 13:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  if (a0 !== 2) {
+                                                                    break L164;
+                                                                  }
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  c23946_9 = 0;
+                                                                  const r180 = {};
+                                                                  r180[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                                  env28700[9] = r180;
+                                                                  if (env28700[2].responseId) {
+                                                                    env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                                  }
+                                                                  if (env28700[2].responseModel) {
+                                                                    env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                                  }
+                                                                  if (env28700[2].promptTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                                  }
+                                                                  if (env28700[2].completionTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                                  }
+                                                                  if (env28700[2].totalTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                                  }
+                                                                  if (env28700[2].finishReasons.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].responseTexts.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].toolCalls.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                                  }
+                                                                  env28700[0].setAttributes(env28700[9]);
+                                                                  env28700[0].end();
+                                                                  c23946_12 = 3;
+                                                                  break L57;
+                                                                case 14:
+                                                                  const r174 = c23946_10;
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  throw r174;
+                                                                case 15:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  if (a0 !== 2) {
+                                                                    break L231;
+                                                                  }
+                                                                  c23946_9 = 1;
+                                                                  if (env28700[5]) {
+                                                                    throw env28700[3];
+                                                                  }
+                                                                  c23946_9 = 0;
+                                                                  const r44 = {};
+                                                                  r44[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                                  env28700[9] = r44;
+                                                                  if (env28700[2].responseId) {
+                                                                    env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                                  }
+                                                                  if (env28700[2].responseModel) {
+                                                                    env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                                  }
+                                                                  if (env28700[2].promptTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                                  }
+                                                                  if (env28700[2].completionTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                                  }
+                                                                  if (env28700[2].totalTokens !== void 0) {
+                                                                    env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                                  }
+                                                                  if (env28700[2].finishReasons.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].responseTexts.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                                  }
+                                                                  if (env28700[1] && env28700[2].toolCalls.length) {
+                                                                    env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                                  }
+                                                                  env28700[0].setAttributes(env28700[9]);
+                                                                  env28700[0].end();
+                                                                  c23946_12 = 3;
+                                                                  break L27;
+                                                                default:
+                                                                  if (a0 === 1) {
+                                                                    c23946_12 = 3;
+                                                                    throw a1;
+                                                                  }
+                                                                  if (a0 === 2) {
+                                                                    c23946_9 = 1;
+                                                                    if (env28700[5]) {
+                                                                      throw env28700[3];
+                                                                    }
+                                                                    c23946_9 = 0;
+                                                                    const r1396 = {};
+                                                                    r1396[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                                    env28700[9] = r1396;
+                                                                    if (env28700[2].responseId) {
+                                                                      env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                                    }
+                                                                    if (env28700[2].responseModel) {
+                                                                      env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                                    }
+                                                                    if (env28700[2].promptTokens !== void 0) {
+                                                                      env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                                    }
+                                                                    if (env28700[2].completionTokens !== void 0) {
+                                                                      env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                                    }
+                                                                    if (env28700[2].totalTokens !== void 0) {
+                                                                      env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                                    }
+                                                                    if (env28700[2].finishReasons.length) {
+                                                                      env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                                    }
+                                                                    if (env28700[1] && env28700[2].responseTexts.length) {
+                                                                      env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                                    }
+                                                                    if (env28700[1] && env28700[2].toolCalls.length) {
+                                                                      env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                                    }
+                                                                    env28700[0].setAttributes(env28700[9]);
+                                                                    env28700[0].end();
+                                                                    c23946_12 = 3;
+                                                                    break L320;
+                                                                  }
+                                                                  break L295;
+                                                              }
+                                                            }
+                                                            c23946_9 = 1;
+                                                            if (env28700[5]) {
+                                                              throw env28700[3];
+                                                            }
+                                                            c23946_9 = 0;
+                                                            const r607 = {};
+                                                            r607[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                            env28700[9] = r607;
+                                                            if (env28700[2].responseId) {
+                                                              env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                            }
+                                                            if (env28700[2].responseModel) {
+                                                              env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                            }
+                                                            if (env28700[2].promptTokens !== void 0) {
+                                                              env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                            }
+                                                            if (env28700[2].completionTokens !== void 0) {
+                                                              env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                            }
+                                                            if (env28700[2].totalTokens !== void 0) {
+                                                              env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                            }
+                                                            if (env28700[2].finishReasons.length) {
+                                                              env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                            }
+                                                            if (env28700[1] && env28700[2].responseTexts.length) {
+                                                              env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                            }
+                                                            if (env28700[1] && env28700[2].toolCalls.length) {
+                                                              env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                            }
+                                                            env28700[0].setAttributes(env28700[9]);
+                                                            env28700[0].end();
+                                                            c23946_12 = 3;
+                                                            break L152;
+                                                          }
+                                                          c23946_9 = 1;
+                                                          if (env28700[5]) {
+                                                            throw env28700[3];
+                                                          }
+                                                          c23946_9 = 0;
+                                                          const r765 = {};
+                                                          r765[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                          env28700[9] = r765;
+                                                          if (env28700[2].responseId) {
+                                                            env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                          }
+                                                          if (env28700[2].responseModel) {
+                                                            env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                          }
+                                                          if (env28700[2].promptTokens !== void 0) {
+                                                            env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                          }
+                                                          if (env28700[2].completionTokens !== void 0) {
+                                                            env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                          }
+                                                          if (env28700[2].totalTokens !== void 0) {
+                                                            env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                          }
+                                                          if (env28700[2].finishReasons.length) {
+                                                            env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                          }
+                                                          if (env28700[1] && env28700[2].responseTexts.length) {
+                                                            env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                          }
+                                                          if (env28700[1] && env28700[2].toolCalls.length) {
+                                                            env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                          }
+                                                          env28700[0].setAttributes(env28700[9]);
+                                                          env28700[0].end();
+                                                          c23946_12 = 3;
+                                                          break L186;
+                                                        }
+                                                        env28700[8] = env28700[6].value;
+                                                        (0, processChunk)(env28700[8], env28700[2], env28700[1], env28700[0]);
+                                                        value7 = env28700[8];
+                                                        c23946_11 = 6;
+                                                        c23946_12 = 1;
+                                                        break L195;
+                                                      }
+                                                      c23946_9 = 2;
+                                                      break L228;
+                                                    }
+                                                    c23946_9 = 1;
+                                                    if (env28700[5]) {
+                                                      throw env28700[3];
+                                                    }
+                                                    c23946_9 = 0;
+                                                    const r926 = {};
+                                                    r926[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                    env28700[9] = r926;
+                                                    if (env28700[2].responseId) {
+                                                      env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                    }
+                                                    if (env28700[2].responseModel) {
+                                                      env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                    }
+                                                    if (env28700[2].promptTokens !== void 0) {
+                                                      env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                    }
+                                                    if (env28700[2].completionTokens !== void 0) {
+                                                      env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                    }
+                                                    if (env28700[2].totalTokens !== void 0) {
+                                                      env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                    }
+                                                    if (env28700[2].finishReasons.length) {
+                                                      env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                    }
+                                                    if (env28700[1] && env28700[2].responseTexts.length) {
+                                                      env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                    }
+                                                    if (env28700[1] && env28700[2].toolCalls.length) {
+                                                      env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                    }
+                                                    env28700[0].setAttributes(env28700[9]);
+                                                    env28700[0].end();
+                                                    c23946_12 = 3;
+                                                    break L222;
+                                                  }
+                                                  c23946_9 = 8;
+                                                  if (env28700[4] && env28700[7].return != null) {
+                                                    value9 = (0, _awaitAsyncGenerator)(env28700[7].return());
+                                                    c23946_11 = 15;
+                                                    c23946_12 = 1;
+                                                    break L256;
+                                                  }
+                                                }
+                                                c23946_9 = 1;
+                                                if (env28700[5]) {
+                                                  throw env28700[3];
+                                                }
+                                                c23946_9 = 0;
+                                                const r1078 = {};
+                                                r1078[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
+                                                env28700[9] = r1078;
+                                                if (env28700[2].responseId) {
+                                                  env28700[9][GEN_AI_RESPONSE_ID_ATTRIBUTE] = env28700[2].responseId;
+                                                }
+                                                if (env28700[2].responseModel) {
+                                                  env28700[9][GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = env28700[2].responseModel;
+                                                }
+                                                if (env28700[2].promptTokens !== void 0) {
+                                                  env28700[9][GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = env28700[2].promptTokens;
+                                                }
+                                                if (env28700[2].completionTokens !== void 0) {
+                                                  env28700[9][GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = env28700[2].completionTokens;
+                                                }
+                                                if (env28700[2].totalTokens !== void 0) {
+                                                  env28700[9][GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE] = env28700[2].totalTokens;
+                                                }
+                                                if (env28700[2].finishReasons.length) {
+                                                  env28700[9][GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(env28700[2].finishReasons);
+                                                }
+                                                if (env28700[1] && env28700[2].responseTexts.length) {
+                                                  env28700[9][GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = env28700[2].responseTexts.join("");
+                                                }
+                                                if (env28700[1] && env28700[2].toolCalls.length) {
+                                                  env28700[9][GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(env28700[2].toolCalls);
+                                                }
+                                                env28700[0].setAttributes(env28700[9]);
+                                                env28700[0].end();
+                                                c23946_12 = 3;
+                                                break L253;
+                                              }
+                                              c23946_9 = 1;
+                                              if (env28700[5]) {
+                                                throw env28700[3];
+                                              }
+                                              throw c23946_6;
+                                            } catch (r1528) {
+                                              c23946_10 = r1528;
+                                              const r1530 = c23946_9;
+                                              if (r1530 === 0) {
+                                                c23946_12 = 3;
+                                                throw r1528;
+                                              }
+                                              if (r1530 === 1) {
+                                                c23946_11 = 1;
+                                                continue;
+                                              }
+                                              if (r1530 === 2) {
+                                                c23946_11 = 2;
+                                                continue;
+                                              }
+                                              if (r1530 === 3) {
+                                                c23946_11 = 3;
+                                                continue;
+                                              }
+                                              if (r1530 === 4) {
+                                                c23946_11 = 4;
+                                                continue;
+                                              }
+                                              if (r1530 === 5) {
+                                                c23946_11 = 8;
+                                                continue;
+                                              }
+                                              if (r1530 === 6) {
+                                                c23946_11 = 10;
+                                                continue;
+                                              }
+                                              if (r1530 === 7) {
+                                                c23946_11 = 12;
+                                                continue;
+                                              }
+                                              c23946_11 = 14;
+                                              continue;
+                                            }
+                                          }
+                                          return {
+                                            value: a1,
+                                            done: true
+                                          };
+                                        }
+                                        return {
+                                          value: a1,
+                                          done: true
+                                        };
+                                      }
+                                      return {
+                                        value: a1,
+                                        done: true
+                                      };
+                                    }
+                                    return {
+                                      value: a1,
+                                      done: true
+                                    };
+                                  }
+                                  return {
+                                    value: a1,
+                                    done: true
+                                  };
+                                }
+                                return {
+                                  value: value2,
+                                  done: true
+                                };
+                              }
+                              return {
+                                value: value4,
+                                done: false
+                              };
+                            }
+                            return {
+                              value: value5,
+                              done: false
+                            };
+                          }
+                          return {
+                            value,
+                            done: true
+                          };
+                        }
+                        return {
+                          value: value6,
+                          done: false
+                        };
+                      }
+                      return {
+                        value: value7,
+                        done: false
+                      };
+                    }
+                    return {
+                      value: value3,
+                      done: true
+                    };
+                  }
+                  return {
+                    value: value8,
+                    done: false
+                  };
+                }
+                return {
+                  value: void 0,
+                  done: true
+                };
+              }
+              return {
+                value: value9,
+                done: false
+              };
+            }
+            return {
+              value: value10,
+              done: false
+            };
+          }
+          return {
+            value: value11,
+            done: false
+          };
+        }
+        return {
+          value: a1,
+          done: true
+        };
+      }
+    });
+  });
+  env803[6] = r8;
+  return r8.apply(this, arguments);
+};
+Object.defineProperty(exports, Symbol.toStringTag, {
+  value: "Module"
+});
+export function instrumentStream(a0, a1, a2) {
+  return env803[6].apply(this, arguments);
+}

_bundle/AudioTypes.js

@@ -0,0 +1,73 @@
+// Metro module 4783 (f4784).
+import * as __createClass from "./_createClass";
+import * as _classCallCheck from "./_classCallCheck";
+const AudioTypes = function AudioTypes() {
+  _classCallCheck(this, AudioTypes);
+};
+const r16 = __createClass(AudioTypes);
+export { r16 as AudioTypes };
+r16.AAC = {
+  extension: "aac",
+  mimeType: "audio/aac",
+  description: "Advanced Audio Coding (AAC) is an audio coding standard for lossy digital audio compression",
+  signatures: [{
+    sequence: [255, 241],
+    description: "MPEG-4 Advanced Audio Coding (AAC) Low Complexity (LC) audio file"
+  }, {
+    sequence: [255, 249],
+    description: "MPEG-2 Advanced Audio Coding (AAC) Low Complexity (LC) audio file"
+  }]
+};
+r16.AMR = {
+  extension: "amr",
+  mimeType: "audio/amr",
+  description: "Adaptive Multi-Rate ACELP (Algebraic Code Excited Linear Prediction) Codec, commonly audio format with GSM cell phones",
+  signatures: [{
+    sequence: [35, 33, 65, 77, 82]
+  }]
+};
+r16.FLAC = {
+  extension: "flac",
+  mimeType: "audio/x-flac",
+  description: "Free Lossless Audio Codec file",
+  signatures: [{
+    sequence: [102, 76, 97, 67, 0, 0, 0, 34]
+  }]
+};
+r16.M4A = {
+  extension: "m4a",
+  mimeType: "audio/x-m4a",
+  description: "Apple Lossless Audio Codec file",
+  signatures: [{
+    sequence: [102, 116, 121, 112, 77, 52, 65, 32],
+    offset: 4,
+    compatibleExtensions: ["aac"]
+  }]
+};
+r16.MP3 = {
+  extension: "mp3",
+  mimeType: "audio/mpeg",
+  description: "A digital audio file format that uses compression to reduce file size while maintaining high quality sound",
+  signatures: [{
+    sequence: [255, 251],
+    description: "MPEG-1 Layer 3 file without an ID3 tag or with an ID3v1 tag (which is appended at the end of the file)"
+  }, {
+    sequence: [255, 243],
+    description: "MPEG-1 Layer 3 file without an ID3 tag or with an ID3v1 tag (which is appended at the end of the file)"
+  }, {
+    sequence: [255, 242],
+    description: "MPEG-1 Layer 3 file without an ID3 tag or with an ID3v1 tag (which is appended at the end of the file)"
+  }, {
+    sequence: [73, 68, 51],
+    description: "MP3 file with an ID3v2 container"
+  }]
+};
+r16.WAV = {
+  extension: "wav",
+  mimeType: "audio/wav",
+  description: "Waveform Audio File Format",
+  signatures: [{
+    sequence: [82, 73, 70, 70, 87, 65, 86, 69, 102, 109, 116, 32],
+    skippedBytes: [4, 5, 6, 7]
+  }]
+};

_bundle/AverageWindow.js

@@ -0,0 +1,86 @@
+// Metro module 5430 (f5431).
+import _classCallCheck from "./_classCallCheck_5425";
+import _createClass from "./_createClass_5426";
+let c3313_1;
+let MultiTypeAverageWindow;
+let env3313 = {};
+const AverageWindow = function AverageWindow(a0, a1) {
+  _classCallCheck(this, AverageWindow);
+  this.nextIndex = 0;
+  const r8 = Array;
+  const r9 = Math;
+  let currentCount = 1;
+  this.inputValues = new r8(r9.max(1, a0));
+  this.currentAverage = a1 == null ? 0 : a1;
+  if (a1 === void 0) {
+    currentCount = 0;
+  }
+  this.currentCount = currentCount;
+  this.nextIndex = this.currentCount;
+  this.inputValues[0] = a1;
+};
+c3313_1 = _createClass(AverageWindow, [{
+  key: "currentValue",
+  get: function get() {
+    return this.currentAverage;
+  }
+}, {
+  key: "addValue",
+  value: function addValue(a0) {
+    const nextIndex = this.getNextIndex();
+    let r9 = this.inputValues[nextIndex];
+    const currentCount = r9 === void 0 ? this.currentCount + 1 : this.currentCount;
+    this.inputValues[nextIndex] = a0;
+    const r15 = Math;
+    const r18 = this.currentAverage * (this.currentCount / currentCount);
+    if (r9 == null) {
+      r9 = 0;
+    }
+    this.currentAverage = r15.max(0, r18 + (a0 - r9) / currentCount);
+    this.currentCount = currentCount;
+  }
+}, {
+  key: "getNextIndex",
+  value: function getNextIndex() {
+    const nextIndex = this.nextIndex;
+    this.nextIndex = (this.nextIndex + 1) % this.inputValues.length;
+    return nextIndex;
+  }
+}]);
+MultiTypeAverageWindow = function MultiTypeAverageWindow(a0, a1) {
+  _classCallCheck(this, MultiTypeAverageWindow);
+  this.averageWindows = new Map();
+  this.windowSize = a0;
+  this.defaultValue = a1;
+};
+const r34 = _createClass(MultiTypeAverageWindow, [{
+  key: "addValue",
+  value: function addValue(a0, a1) {
+    let r10 = this.averageWindows.get(a1);
+    if (!r10) {
+      const r13 = new c3313_1(this.windowSize);
+      this.averageWindows.set(a1, r13);
+      r10 = r13;
+    }
+    r10.addValue(a0);
+  }
+}, {
+  key: "getCurrentValue",
+  value: function getCurrentValue(a0) {
+    let r8 = this.averageWindows.get(a0)?.currentValue;
+    if (r8 == null) {
+      r8 = this.defaultValue;
+    }
+    if (r8 == null) {
+      r8 = 0;
+    }
+    return r8;
+  }
+}, {
+  key: "reset",
+  value: function reset() {
+    this.averageWindows.clear();
+  }
+}]);
+export { c3313_1 as AverageWindow };
+export { r34 as MultiTypeAverageWindow };

_bundle/BackButton.js

@@ -0,0 +1,61 @@
+// Metro module 10870 (f10871).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import Module19 from "react";
+import { BackHandler } from "react-native";
+import { jsx } from "react/jsx-runtime";
+import { __HistoryContext } from "./Module4017";
+let BackButton;
+let env7307 = {};
+env7307[7] = function _isNativeReflectConstruct() {
+  let c18327_0;
+  try {
+    c18327_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c18327_0;
+  };
+  env7307[7] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+const Component = Module19.Component;
+BackButton = function BackButton(...args) {
+  _classCallCheck(this, BackButton);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BackButton);
+  const r27 = _possibleConstructorReturn(this, (0, env7307[7])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  r27.handleBack = () => {
+    let r1 = this.history.index !== 0;
+    if (r1) {
+      this.history.goBack();
+      r1 = true;
+    }
+    return r1;
+  };
+  return r27;
+};
+_inherits(BackButton, Component);
+export default _createClass(BackButton, [{
+  key: "componentDidMount",
+  value: function componentDidMount() {
+    BackHandler.addEventListener("hardwareBackPress", this.handleBack);
+  }
+}, {
+  key: "componentWillUnmount",
+  value: function componentWillUnmount() {
+    BackHandler.removeEventListener("hardwareBackPress", this.handleBack);
+  }
+}, {
+  key: "render",
+  value: function render() {
+    return (0, jsx)(__HistoryContext.Consumer, {
+      children: (a0) => {
+        this.history = a0;
+        return this.props.children || null;
+      }
+    });
+  }
+}]);

_bundle/Background.jsx

@@ -0,0 +1,10 @@
+// Metro module 5154 (f5155).
+import { View } from "react-native";
+import { useTheme } from "./Module1481";
+export default function Background(props) {
+  const { style, ...rest } = props;
+  return <View {...rest} style={[{
+    flex: 1,
+    backgroundColor: useTheme().colors.background
+  }, style]} />;
+};

_bundle/Background_5583.jsx

@@ -0,0 +1,10 @@
+// Metro module 5583 (f5584).
+import { View } from "react-native";
+import { useTheme } from "./Module1481";
+export default function Background(props) {
+  const { style, ...rest } = props;
+  return <View {...rest} style={[{
+    flex: 1,
+    backgroundColor: useTheme().colors.background
+  }, style]} />;
+};

_bundle/Backoff.js

@@ -0,0 +1,74 @@
+// Metro module 584 (f585).
+class Backoff {
+  constructor(min = 500, max = null, jitter = true) {
+    const prototype = new.target.prototype;
+    if (min <= 0) {
+      throw Error("Backoff min value must be greater than zero or backoff will never back-off.");
+    }
+    const r8 = {
+      __proto__: prototype,
+      _fails: 0
+    };
+    r8.min = min;
+    if (max == null) {
+      max = 10 * min;
+    }
+    r8.max = max;
+    r8.jitter = jitter;
+    r8._current = min;
+    return r8;
+  }
+  get fails() {
+    return this._fails;
+  }
+  get current() {
+    return this._current;
+  }
+  get pending() {
+    return this._timeoutId != null;
+  }
+  succeed() {
+    this.cancel();
+    this._fails = 0;
+    this._current = this.min;
+  }
+  fail(a0, a1) {
+    this._fails = this._fails + 1;
+    const r1 = 2 * this._current;
+    const r19 = this.jitter ? r1 * Math.random() : r1;
+    let r23 = a1;
+    this._current = Math.min(this._current + r19, this.max);
+    if (!(a1 != null && a1 > this._current)) {
+      r23 = this._current;
+    }
+    if (a0 != null) {
+      if (this._timeoutId != null) {
+        if (this._callback !== a0) {
+          throw new Error("callback already pending");
+        }
+        this.cancel();
+      }
+      this._callback = a0;
+      this._timeoutId = setTimeout(() => {
+        try {
+          if (a0 != null) {
+            a0();
+          }
+        } catch (r9) {
+          this.cancel();
+          throw r9;
+        }
+        this.cancel();
+      }, r23);
+    }
+    return r23;
+  }
+  cancel() {
+    this._callback = null;
+    if (this._timeoutId != null) {
+      clearTimeout(this._timeoutId);
+      this._timeoutId = null;
+    }
+  }
+}
+export default Backoff;

_bundle/BaseAnimationBuilder.js

@@ -0,0 +1,152 @@
+// Metro module 1677 (f1678).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import { ReduceMotion } from "./Module1631";
+import { ReanimatedError } from "./Module1617";
+import * as _Module1678 from "./Module1678";
+import * as _recognizePrefixSuffix from "./recognizePrefixSuffix";
+let env1321 = {};
+const c1321_3 = {
+  code: "function pnpm_BaseAnimationBuilderTs1(delay,animation){const{withDelay,reduceMotion}=this.__closure;return withDelay(delay,animation,reduceMotion);}"
+};
+const c1321_4 = {
+  code: "function pnpm_BaseAnimationBuilderTs2(_,animation){const{getReduceMotionFromConfig,reduceMotion}=this.__closure;animation.reduceMotion=getReduceMotionFromConfig(reduceMotion);return animation;}"
+};
+const BaseAnimationBuilder = function BaseAnimationBuilder() {
+  _classCallCheck(this, BaseAnimationBuilder);
+  this.reduceMotionV = ReduceMotion.System;
+  this.randomizeDelay = false;
+  this.build = () => {
+    throw new ReanimatedError("Unimplemented method in child class.");
+  };
+};
+exports.BaseAnimationBuilder = _createClass(BaseAnimationBuilder, [{
+  key: "duration",
+  value: function duration(a0) {
+    this.durationV = a0;
+    return this;
+  }
+}, {
+  key: "delay",
+  value: function delay(a0) {
+    this.delayV = a0;
+    return this;
+  }
+}, {
+  key: "withCallback",
+  value: function withCallback(a0) {
+    this.callbackV = a0;
+    return this;
+  }
+}, {
+  key: "reduceMotion",
+  value: function reduceMotion(a0) {
+    this.reduceMotionV = a0;
+    return this;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 300;
+    }
+    return durationV;
+  }
+}, {
+  key: "randomDelay",
+  value: function randomDelay() {
+    this.randomizeDelay = true;
+    return this;
+  }
+}, {
+  key: "getDelay",
+  value: function getDelay() {
+    let r6;
+    if (this.randomizeDelay) {
+      const r8 = Math.random();
+      let delayV = this.delayV;
+      if (delayV == null) {
+        delayV = 1000;
+      }
+      r6 = r8 * delayV;
+    } else {
+      r6 = this.delayV;
+      if (r6 == null) {
+        r6 = 0;
+      }
+    }
+    return r6;
+  }
+}, {
+  key: "getReduceMotion",
+  value: function getReduceMotion() {
+    return this.reduceMotionV;
+  }
+}, {
+  key: "getDelayFunction",
+  value: function getDelayFunction() {
+    let r10;
+    const r2 = this.randomizeDelay || this.delayV;
+    const reduceMotion2 = this.getReduceMotion();
+    if (r2) {
+      const n = function n(a0, a1) {
+        return _Module1678.withDelay(a0, a1, reduceMotion2);
+      };
+      n.__closure = {
+        withDelay: _Module1678.withDelay,
+        reduceMotion: reduceMotion2
+      };
+      n.__workletHash = 15544853359686;
+      n.__initData = c1321_3;
+      r10 = n;
+    } else {
+      r10 = function t(a0, a1) {
+        a1.reduceMotion = _recognizePrefixSuffix.getReduceMotionFromConfig(reduceMotion2);
+        return a1;
+      };
+      r10.__closure = {
+        getReduceMotionFromConfig: _recognizePrefixSuffix.getReduceMotionFromConfig,
+        reduceMotion: reduceMotion2
+      };
+      r10.__workletHash = 8417033392474;
+      r10.__initData = c1321_4;
+    }
+    return r10;
+  }
+}], [{
+  key: "duration",
+  value: function duration(a0) {
+    return this.createInstance().duration(a0);
+  }
+}, {
+  key: "delay",
+  value: function delay(a0) {
+    return this.createInstance().delay(a0);
+  }
+}, {
+  key: "withCallback",
+  value: function withCallback(a0) {
+    return this.createInstance().withCallback(a0);
+  }
+}, {
+  key: "reduceMotion",
+  value: function reduceMotion(a0) {
+    return this.createInstance().reduceMotion(a0);
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 300;
+  }
+}, {
+  key: "randomDelay",
+  value: function randomDelay() {
+    return this.createInstance().randomDelay();
+  }
+}, {
+  key: "build",
+  value: function build() {
+    return this.createInstance().build();
+  }
+}]);

_bundle/BinTree.js

@@ -0,0 +1,112 @@
+// Metro module 6033 (f6034).
+import * as _TreeBase from "./TreeBase";
+const Node2 = function(a0) {
+  this.data = a0;
+  this.left = null;
+  this.right = null;
+};
+const BinTree = function BinTree(a0) {
+  this._root = null;
+  this._comparator = a0;
+  this.size = 0;
+};
+Node2.prototype.get_child = function(a0) {
+  return a0 ? this.right : this.left;
+};
+Node2.prototype.set_child = function(a0, a1) {
+  if (a0) {
+    this.right = a1;
+  } else {
+    this.left = a1;
+  }
+};
+BinTree.prototype = new _TreeBase();
+BinTree.prototype.insert = function(a0) {
+  if (this._root === null) {
+    const _root2 = {
+      __proto__: Node2.prototype
+    };
+    _root2.data = a0;
+    _root2.left = null;
+    _root2.right = null;
+    this._root = _root2;
+    this.size = this.size + 1;
+    return true;
+  }
+  let _root = this._root;
+  let r14 = null;
+  let r1 = 0;
+  while (true) {
+    const r11 = _root;
+    const r10 = r14;
+    const r3 = r1;
+    if (r11 === null) {
+      const r23 = {
+        __proto__: Node2.prototype
+      };
+      r23.data = a0;
+      r23.left = null;
+      r23.right = null;
+      r10.set_child(r3, r23);
+      globalThis.ret = true;
+      this.size = this.size + 1;
+      return true;
+    }
+    if (this._comparator(r11.data, a0) === 0) {
+      return false;
+    }
+    const r2 = this._comparator(r11.data, a0) < 0;
+    _root = r11.get_child(r2);
+    r14 = r11;
+    r1 = r2;
+  }
+};
+BinTree.prototype.remove = function(a0) {
+  let r29;
+  if (this._root === null) {
+    return false;
+  }
+  const r19 = {
+    __proto__: Node2.prototype
+  };
+  r19.data = void 0;
+  r19.left = null;
+  r19.right = null;
+  r19.right = this._root;
+  const r22 = r19.get_child(1);
+  let r23 = 1;
+  let r12 = null;
+  let r10 = r19;
+  let r8 = null;
+  let r11 = r10;
+  let r9 = null;
+  if (r22 !== null) {
+    do {
+      const r14 = r10.get_child(r23);
+      const r26 = this._comparator(a0, r14.data);
+      const r3 = r26 > 0;
+      let r16 = r12;
+      const r27 = r10;
+      if (r26 === 0) {
+        r16 = r14;
+      }
+      r29 = r14.get_child(r3);
+      r12 = r16;
+      r23 = r3;
+      r10 = r14;
+      r8 = r12;
+      r9 = r27;
+      r11 = r10;
+    } while (r29 !== null);
+  }
+  let r30 = r8 !== null;
+  if (r30) {
+    r8.data = r11.data;
+    r9.set_child(r9.right === r11, r11.get_child(r11.left === null));
+    this._root = r19.right;
+    this.size = this.size - 1;
+    r30 = true;
+  }
+  return r30;
+};
+module.exports = BinTree;

_bundle/BinaryReader.js

@@ -0,0 +1,192 @@
+// Metro module 1312 (f1313).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+import { varint64read, varint32read } from "./Module1313";
+import { WireType } from "./is";
+import { PbLong, PbULong } from "./SharedPbLong";
+let c1080_5;
+let BinaryReader;
+let env1080 = {};
+const c1080_4 = {
+  readUnknownField: true,
+  readerFactory: (a0) => new c1080_5(a0)
+};
+export function binaryReadOptions(a0) {
+  return a0 ? {
+    ...c1080_4,
+    ...a0
+  } : c1080_4;
+}
+BinaryReader = function BinaryReader(a0, a1) {
+  let textDecoder = a1;
+  _classCallCheck(this, BinaryReader);
+  this.varint64 = varint64read;
+  this.uint32 = varint32read;
+  this.buf = a0;
+  this.len = a0.length;
+  this.pos = 0;
+  this.view = new DataView(a0.buffer, a0.byteOffset, a0.byteLength);
+  if (a1 == null) {
+    textDecoder = new TextDecoder("utf-8", {
+      fatal: true,
+      ignoreBOM: true
+    });
+  }
+  this.textDecoder = textDecoder;
+};
+c1080_5 = __createClass(BinaryReader, [{
+  key: "tag",
+  value: function tag() {
+    const r9 = this.uint32();
+    const r2 = r9 >>> 3;
+    const r11 = 7 & r9;
+    if (!(r2 <= 0) && !(r11 < 0) && !(5 < r11)) {
+      return [r2, r11];
+    }
+    throw new Error("illegal tag: field no " + r2 + " wire type " + r11);
+  }
+}, {
+  key: "skip",
+  value: function skip(a0) {
+    let r72, buf2, pos;
+    L14: {
+      pos = this.pos;
+      if (WireType.Varint === a0) {
+        const buf = this.buf;
+        const r66 = +this.pos;
+        this.pos = r66 + 1;
+        if (128 & buf[r66]) {
+          do {
+            buf2 = this.buf;
+            r72 = +this.pos;
+            this.pos = r72 + 1;
+          } while (128 & buf2[r72]);
+        }
+      } else {
+        if (WireType.Bit64 === a0) {
+          this.pos = this.pos + 4;
+        } else if (WireType.Bit32 !== a0) {
+          if (WireType.LengthDelimited === a0) {
+            this.pos = this.pos + this.uint32();
+            break L14;
+          }
+          if (WireType.StartGroup !== a0) {
+            throw new Error("cant skip wire type " + a0);
+          }
+          let r40 = this.tag()[1];
+          if (r40 === WireType.EndGroup) {
+            break L14;
+          }
+          while (true) {
+            this.skip(r40);
+            r40 = this.tag()[1];
+            if (r40 === WireType.EndGroup) {
+              break L14;
+            }
+          }
+        }
+        this.pos = this.pos + 4;
+      }
+    }
+    this.assertBounds();
+    return this.buf.subarray(pos, this.pos);
+  }
+}, {
+  key: "assertBounds",
+  value: function assertBounds() {
+    if (this.pos > this.len) {
+      throw new RangeError("premature EOF");
+    }
+  }
+}, {
+  key: "int32",
+  value: function int32() {
+    return this.uint32() | 0;
+  }
+}, {
+  key: "sint32",
+  value: function sint32() {
+    const r4 = this.uint32();
+    return r4 >>> 1 ^ -(1 & r4);
+  }
+}, {
+  key: "int64",
+  value: function int64() {
+    return new PbLong(...[...this.varint64()]);
+  }
+}, {
+  key: "uint64",
+  value: function uint64() {
+    return new PbULong(...[...this.varint64()]);
+  }
+}, {
+  key: "sint64",
+  value: function sint64() {
+    const [r15, r16] = this.varint64();
+    const r2 = -(1 & r15);
+    return new PbLong((r15 >>> 1 | (1 & r16) << 31) ^ r2, r16 >>> 1 ^ r2);
+  }
+}, {
+  key: "bool",
+  value: function bool() {
+    const [r9, r10] = this.varint64();
+    return r9 !== 0 || r10 !== 0;
+  }
+}, {
+  key: "fixed32",
+  value: function fixed32() {
+    const view = this.view;
+    const pos = this.pos + 4;
+    this.pos = pos;
+    return view.getUint32(pos - 4, true);
+  }
+}, {
+  key: "sfixed32",
+  value: function sfixed32() {
+    const view = this.view;
+    const pos = this.pos + 4;
+    this.pos = pos;
+    return view.getInt32(pos - 4, true);
+  }
+}, {
+  key: "fixed64",
+  value: function fixed64() {
+    return new PbULong(this.sfixed32(), this.sfixed32());
+  }
+}, {
+  key: "sfixed64",
+  value: function sfixed64() {
+    return new PbLong(this.sfixed32(), this.sfixed32());
+  }
+}, {
+  key: "float",
+  value: function float() {
+    const view = this.view;
+    const pos = this.pos + 4;
+    this.pos = pos;
+    return view.getFloat32(pos - 4, true);
+  }
+}, {
+  key: "double",
+  value: function double() {
+    const view = this.view;
+    const pos = this.pos + 8;
+    this.pos = pos;
+    return view.getFloat64(pos - 8, true);
+  }
+}, {
+  key: "bytes",
+  value: function bytes() {
+    const r4 = this.uint32();
+    const pos = this.pos;
+    this.pos = this.pos + r4;
+    this.assertBounds();
+    return this.buf.subarray(pos, pos + r4);
+  }
+}, {
+  key: "string",
+  value: function string() {
+    return this.textDecoder.decode(this.bytes());
+  }
+}]);
+export { c1080_5 as BinaryReader };

_bundle/BinaryWriter.js

@@ -0,0 +1,224 @@
+// Metro module 1315 (f1316).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+import { assertUInt32, assertInt32, assertFloat32 } from "./Module1316";
+import { varint32write, varint64write } from "./Module1313";
+import { PbLong, PbULong } from "./SharedPbLong";
+let c1087_4;
+let BinaryWriter;
+let env1087 = {};
+const c1087_3 = {
+  writeUnknownFields: true,
+  writerFactory: () => new c1087_4()
+};
+export function binaryWriteOptions(a0) {
+  return a0 ? {
+    ...c1087_3,
+    ...a0
+  } : c1087_3;
+}
+BinaryWriter = function BinaryWriter(a0) {
+  let textEncoder = a0;
+  _classCallCheck(this, BinaryWriter);
+  this.stack = [];
+  if (a0 == null) {
+    textEncoder = new TextEncoder();
+  }
+  this.textEncoder = textEncoder;
+  this.chunks = [];
+  this.buf = [];
+};
+c1087_4 = __createClass(BinaryWriter, [{
+  key: "finish",
+  value: function finish() {
+    let length;
+    this.chunks.push(new Uint8Array(this.buf));
+    const r4 = 0 < this.chunks.length;
+    let r0 = 0;
+    let r19 = 0;
+    let r20 = 0;
+    if (r4) {
+      do {
+        r19 = r19 + this.chunks[r0].length;
+        r0 = r0 + 1;
+        length = this.chunks.length;
+        r20 = r19;
+      } while (r0 < length);
+    }
+    const uint8Array = new Uint8Array(r20);
+    const r34 = 0 < this.chunks.length;
+    let r35 = 0;
+    let r36 = 0;
+    if (r34) {
+      do {
+        uint8Array.set(this.chunks[r35], r36);
+        r36 = r36 + this.chunks[r35].length;
+        r35 = r35 + 1;
+      } while (r35 < this.chunks.length);
+    }
+    this.chunks = [];
+    return uint8Array;
+  }
+}, {
+  key: "fork",
+  value: function fork() {
+    this.stack.push({
+      chunks: this.chunks,
+      buf: this.buf
+    });
+    this.chunks = [];
+    this.buf = [];
+    return this;
+  }
+}, {
+  key: "join",
+  value: function join() {
+    const r1 = this.finish();
+    const r9 = this.stack.pop();
+    if (r9) {
+      this.chunks = r9.chunks;
+      this.buf = r9.buf;
+      this.uint32(r1.byteLength);
+      return this.raw(r1);
+    }
+    throw new Error("invalid state, fork stack empty");
+  }
+}, {
+  key: "tag",
+  value: function tag(a0, a1) {
+    return this.uint32((a0 << 3 | a1) >>> 0);
+  }
+}, {
+  key: "raw",
+  value: function raw(a0) {
+    if (this.buf.length) {
+      this.chunks.push(new Uint8Array(this.buf));
+      this.buf = [];
+    }
+    this.chunks.push(a0);
+    return this;
+  }
+}, {
+  key: "uint32",
+  value: function uint32(a0) {
+    assertUInt32(a0);
+    let r15 = a0;
+    let r16 = a0;
+    if (a0 > 127) {
+      do {
+        this.buf.push(127 & r15 | 128);
+        r15 = r15 >>> 7;
+        r16 = r15;
+      } while (127 < r16);
+    }
+    this.buf.push(r16);
+    return this;
+  }
+}, {
+  key: "int32",
+  value: function int32(a0) {
+    assertInt32(a0);
+    varint32write(a0, this.buf);
+    return this;
+  }
+}, {
+  key: "bool",
+  value: function bool(a0) {
+    this.buf.push(a0 ? 1 : 0);
+    return this;
+  }
+}, {
+  key: "bytes",
+  value: function bytes(a0) {
+    this.uint32(a0.byteLength);
+    return this.raw(a0);
+  }
+}, {
+  key: "string",
+  value: function string(a0) {
+    const r4 = this.textEncoder.encode(a0);
+    this.uint32(r4.byteLength);
+    return this.raw(r4);
+  }
+}, {
+  key: "float",
+  value: function float(a0) {
+    assertFloat32(a0);
+    const uint8Array = new Uint8Array(4);
+    new DataView(uint8Array.buffer).setFloat32(0, a0, true);
+    return this.raw(uint8Array);
+  }
+}, {
+  key: "double",
+  value: function double(a0) {
+    const uint8Array = new Uint8Array(8);
+    new DataView(uint8Array.buffer).setFloat64(0, a0, true);
+    return this.raw(uint8Array);
+  }
+}, {
+  key: "fixed32",
+  value: function fixed32(a0) {
+    assertUInt32(a0);
+    const uint8Array = new Uint8Array(4);
+    new DataView(uint8Array.buffer).setUint32(0, a0, true);
+    return this.raw(uint8Array);
+  }
+}, {
+  key: "sfixed32",
+  value: function sfixed32(a0) {
+    assertInt32(a0);
+    const uint8Array = new Uint8Array(4);
+    new DataView(uint8Array.buffer).setInt32(0, a0, true);
+    return this.raw(uint8Array);
+  }
+}, {
+  key: "sint32",
+  value: function sint32(a0) {
+    assertInt32(a0);
+    varint32write((a0 << 1 ^ a0 >> 31) >>> 0, this.buf);
+    return this;
+  }
+}, {
+  key: "sfixed64",
+  value: function sfixed64(a0) {
+    const uint8Array = new Uint8Array(8);
+    const dataView = new DataView(uint8Array.buffer);
+    const r26 = PbLong.from(a0);
+    dataView.setInt32(0, r26.lo, true);
+    dataView.setInt32(4, r26.hi, true);
+    return this.raw(uint8Array);
+  }
+}, {
+  key: "fixed64",
+  value: function fixed64(a0) {
+    const uint8Array = new Uint8Array(8);
+    const dataView = new DataView(uint8Array.buffer);
+    const r26 = PbULong.from(a0);
+    dataView.setInt32(0, r26.lo, true);
+    dataView.setInt32(4, r26.hi, true);
+    return this.raw(uint8Array);
+  }
+}, {
+  key: "int64",
+  value: function int64(a0) {
+    const r10 = PbLong.from(a0);
+    varint64write(r10.lo, r10.hi, this.buf);
+    return this;
+  }
+}, {
+  key: "sint64",
+  value: function sint64(a0) {
+    const r14 = PbLong.from(a0);
+    const r3 = r14.hi >> 31;
+    varint64write(r14.lo << 1 ^ r3, (r14.hi << 1 | r14.lo >>> 31) ^ r3, this.buf);
+    return this;
+  }
+}, {
+  key: "uint64",
+  value: function uint64(a0) {
+    const r10 = PbULong.from(a0);
+    varint64write(r10.lo, r10.hi, this.buf);
+    return this;
+  }
+}]);
+export { c1087_4 as BinaryWriter };

_bundle/Blob.js

@@ -0,0 +1,69 @@
+// Metro module 203 (f204).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import * as _BlobManager from "./BlobManager";
+let env220 = {};
+const Blob2 = function(r5 = []) {
+  _classCallCheck(this, Blob2);
+  this.data = _BlobManager.default.createFromParts(r5, arguments[1]).data;
+};
+export default _createClass(Blob2, [{
+  key: "data",
+  get: function get() {
+    if (this._data) {
+      return this._data;
+    }
+    throw new Error("Blob has been closed and is no longer available");
+  },
+  set: function set(a0) {
+    this._data = a0;
+  }
+}, {
+  key: "slice",
+  value: function slice(a0, a1, type = "") {
+    let r10 = a0;
+    const data = this.data;
+    const { offset, size } = data;
+    let size2 = size;
+    let offset2 = offset;
+    if (typeof a0 === "number") {
+      if (a0 > size) {
+        r10 = size;
+      }
+      const r19 = offset + r10;
+      let r20 = size - r10;
+      if (typeof a1 === "number") {
+        let r9 = a1 < 0 ? this.size + a1 : a1;
+        if (r9 > this.size) {
+          r9 = this.size;
+        }
+        r20 = r9 - r10;
+      }
+      size2 = r20;
+      offset2 = r19;
+    }
+    return _BlobManager.default.createFromOptions({
+      blobId: this.data.blobId,
+      offset: offset2,
+      size: size2,
+      type,
+      __collector: this.data.__collector
+    });
+  }
+}, {
+  key: "close",
+  value: function close() {
+    _BlobManager.default.release(this.data.blobId);
+    this.data = null;
+  }
+}, {
+  key: "size",
+  get: function get() {
+    return this.data.size;
+  }
+}, {
+  key: "type",
+  get: function get() {
+    return this.data.type || "";
+  }
+}]);

_bundle/BlobManager.js

@@ -0,0 +1,96 @@
+// Metro module 200 (f201).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import Module38 from "./Module38";
+import Module201 from "./Module201";
+import * as _Blob from "./Blob";
+import { register, unregister, has } from "./Module204";
+let env217 = {};
+const BlobManager = function BlobManager() {
+  _classCallCheck(this, BlobManager);
+};
+const r35 = _createClass(BlobManager, null, [{
+  key: "createFromParts",
+  value: function createFromParts(a0, a1) {
+    Module38(Module201, "NativeBlobModule is available.");
+    const blobId = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (a0) => {
+      const r2 = 16 * Math.random() | 0;
+      return (a0 != "x" ? 3 & r2 | 8 : r2).toString(16);
+    });
+    const r20 = a0.map((item) => {
+      if (!(item instanceof ArrayBuffer) && !ArrayBuffer.isView(item)) {
+        return item instanceof _Blob.default ? {
+          data: item.data,
+          type: "blob"
+        } : {
+          data: String(item),
+          type: "string"
+        };
+      }
+      throw new Error("Creating blobs from 'ArrayBuffer' and 'ArrayBufferView' are not supported");
+    });
+    const size = r20.reduce((acc, item) => item.type === "string" ? acc + global.unescape(encodeURI(item.data)).length : acc + item.data.size, 0);
+    Module201.createFromParts(r20, blobId);
+    return BlobManager.createFromOptions({
+      blobId,
+      offset: 0,
+      size,
+      type: a1 ? a1.type : "",
+      lastModified: a1 ? a1.lastModified : Date.now()
+    });
+  }
+}, {
+  key: "createFromOptions",
+  value: function createFromOptions(a0) {
+    register(a0.blobId);
+    const r15 = Object;
+    const r22 = Object.create(_Blob.default.prototype);
+    const __collector = a0.__collector;
+    let data = a0;
+    if (__collector == null) {
+      const blobId = a0.blobId;
+      data = {
+        ...a0,
+        __collector: global.__blobCollectorProvider == null ? null : global.__blobCollectorProvider(blobId)
+      };
+    }
+    return r15.assign(r22, {
+      data
+    });
+  }
+}, {
+  key: "release",
+  value: function release(a0) {
+    Module38(Module201, "NativeBlobModule is available.");
+    unregister(a0);
+    if (!has(a0)) {
+      Module201.release(a0);
+    }
+  }
+}, {
+  key: "addNetworkingHandler",
+  value: function addNetworkingHandler() {
+    Module38(Module201, "NativeBlobModule is available.");
+    Module201.addNetworkingHandler();
+  }
+}, {
+  key: "addWebSocketHandler",
+  value: function addWebSocketHandler(a0) {
+    Module38(Module201, "NativeBlobModule is available.");
+    Module201.addWebSocketHandler(a0);
+  }
+}, {
+  key: "removeWebSocketHandler",
+  value: function removeWebSocketHandler(a0) {
+    Module38(Module201, "NativeBlobModule is available.");
+    Module201.removeWebSocketHandler(a0);
+  }
+}, {
+  key: "sendOverSocket",
+  value: function sendOverSocket(a0, a1) {
+    Module38(Module201, "NativeBlobModule is available.");
+    Module201.sendOverSocket(a0.data, a1);
+  }
+}]);
+r35.isAvailable = !!Module201;
+export default r35;

_bundle/BoostThisServerRiveInner.jsx

@@ -0,0 +1,55 @@
+// Metro module 3917 (f3918).
+import { forwardRef, useCallback } from "react";
+import { useBooleanBinding, BaseRive } from "./Module3918";
+import Module3968 from "./Module3968";
+import { RiveErrorBoundary } from "./Module3969";
+let BoostThisServerRiveInner;
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance", "dataBinding", "onDataBindingChange"];
+const artboardProperties = {
+  "Boost Server": {
+    reducedMotion: "boolean"
+  },
+  "Boost Crystal": {
+    reducedMotion: "boolean"
+  },
+  "Crystal Side B": {},
+  "Crystal Side A": {},
+  "Boost Saved": {
+    reducedMotion: "boolean"
+  }
+};
+const artboardViewModelInstances = {
+  "Boost Server": ["Instance"],
+  "Boost Crystal": ["Instance"],
+  "Crystal Side B": [],
+  "Crystal Side A": [],
+  "Boost Saved": ["Instance"]
+};
+let c2228_9 = {
+  "Boost Server": function BoostServerBindings(a0) {
+    useBooleanBinding("reducedMotion", a0.instance, a0.reducedMotionEnabled, void 0, a0.playIfNeeded);
+    return null;
+  },
+  "Boost Crystal": function BoostCrystalBindings(a0) {
+    useBooleanBinding("reducedMotion", a0.instance, a0.reducedMotionEnabled, void 0, a0.playIfNeeded);
+    return null;
+  },
+  "Boost Saved": function BoostSavedBindings(a0) {
+    useBooleanBinding("reducedMotion", a0.instance, a0.reducedMotionEnabled, void 0, a0.playIfNeeded);
+    return null;
+  }
+};
+BoostThisServerRiveInner = forwardRef(function BoostThisServerRiveInner(props, a1) {
+  props.fallback;
+  const { artboard = "Boost Server", stateMachine, defaultViewModelInstance: defaultViewModelInstance2 = "Instance", dataBinding, onDataBindingChange, ...rest } = props;
+  return <BaseRive ref={a1} src={Module3968} artboard={artboard} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance2} stateMachine={stateMachine} renderDataBinding={useCallback((a0) => {
+    const Component = c2228_9[artboard];
+    return Component != null ? <Component {...a0} dataBinding={dataBinding} onDataBindingChange={onDataBindingChange} /> : null;
+  }, [artboard, dataBinding, onDataBindingChange])} {...rest} />;
+});
+const r42 = forwardRef(function BoostThisServerRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <BoostThisServerRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r42 as BoostThisServerRive };

_bundle/BottomSheetDraggableView.jsx

@@ -0,0 +1,48 @@
+// Metro module 5380 (f5381).
+import * as _Module19 from "react";
+import { useMemo } from "react";
+import { useBottomSheetInternal, useBottomSheetGestureHandlers } from "./Module5250";
+import { Gesture, GestureDetector } from "./Module5273";
+import { BottomSheetDraggableContext } from "./Module5257";
+import Module1606 from "./Module1606";
+const memo2 = _Module19.memo;
+const r22 = memo2(({ nativeGestureRef, refreshControlGestureRef, style, children, ...props }) => {
+  const bottomSheetInternal = useBottomSheetInternal();
+  const { enableContentPanningGesture, simultaneousHandlers, waitFor, activeOffsetX, activeOffsetY, failOffsetX, failOffsetY } = bottomSheetInternal;
+  const contentPanGestureHandler = useBottomSheetGestureHandlers().contentPanGestureHandler;
+  const memo = useMemo(() => {
+    const r1 = [];
+    if (nativeGestureRef) {
+      r1.push(nativeGestureRef);
+    }
+    if (refreshControlGestureRef) {
+      r1.push(refreshControlGestureRef);
+    }
+    if (simultaneousHandlers) {
+      const isArray = Array.isArray(simultaneousHandlers);
+      const push = r1.push;
+      if (isArray) {
+        push.apply(r1, [...simultaneousHandlers]);
+      } else {
+        push.call(r1, simultaneousHandlers);
+      }
+    }
+    return r1;
+  }, [simultaneousHandlers, nativeGestureRef, refreshControlGestureRef]);
+  const memo2 = useMemo(() => {
+    const r30 = Gesture.Pan().enabled(enableContentPanningGesture).shouldCancelWhenOutside(false).runOnJS(false).onStart(contentPanGestureHandler.handleOnStart).onChange(contentPanGestureHandler.handleOnChange).onEnd(contentPanGestureHandler.handleOnEnd).onFinalize(contentPanGestureHandler.handleOnFinalize);
+    const r32 = waitFor ? r30.requireExternalGestureToFail(waitFor) : r30;
+    const r35 = memo ? r32.simultaneousWithExternalGesture(memo) : r32;
+    const r38 = activeOffsetX ? r35.activeOffsetX(activeOffsetX) : r35;
+    const r41 = activeOffsetY ? r38.activeOffsetY(activeOffsetY) : r38;
+    const r44 = failOffsetX ? r41.failOffsetX(failOffsetX) : r41;
+    return failOffsetY ? r44.failOffsetY(failOffsetY) : r44;
+  }, [activeOffsetX, activeOffsetY, enableContentPanningGesture, failOffsetX, failOffsetY, memo, waitFor, contentPanGestureHandler.handleOnChange, contentPanGestureHandler.handleOnEnd, contentPanGestureHandler.handleOnFinalize, contentPanGestureHandler.handleOnStart]);
+  return <GestureDetector gesture={memo2}>
+    <BottomSheetDraggableContext.Provider value={memo2}>
+      <Module1606.View style={style} {...props}>{children}</Module1606.View>
+    </BottomSheetDraggableContext.Provider>
+  </GestureDetector>;
+});
+r22.displayName = "BottomSheetDraggableView";
+export default r22;

_bundle/BottomSheetFlatList.js

@@ -0,0 +1,9 @@
+// Metro module 5407 (f5408).
+import { memo } from "react";
+import { FlatList } from "react-native";
+import Module1606 from "./Module1606";
+import { createBottomSheetScrollableComponent } from "./Module5399";
+import { SCROLLABLE_TYPE } from "./Module5246";
+const r29 = memo(createBottomSheetScrollableComponent(SCROLLABLE_TYPE.FLATLIST, Module1606.createAnimatedComponent(FlatList)));
+r29.displayName = "BottomSheetFlatList";
+export default r29;

_bundle/BottomSheetHandle.jsx

@@ -0,0 +1,45 @@
+// Metro module 5386 (f5387).
+import { useMemo, memo } from "react";
+import { StyleSheet, View } from "react-native";
+import { DEFAULT_ACCESSIBLE, DEFAULT_ACCESSIBILITY_ROLE, DEFAULT_ACCESSIBILITY_LABEL, DEFAULT_ACCESSIBILITY_HINT } from "./Module5387";
+import { styles } from "./Module5388";
+const r27 = memo(function BottomSheetHandleComponent(props) {
+  const { style, indicatorStyle } = props;
+  let accessible = props.accessible;
+  if (accessible === void 0) {
+    accessible = DEFAULT_ACCESSIBLE;
+  }
+  let accessibilityRole = props.accessibilityRole;
+  if (accessibilityRole === void 0) {
+    accessibilityRole = DEFAULT_ACCESSIBILITY_ROLE;
+  }
+  let accessibilityLabel = props.accessibilityLabel;
+  if (accessibilityLabel === void 0) {
+    accessibilityLabel = DEFAULT_ACCESSIBILITY_LABEL;
+  }
+  let accessibilityHint = props.accessibilityHint;
+  if (accessibilityHint === void 0) {
+    accessibilityHint = DEFAULT_ACCESSIBILITY_HINT;
+  }
+  const children = props.children;
+  const memo = useMemo(() => [styles.container, StyleSheet.flatten(style)], [style]);
+  const memo2 = useMemo(() => [styles.indicator, StyleSheet.flatten(indicatorStyle)], [indicatorStyle]);
+  if (accessible == null) {
+    accessible = void 0;
+  }
+  if (accessibilityRole == null) {
+    accessibilityRole = void 0;
+  }
+  if (accessibilityLabel == null) {
+    accessibilityLabel = void 0;
+  }
+  if (accessibilityHint == null) {
+    accessibilityHint = void 0;
+  }
+  return <View style={memo} accessible={accessible} accessibilityRole={accessibilityRole} accessibilityLabel={accessibilityLabel} accessibilityHint={accessibilityHint} collapsable>
+    <View style={memo2} />
+    {children}
+  </View>;
+});
+r27.displayName = "BottomSheetHandle";
+export default r27;

_bundle/BottomSheetHandleContainer.jsx

@@ -0,0 +1,61 @@
+// Metro module 5389 (f5390).
+import * as _Module19 from "react";
+import { useCallback, useMemo, useRef } from "react";
+import * as _Module5249 from "./Module5249";
+import { useBottomSheetInternal, useBottomSheetGestureHandlers, useBoundingClientRect } from "./Module5250";
+import { Gesture, GestureDetector } from "./Module5273";
+import BottomSheetHandle from "./BottomSheetHandle";
+import Module1606 from "./Module1606";
+const memo2 = _Module19.memo;
+const r24 = memo2(function BottomSheetHandleContainerComponent(props) {
+  const { animatedIndex, animatedPosition, simultaneousHandlers, enableHandlePanningGesture = _Module5249.DEFAULT_ENABLE_HANDLE_PANNING_GESTURE } = props;
+  const DEFAULT_ENABLE_HANDLE_PANNING_GESTURE = enableHandlePanningGesture;
+  const handleHeight = props.handleHeight;
+  let HandleComponent = props.handleComponent;
+  const { handleStyle, handleIndicatorStyle } = props;
+  const ref = useRef(null);
+  const bottomSheetInternal = useBottomSheetInternal();
+  const { activeOffsetX, activeOffsetY, failOffsetX, failOffsetY, waitFor, simultaneousHandlers: simultaneousHandlers2 } = bottomSheetInternal;
+  const handlePanGestureHandler = useBottomSheetGestureHandlers().handlePanGestureHandler;
+  const memo = useMemo(() => {
+    const r1 = [];
+    if (simultaneousHandlers) {
+      r1.push(simultaneousHandlers);
+    }
+    if (simultaneousHandlers2) {
+      const isArray = Array.isArray(simultaneousHandlers2);
+      const push = r1.push;
+      if (isArray) {
+        push.apply(r1, [...simultaneousHandlers2]);
+      } else {
+        push.call(r1, simultaneousHandlers2);
+      }
+    }
+    return r1;
+  }, [simultaneousHandlers2, simultaneousHandlers]);
+  const memo2 = useMemo(() => {
+    const r30 = Gesture.Pan().enabled(DEFAULT_ENABLE_HANDLE_PANNING_GESTURE).shouldCancelWhenOutside(false).runOnJS(false).onStart(handlePanGestureHandler.handleOnStart).onChange(handlePanGestureHandler.handleOnChange).onEnd(handlePanGestureHandler.handleOnEnd).onFinalize(handlePanGestureHandler.handleOnFinalize);
+    const r32 = waitFor ? r30.requireExternalGestureToFail(waitFor) : r30;
+    const r35 = memo ? r32.simultaneousWithExternalGesture(memo) : r32;
+    const r38 = activeOffsetX ? r35.activeOffsetX(activeOffsetX) : r35;
+    const r41 = activeOffsetY ? r38.activeOffsetY(activeOffsetY) : r38;
+    const r44 = failOffsetX ? r41.failOffsetX(failOffsetX) : r41;
+    return failOffsetY ? r44.failOffsetY(failOffsetY) : r44;
+  }, [activeOffsetX, activeOffsetY, DEFAULT_ENABLE_HANDLE_PANNING_GESTURE, failOffsetX, failOffsetY, memo, waitFor, handlePanGestureHandler.handleOnChange, handlePanGestureHandler.handleOnEnd, handlePanGestureHandler.handleOnFinalize, handlePanGestureHandler.handleOnStart]);
+  const callback = useCallback(function handleContainerLayout(a0) {
+    handleHeight.value = a0.nativeEvent.layout.height;
+  }, [handleHeight]);
+  useBoundingClientRect(ref, useCallback((a0) => {
+    handleHeight.value = a0.height;
+  }, [handleHeight]));
+  if (HandleComponent == null) {
+    HandleComponent = BottomSheetHandle;
+  }
+  return <GestureDetector gesture={memo2}>
+    <Module1606.View key="BottomSheetHandleContainer" ref={ref} onLayout={callback}>
+      <HandleComponent animatedIndex={animatedIndex} animatedPosition={animatedPosition} style={handleStyle} indicatorStyle={handleIndicatorStyle} />
+    </Module1606.View>
+  </GestureDetector>;
+});
+r24.displayName = "BottomSheetHandleContainer";
+export default r24;

_bundle/BottomSheetModal.jsx

@@ -0,0 +1,262 @@
+// Metro module 5391 (f5392).
+import _slicedToArray from "./_slicedToArray";
+import * as _Module19 from "react";
+import Module19, { createElement, useCallback, useImperativeHandle, useMemo, useRef, useState } from "react";
+import * as _Module5392 from "./Module5392";
+import { useBottomSheetModalInternal } from "./Module5250";
+import { usePortal, Portal } from "./Module4060";
+import { id } from "./Module5393";
+import { print } from "./Module5262";
+import Module5247 from "./Module5247";
+const _excluded = ["name", "stackBehavior", "enableDismissOnClose", "onDismiss", "onAnimate", "index", "snapPoints", "enablePanDownToClose", "animateOnMount", "containerComponent", "onChange", "children"];
+const { forwardRef, memo: memo2 } = _Module19;
+let c3292_14 = {
+  mount: false,
+  data: void 0
+};
+let c3292_15 = memo2(forwardRef(function BottomSheetModalComponent(props, a1) {
+  let callback, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, resetVariables2;
+  let c14842_0 = a1;
+  const { name, stackBehavior = _Module5392.DEFAULT_STACK_BEHAVIOR } = props;
+  const DEFAULT_STACK_BEHAVIOR = stackBehavior;
+  let enableDismissOnClose = props.enableDismissOnClose;
+  if (enableDismissOnClose === void 0) {
+    enableDismissOnClose = _Module5392.DEFAULT_ENABLE_DISMISS_ON_CLOSE;
+  }
+  const DEFAULT_ENABLE_DISMISS_ON_CLOSE = enableDismissOnClose;
+  const { onDismiss, onAnimate, index = 0, snapPoints, enablePanDownToClose = true, animateOnMount: animateOnMount2 = true, containerComponent: ContainerComponent = Module19.Fragment, onChange, children: Children, ...rest } = props;
+  const r54 = _slicedToArray(useState(c3292_14), 2);
+  const r55 = r54[0];
+  const { mount, data: data2 } = r55;
+  const setState = r54[1];
+  const bottomSheetModalInternal = useBottomSheetModalInternal();
+  const { hostName, containerHeight, containerOffset, mountSheet, unmountSheet, willUnmountSheet } = bottomSheetModalInternal;
+  const removePortal = usePortal(hostName).removePortal;
+  const ref = useRef(null);
+  const ref2 = useRef(animateOnMount2 ? -1 : index);
+  const ref3 = useRef(null);
+  const ref4 = useRef(-1);
+  const ref5 = useRef(false);
+  const ref6 = useRef(false);
+  const ref7 = useRef(false);
+  ref7.current = mount;
+  const memo = useMemo(() => {
+    let r5 = name;
+    if (!name) {
+      r5 = `bottom-sheet-modal-${id()}`;
+    }
+    return r5;
+  }, [name]);
+  resetVariables2 = function resetVariables() {
+    print({
+      component: c3292_15.name,
+      method: resetVariables2.name
+    });
+    ref2.current = -1;
+    ref4.current = -1;
+    ref5.current = false;
+    ref7.current = false;
+    ref6.current = false;
+  };
+  callback = useCallback(resetVariables2, []);
+  callback2 = useCallback(function unmount() {
+    const current = ref7.current;
+    callback();
+    unmountSheet(memo);
+    removePortal(memo);
+    if (current) {
+      setState(c3292_14);
+    }
+    if (onDismiss) {
+      onDismiss();
+    }
+  }, [memo, callback, unmountSheet, removePortal, onDismiss]);
+  callback3 = useCallback(function(...args) {
+    if (!ref5.current) {
+      const current = ref.current;
+      if (current != null) {
+        current.snapToIndex.apply(current, [...args]);
+      }
+    }
+  }, []);
+  callback4 = useCallback(function(...args) {
+    if (!ref5.current) {
+      const current = ref.current;
+      if (current != null) {
+        current.snapToPosition.apply(current, [...args]);
+      }
+    }
+  }, []);
+  callback5 = useCallback(function(...args) {
+    if (!ref5.current) {
+      const current = ref.current;
+      if (current != null) {
+        current.expand.apply(current, [...args]);
+      }
+    }
+  }, []);
+  callback6 = useCallback(function(...args) {
+    if (!ref5.current) {
+      const current = ref.current;
+      if (current != null) {
+        current.collapse.apply(current, [...args]);
+      }
+    }
+  }, []);
+  callback7 = useCallback(function(...args) {
+    if (!ref5.current) {
+      const current = ref.current;
+      if (current != null) {
+        current.close.apply(current, [...args]);
+      }
+    }
+  }, []);
+  callback8 = useCallback(function(...args) {
+    if (!ref5.current) {
+      const current = ref.current;
+      if (current != null) {
+        current.forceClose.apply(current, [...args]);
+      }
+    }
+  }, []);
+  callback9 = useCallback(function handlePresent(data) {
+    requestAnimationFrame(() => {
+      setState({
+        mount: true,
+        data
+      });
+      mountSheet(memo, c14842_0, DEFAULT_STACK_BEHAVIOR);
+    });
+  }, [memo, DEFAULT_STACK_BEHAVIOR, mountSheet]);
+  callback10 = useCallback(function handleDismiss(a0) {
+    const r2 = ref3.current != null;
+    const r1 = ref2.current !== -1 || ref5.current !== false || r2;
+    L12: {
+      if (r1) {
+        L10: {
+          if (!r2) {
+            if (!ref5.current) {
+              if (ref2.current !== -1) {
+                break L10;
+              }
+              if (!enablePanDownToClose) {
+                break L10;
+              }
+            }
+            callback2();
+            break L12;
+          }
+        }
+        willUnmountSheet(memo);
+        ref6.current = true;
+        const current = ref.current;
+        if (current != null) {
+          current.forceClose(a0);
+        }
+      }
+    }
+  }, [willUnmountSheet, callback2, memo, enablePanDownToClose]);
+  callback11 = useCallback(function handleMinimize() {
+    if (!ref5.current) {
+      ref5.current = true;
+      if (ref2.current === -1) {
+        ref4.current = index;
+      } else {
+        ref4.current = ref2.current;
+      }
+      const current = ref.current;
+      if (current != null) {
+        current.close();
+      }
+    }
+  }, [index]);
+  callback12 = useCallback(function handleRestore() {
+    if (ref5.current && !ref6.current) {
+      ref5.current = false;
+      const current = ref.current;
+      if (current != null) {
+        current.snapToIndex(ref4.current);
+      }
+    }
+  }, []);
+  const callback13 = useCallback(function handlePortalOnUnmount() {
+    if (!(ref2.current === -1 && ref5.current === false)) {
+      ref7.current = false;
+      ref6.current = true;
+      if (ref5.current) {
+        callback2();
+      } else {
+        willUnmountSheet(memo);
+        const current = ref.current;
+        if (current != null) {
+          current.close();
+        }
+      }
+    }
+  }, [memo, callback2, willUnmountSheet]);
+  const callback14 = useCallback(function handlePortalRender(a0) {
+    if (ref7.current) {
+      a0();
+    }
+  }, []);
+  const callback15 = useCallback(function handleBottomSheetOnChange(a0, a1, a2) {
+    ref2.current = a0;
+    ref3.current = null;
+    if (onChange) {
+      onChange(a0, a1, a2);
+    }
+  }, [onChange]);
+  const callback16 = useCallback((a0, a1, a2, a3, a4) => {
+    ref3.current = a1;
+    if (onAnimate) {
+      onAnimate(a0, a1, a2, a3, a4);
+    }
+  }, [onAnimate]);
+  const callback17 = useCallback(function handleBottomSheetOnClose() {
+    if (!ref5.current && DEFAULT_ENABLE_DISMISS_ON_CLOSE) {
+      callback2();
+    }
+  }, [DEFAULT_ENABLE_DISMISS_ON_CLOSE, callback2]);
+  useImperativeHandle(a1, () => ({
+    snapToIndex: callback3,
+    snapToPosition: callback4,
+    expand: callback5,
+    collapse: callback6,
+    close: callback7,
+    forceClose: callback8,
+    dismiss: callback10,
+    present: callback9,
+    minimize: callback11,
+    restore: callback12
+  }));
+  let r133 = null;
+  if (mount) {
+    const r143 = {
+      ...rest,
+      ref,
+      key: memo,
+      index,
+      snapPoints,
+      enablePanDownToClose,
+      animateOnMount: animateOnMount2,
+      containerHeight,
+      containerOffset,
+      onChange: callback15,
+      onClose: callback17,
+      onAnimate: callback16,
+      $modal: true
+    };
+    let r146 = Children;
+    if (typeof r146 === "function") {
+      r146 = <Children data={data2} />;
+    }
+    r133 = <Portal key={memo} name={memo} hostName={hostName} handleOnMount={callback14} handleOnUpdate={callback14} handleOnUnmount={callback13}>
+      <ContainerComponent key={memo}>
+        {createElement(Module5247, r143, r146)}
+      </ContainerComponent>
+    </Portal>;
+  }
+  return r133;
+}));
+c3292_15.displayName = "BottomSheetModal";
+export default c3292_15;

_bundle/BottomSheetRefreshControl.jsx

@@ -0,0 +1,44 @@
+// Metro module 5404 (f5405).
+import { useContext, useMemo, memo } from "react";
+import { RefreshControl } from "react-native";
+import Module1606, { useAnimatedProps } from "./Module1606";
+import { BottomSheetDraggableContext } from "./Module5257";
+import { useBottomSheetInternal } from "./Module5250";
+import * as _Module5246 from "./Module5246";
+import { Gesture, GestureDetector } from "./Module5273";
+const AnimatedComponent = Module1606.createAnimatedComponent(RefreshControl);
+const __initData = {
+  code: "function pnpm_BottomSheetRefreshControlAndroidTsx1(){const{animatedScrollableState,SCROLLABLE_STATE}=this.__closure;return{enabled:animatedScrollableState.value===SCROLLABLE_STATE.UNLOCKED};}"
+};
+const r31 = memo(function BottomSheetRefreshControlComponent(props) {
+  const { onRefresh, scrollableGesture, ...props2 } = props;
+  const context = useContext(BottomSheetDraggableContext);
+  const bottomSheetInternal = useBottomSheetInternal();
+  const { animatedScrollableState, enableContentPanningGesture } = bottomSheetInternal;
+  if (!context && enableContentPanningGesture) {
+    throw "'BottomSheetRefreshControl' cannot be used out of the BottomSheet!";
+  }
+  const f = () => ({
+    enabled: animatedScrollableState.value === _Module5246.SCROLLABLE_STATE.UNLOCKED
+  });
+  f.__closure = {
+    animatedScrollableState,
+    SCROLLABLE_STATE: _Module5246.SCROLLABLE_STATE
+  };
+  f.__workletHash = 8403038560398;
+  f.__initData = __initData;
+  const animatedProps = useAnimatedProps(f, [animatedScrollableState.value]);
+  const memo = useMemo(() => {
+    let r2 = void 0;
+    if (context) {
+      const r5 = Gesture.Native();
+      r2 = r5.simultaneousWithExternalGesture.apply(r5, [...context.toGestureArray(), ...scrollableGesture.toGestureArray()]).shouldCancelWhenOutside(true);
+    }
+    return r2;
+  }, [context, scrollableGesture]);
+  return memo ? <GestureDetector gesture={memo}>
+    <AnimatedComponent {...props2} onRefresh={onRefresh} animatedProps={animatedProps} />
+  </GestureDetector> : <AnimatedComponent {...props2} onRefresh={onRefresh} animatedProps={animatedProps} />;
+});
+r31.displayName = "BottomSheetRefreshControl";
+export default r31;

_bundle/BottomSheetScrollView.js

@@ -0,0 +1,9 @@
+// Metro module 5408 (f5409).
+import { memo } from "react";
+import { ScrollView } from "react-native";
+import Module1606 from "./Module1606";
+import { createBottomSheetScrollableComponent } from "./Module5399";
+import { SCROLLABLE_TYPE } from "./Module5246";
+const r29 = memo(createBottomSheetScrollableComponent(SCROLLABLE_TYPE.SCROLLVIEW, Module1606.createAnimatedComponent(ScrollView)));
+r29.displayName = "BottomSheetScrollView";
+export default r29;

_bundle/BottomSheetSectionList.js

@@ -0,0 +1,9 @@
+// Metro module 5406 (f5407).
+import { memo } from "react";
+import { SectionList } from "react-native";
+import Module1606 from "./Module1606";
+import { createBottomSheetScrollableComponent } from "./Module5399";
+import { SCROLLABLE_TYPE } from "./Module5246";
+const r29 = memo(createBottomSheetScrollableComponent(SCROLLABLE_TYPE.SECTIONLIST, Module1606.createAnimatedComponent(SectionList)));
+r29.displayName = "BottomSheetSectionList";
+export default r29;

_bundle/BottomSheetTextInput.jsx

@@ -0,0 +1,27 @@
+// Metro module 5490 (f5491).
+import * as _Module19 from "react";
+import { useCallback, useEffect } from "react";
+import { useBottomSheetInternal } from "./Module5250";
+import { TextInput } from "./Module5273";
+const { memo, forwardRef } = _Module19;
+const r25 = memo(forwardRef(({ onFocus, onBlur, ...props }, a1) => {
+  const shouldHandleKeyboardEvents = useBottomSheetInternal().shouldHandleKeyboardEvents;
+  const callback = useCallback((a0) => {
+    shouldHandleKeyboardEvents.value = true;
+    if (onFocus) {
+      onFocus(a0);
+    }
+  }, [onFocus, shouldHandleKeyboardEvents]);
+  const callback2 = useCallback((a0) => {
+    shouldHandleKeyboardEvents.value = false;
+    if (onBlur) {
+      onBlur(a0);
+    }
+  }, [onBlur, shouldHandleKeyboardEvents]);
+  useEffect(() => () => {
+    shouldHandleKeyboardEvents.value = false;
+  }, [shouldHandleKeyboardEvents]);
+  return <TextInput ref={a1} onFocus={callback} onBlur={callback2} {...props} />;
+}));
+r25.displayName = "BottomSheetTextInput";
+export default r25;

_bundle/BottomSheetView.jsx

@@ -0,0 +1,29 @@
+// Metro module 5487 (f5488).
+import { useCallback, useEffect, useMemo, memo } from "react";
+import { View } from "react-native";
+import { useBottomSheetInternal, useBottomSheetContentContainerStyle } from "./Module5250";
+import { styles } from "./Module5488";
+import { SCROLLABLE_TYPE } from "./Module5246";
+const r27 = memo(function BottomSheetViewComponent(props) {
+  const { focusHook = useEffect, enableFooterMarginAdjustment = false, onLayout, style, children, ...props2 } = props;
+  const bottomSheetInternal = useBottomSheetInternal();
+  const { animatedScrollableContentOffsetY, animatedScrollableType, enableDynamicSizing, animatedContentHeight } = bottomSheetInternal;
+  const bottomSheetContentContainerStyle = useBottomSheetContentContainerStyle(enableFooterMarginAdjustment, style);
+  const memo = useMemo(() => [bottomSheetContentContainerStyle, styles.container], [bottomSheetContentContainerStyle]);
+  const callback = useCallback(() => {
+    animatedScrollableContentOffsetY.value = 0;
+    animatedScrollableType.value = SCROLLABLE_TYPE.VIEW;
+  }, [animatedScrollableContentOffsetY, animatedScrollableType]);
+  const callback2 = useCallback((a0) => {
+    if (enableDynamicSizing) {
+      animatedContentHeight.set(a0.nativeEvent.layout.height);
+    }
+    if (onLayout) {
+      onLayout(a0);
+    }
+  }, [onLayout, animatedContentHeight, enableDynamicSizing]);
+  focusHook(callback);
+  return <View {...props2} onLayout={callback2} style={memo}>{children}</View>;
+});
+r27.displayName = "BottomSheetView";
+export default r27;

_bundle/BottomSheetVirtualizedList.js

@@ -0,0 +1,9 @@
+// Metro module 5409 (f5410).
+import { memo } from "react";
+import { VirtualizedList } from "react-native";
+import Module1606 from "./Module1606";
+import { createBottomSheetScrollableComponent } from "./Module5399";
+import { SCROLLABLE_TYPE } from "./Module5246";
+const r29 = memo(createBottomSheetScrollableComponent(SCROLLABLE_TYPE.VIRTUALIZEDLIST, Module1606.createAnimatedComponent(VirtualizedList)));
+r29.displayName = "BottomSheetVirtualizedList";
+export default r29;

_bundle/BounceIn.js

@@ -0,0 +1,821 @@
+// Metro module 1724 (f1725).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import * as _Module1678 from "./Module1678";
+import { ComplexAnimationBuilder } from "./Module1676";
+let c1365_6, c1365_7, c1365_8, c1365_9, c1365_10, c1365_11, c1365_12, c1365_13, c1365_14, c1365_15;
+let BounceIn;
+let BounceInDown;
+let BounceInUp;
+let BounceInLeft;
+let BounceInRight;
+let BounceOut;
+let BounceOutDown;
+let BounceOutUp;
+let BounceOutLeft;
+let BounceOutRight;
+let env1365 = {};
+env1365[5] = function _isNativeReflectConstruct() {
+  let c13180_0;
+  try {
+    c13180_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c13180_0;
+  };
+  env1365[5] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+c1365_6 = {
+  code: "function pnpm_BounceTs1(){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{scale:delayFunction(delay,withSequence(withTiming(1.2,{duration:duration*0.55}),withTiming(0.9,{duration:duration*0.15}),withTiming(1.1,{duration:duration*0.15}),withTiming(1,{duration:duration*0.15})))}]},initialValues:{transform:[{scale:0}],...initialValues},callback:callback};}"
+};
+BounceIn = function BounceIn(...args) {
+  _classCallCheck(this, BounceIn);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceIn);
+  const _this = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this.build = () => {
+    const delayFunction = _this.getDelayFunction();
+    const delay = _this.getDelay();
+    const duration = _this.getDuration();
+    const { callbackV, initialValues } = _this;
+    const r15 = function n() {
+      return {
+        animations: {
+          transform: [{
+            scale: delayFunction(delay, _Module1678.withSequence(_Module1678.withTiming(1.2, {
+              duration: 0.55 * duration
+            }), _Module1678.withTiming(0.9, {
+              duration: 0.15 * duration
+            }), _Module1678.withTiming(1.1, {
+              duration: 0.15 * duration
+            }), _Module1678.withTiming(1, {
+              duration: 0.15 * duration
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            scale: 0
+          }],
+          ...initialValues
+        },
+        callback: callbackV
+      };
+    };
+    r15.__closure = {
+      delayFunction,
+      delay,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration,
+      initialValues,
+      callback: callbackV
+    };
+    r15.__workletHash = 6814288411244;
+    r15.__initData = c1365_6;
+    return r15;
+  };
+  return _this;
+};
+_inherits(BounceIn, ComplexAnimationBuilder);
+const r11 = _createClass(BounceIn, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceIn.prototype
+    };
+    const r4 = BounceIn.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r11.presetName = "BounceIn";
+c1365_7 = {
+  code: "function pnpm_BounceTs2(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateY:delayFunction(delay,withSequence(withTiming(-20,{duration:duration*0.55}),withTiming(10,{duration:duration*0.15}),withTiming(-10,{duration:duration*0.15}),withTiming(0,{duration:duration*0.15})))}]},initialValues:{transform:[{translateY:values.windowHeight}],...initialValues},callback:callback};}"
+};
+BounceInDown = function BounceInDown(...args) {
+  _classCallCheck(this, BounceInDown);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceInDown);
+  const _this2 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this2.build = () => {
+    const delayFunction2 = _this2.getDelayFunction();
+    const delay2 = _this2.getDelay();
+    const duration2 = _this2.getDuration();
+    const { callbackV: callbackV2, initialValues: initialValues2 } = _this2;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateY: delayFunction2(delay2, _Module1678.withSequence(_Module1678.withTiming(-20, {
+              duration: 0.55 * duration2
+            }), _Module1678.withTiming(10, {
+              duration: 0.15 * duration2
+            }), _Module1678.withTiming(-10, {
+              duration: 0.15 * duration2
+            }), _Module1678.withTiming(0, {
+              duration: 0.15 * duration2
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateY: a0.windowHeight
+          }],
+          ...initialValues2
+        },
+        callback: callbackV2
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction2,
+      delay: delay2,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration2,
+      initialValues: initialValues2,
+      callback: callbackV2
+    };
+    r15.__workletHash = 4551292686981;
+    r15.__initData = c1365_7;
+    return r15;
+  };
+  return _this2;
+};
+_inherits(BounceInDown, ComplexAnimationBuilder);
+const r10 = _createClass(BounceInDown, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceInDown.prototype
+    };
+    const r4 = BounceInDown.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r10.presetName = "BounceInDown";
+c1365_8 = {
+  code: "function pnpm_BounceTs3(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateY:delayFunction(delay,withSequence(withTiming(20,{duration:duration*0.55}),withTiming(-10,{duration:duration*0.15}),withTiming(10,{duration:duration*0.15}),withTiming(0,{duration:duration*0.15})))}]},initialValues:{transform:[{translateY:-values.windowHeight}],...initialValues},callback:callback};}"
+};
+BounceInUp = function BounceInUp(...args) {
+  _classCallCheck(this, BounceInUp);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceInUp);
+  const _this3 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this3.build = () => {
+    const delayFunction3 = _this3.getDelayFunction();
+    const delay3 = _this3.getDelay();
+    const duration3 = _this3.getDuration();
+    const { callbackV: callbackV3, initialValues: initialValues3 } = _this3;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateY: delayFunction3(delay3, _Module1678.withSequence(_Module1678.withTiming(20, {
+              duration: 0.55 * duration3
+            }), _Module1678.withTiming(-10, {
+              duration: 0.15 * duration3
+            }), _Module1678.withTiming(10, {
+              duration: 0.15 * duration3
+            }), _Module1678.withTiming(0, {
+              duration: 0.15 * duration3
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateY: -a0.windowHeight
+          }],
+          ...initialValues3
+        },
+        callback: callbackV3
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction3,
+      delay: delay3,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration3,
+      initialValues: initialValues3,
+      callback: callbackV3
+    };
+    r15.__workletHash = 11333943352836;
+    r15.__initData = c1365_8;
+    return r15;
+  };
+  return _this3;
+};
+_inherits(BounceInUp, ComplexAnimationBuilder);
+const r9 = _createClass(BounceInUp, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceInUp.prototype
+    };
+    const r4 = BounceInUp.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r9.presetName = "BounceInUp";
+c1365_9 = {
+  code: "function pnpm_BounceTs4(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateX:delayFunction(delay,withSequence(withTiming(20,{duration:duration*0.55}),withTiming(-10,{duration:duration*0.15}),withTiming(10,{duration:duration*0.15}),withTiming(0,{duration:duration*0.15})))}]},initialValues:{transform:[{translateX:-values.windowWidth}],...initialValues},callback:callback};}"
+};
+BounceInLeft = function BounceInLeft(...args) {
+  _classCallCheck(this, BounceInLeft);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceInLeft);
+  const _this4 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this4.build = () => {
+    const delayFunction4 = _this4.getDelayFunction();
+    const delay4 = _this4.getDelay();
+    const duration4 = _this4.getDuration();
+    const { callbackV: callbackV4, initialValues: initialValues4 } = _this4;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateX: delayFunction4(delay4, _Module1678.withSequence(_Module1678.withTiming(20, {
+              duration: 0.55 * duration4
+            }), _Module1678.withTiming(-10, {
+              duration: 0.15 * duration4
+            }), _Module1678.withTiming(10, {
+              duration: 0.15 * duration4
+            }), _Module1678.withTiming(0, {
+              duration: 0.15 * duration4
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateX: -a0.windowWidth
+          }],
+          ...initialValues4
+        },
+        callback: callbackV4
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction4,
+      delay: delay4,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration4,
+      initialValues: initialValues4,
+      callback: callbackV4
+    };
+    r15.__workletHash = 10162410157050;
+    r15.__initData = c1365_9;
+    return r15;
+  };
+  return _this4;
+};
+_inherits(BounceInLeft, ComplexAnimationBuilder);
+const r8 = _createClass(BounceInLeft, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceInLeft.prototype
+    };
+    const r4 = BounceInLeft.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r8.presetName = "BounceInLeft";
+c1365_10 = {
+  code: "function pnpm_BounceTs5(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateX:delayFunction(delay,withSequence(withTiming(-20,{duration:duration*0.55}),withTiming(10,{duration:duration*0.15}),withTiming(-10,{duration:duration*0.15}),withTiming(0,{duration:duration*0.15})))}]},initialValues:{transform:[{translateX:values.windowWidth}],...initialValues},callback:callback};}"
+};
+BounceInRight = function BounceInRight(...args) {
+  _classCallCheck(this, BounceInRight);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceInRight);
+  const _this5 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this5.build = () => {
+    const delayFunction5 = _this5.getDelayFunction();
+    const delay5 = _this5.getDelay();
+    const duration5 = _this5.getDuration();
+    const { callbackV: callbackV5, initialValues: initialValues5 } = _this5;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateX: delayFunction5(delay5, _Module1678.withSequence(_Module1678.withTiming(-20, {
+              duration: 0.55 * duration5
+            }), _Module1678.withTiming(10, {
+              duration: 0.15 * duration5
+            }), _Module1678.withTiming(-10, {
+              duration: 0.15 * duration5
+            }), _Module1678.withTiming(0, {
+              duration: 0.15 * duration5
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateX: a0.windowWidth
+          }],
+          ...initialValues5
+        },
+        callback: callbackV5
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction5,
+      delay: delay5,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration5,
+      initialValues: initialValues5,
+      callback: callbackV5
+    };
+    r15.__workletHash = 4134237895259;
+    r15.__initData = c1365_10;
+    return r15;
+  };
+  return _this5;
+};
+_inherits(BounceInRight, ComplexAnimationBuilder);
+const r110 = _createClass(BounceInRight, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceInRight.prototype
+    };
+    const r4 = BounceInRight.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r110.presetName = "BounceInRight";
+c1365_11 = {
+  code: "function pnpm_BounceTs6(){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{scale:delayFunction(delay,withSequence(withTiming(1.1,{duration:duration*0.15}),withTiming(0.9,{duration:duration*0.15}),withTiming(1.2,{duration:duration*0.15}),withTiming(0,{duration:duration*0.55})))}]},initialValues:{transform:[{scale:1}],...initialValues},callback:callback};}"
+};
+BounceOut = function BounceOut(...args) {
+  _classCallCheck(this, BounceOut);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceOut);
+  const _this6 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this6.build = () => {
+    const delayFunction6 = _this6.getDelayFunction();
+    const delay6 = _this6.getDelay();
+    const duration6 = _this6.getDuration();
+    const { callbackV: callbackV6, initialValues: initialValues6 } = _this6;
+    const r15 = function n() {
+      return {
+        animations: {
+          transform: [{
+            scale: delayFunction6(delay6, _Module1678.withSequence(_Module1678.withTiming(1.1, {
+              duration: 0.15 * duration6
+            }), _Module1678.withTiming(0.9, {
+              duration: 0.15 * duration6
+            }), _Module1678.withTiming(1.2, {
+              duration: 0.15 * duration6
+            }), _Module1678.withTiming(0, {
+              duration: 0.55 * duration6
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            scale: 1
+          }],
+          ...initialValues6
+        },
+        callback: callbackV6
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction6,
+      delay: delay6,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration6,
+      initialValues: initialValues6,
+      callback: callbackV6
+    };
+    r15.__workletHash = 15864962046507;
+    r15.__initData = c1365_11;
+    return r15;
+  };
+  return _this6;
+};
+_inherits(BounceOut, ComplexAnimationBuilder);
+const r126 = _createClass(BounceOut, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceOut.prototype
+    };
+    const r4 = BounceOut.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r126.presetName = "BounceOut";
+c1365_12 = {
+  code: "function pnpm_BounceTs7(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateY:delayFunction(delay,withSequence(withTiming(-10,{duration:duration*0.15}),withTiming(10,{duration:duration*0.15}),withTiming(-20,{duration:duration*0.15}),withTiming(values.windowHeight,{duration:duration*0.55})))}]},initialValues:{transform:[{translateY:0}],...initialValues},callback:callback};}"
+};
+BounceOutDown = function BounceOutDown(...args) {
+  _classCallCheck(this, BounceOutDown);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceOutDown);
+  const _this7 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this7.build = () => {
+    const delayFunction7 = _this7.getDelayFunction();
+    const delay7 = _this7.getDelay();
+    const duration7 = _this7.getDuration();
+    const { callbackV: callbackV7, initialValues: initialValues7 } = _this7;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateY: delayFunction7(delay7, _Module1678.withSequence(_Module1678.withTiming(-10, {
+              duration: 0.15 * duration7
+            }), _Module1678.withTiming(10, {
+              duration: 0.15 * duration7
+            }), _Module1678.withTiming(-20, {
+              duration: 0.15 * duration7
+            }), _Module1678.withTiming(a0.windowHeight, {
+              duration: 0.55 * duration7
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateY: 0
+          }],
+          ...initialValues7
+        },
+        callback: callbackV7
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction7,
+      delay: delay7,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration7,
+      initialValues: initialValues7,
+      callback: callbackV7
+    };
+    r15.__workletHash = 4170057933312;
+    r15.__initData = c1365_12;
+    return r15;
+  };
+  return _this7;
+};
+_inherits(BounceOutDown, ComplexAnimationBuilder);
+const r142 = _createClass(BounceOutDown, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceOutDown.prototype
+    };
+    const r4 = BounceOutDown.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r142.presetName = "BounceOutDown";
+c1365_13 = {
+  code: "function pnpm_BounceTs8(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateY:delayFunction(delay,withSequence(withTiming(10,{duration:duration*0.15}),withTiming(-10,{duration:duration*0.15}),withTiming(20,{duration:duration*0.15}),withTiming(-values.windowHeight,{duration:duration*0.55})))}]},initialValues:{transform:[{translateY:0}],...initialValues},callback:callback};}"
+};
+BounceOutUp = function BounceOutUp(...args) {
+  _classCallCheck(this, BounceOutUp);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceOutUp);
+  const _this8 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this8.build = () => {
+    const delayFunction8 = _this8.getDelayFunction();
+    const delay8 = _this8.getDelay();
+    const duration8 = _this8.getDuration();
+    const { callbackV: callbackV8, initialValues: initialValues8 } = _this8;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateY: delayFunction8(delay8, _Module1678.withSequence(_Module1678.withTiming(10, {
+              duration: 0.15 * duration8
+            }), _Module1678.withTiming(-10, {
+              duration: 0.15 * duration8
+            }), _Module1678.withTiming(20, {
+              duration: 0.15 * duration8
+            }), _Module1678.withTiming(-a0.windowHeight, {
+              duration: 0.55 * duration8
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateY: 0
+          }],
+          ...initialValues8
+        },
+        callback: callbackV8
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction8,
+      delay: delay8,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration8,
+      initialValues: initialValues8,
+      callback: callbackV8
+    };
+    r15.__workletHash = 8059944917039;
+    r15.__initData = c1365_13;
+    return r15;
+  };
+  return _this8;
+};
+_inherits(BounceOutUp, ComplexAnimationBuilder);
+const r158 = _createClass(BounceOutUp, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceOutUp.prototype
+    };
+    const r4 = BounceOutUp.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r158.presetName = "BounceOutUp";
+c1365_14 = {
+  code: "function pnpm_BounceTs9(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateX:delayFunction(delay,withSequence(withTiming(10,{duration:duration*0.15}),withTiming(-10,{duration:duration*0.15}),withTiming(20,{duration:duration*0.15}),withTiming(-values.windowWidth,{duration:duration*0.55})))}]},initialValues:{transform:[{translateX:0}],...initialValues},callback:callback};}"
+};
+BounceOutLeft = function BounceOutLeft(...args) {
+  _classCallCheck(this, BounceOutLeft);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceOutLeft);
+  const _this9 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this9.build = () => {
+    const delayFunction9 = _this9.getDelayFunction();
+    const delay9 = _this9.getDelay();
+    const duration9 = _this9.getDuration();
+    const { callbackV: callbackV9, initialValues: initialValues9 } = _this9;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateX: delayFunction9(delay9, _Module1678.withSequence(_Module1678.withTiming(10, {
+              duration: 0.15 * duration9
+            }), _Module1678.withTiming(-10, {
+              duration: 0.15 * duration9
+            }), _Module1678.withTiming(20, {
+              duration: 0.15 * duration9
+            }), _Module1678.withTiming(-a0.windowWidth, {
+              duration: 0.55 * duration9
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateX: 0
+          }],
+          ...initialValues9
+        },
+        callback: callbackV9
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction9,
+      delay: delay9,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration9,
+      initialValues: initialValues9,
+      callback: callbackV9
+    };
+    r15.__workletHash = 6930767645815;
+    r15.__initData = c1365_14;
+    return r15;
+  };
+  return _this9;
+};
+_inherits(BounceOutLeft, ComplexAnimationBuilder);
+const r174 = _createClass(BounceOutLeft, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceOutLeft.prototype
+    };
+    const r4 = BounceOutLeft.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r174.presetName = "BounceOutLeft";
+c1365_15 = {
+  code: "function pnpm_BounceTs10(values){const{delayFunction,delay,withSequence,withTiming,duration,initialValues,callback}=this.__closure;return{animations:{transform:[{translateX:delayFunction(delay,withSequence(withTiming(-10,{duration:duration*0.15}),withTiming(10,{duration:duration*0.15}),withTiming(-20,{duration:duration*0.15}),withTiming(values.windowWidth,{duration:duration*0.55})))}]},initialValues:{transform:[{translateX:0}],...initialValues},callback:callback};}"
+};
+BounceOutRight = function BounceOutRight(...args) {
+  _classCallCheck(this, BounceOutRight);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(BounceOutRight);
+  const _this10 = _possibleConstructorReturn(this, (0, env1365[5])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  _this10.build = () => {
+    const delayFunction10 = _this10.getDelayFunction();
+    const delay10 = _this10.getDelay();
+    const duration10 = _this10.getDuration();
+    const { callbackV: callbackV10, initialValues: initialValues10 } = _this10;
+    const r15 = function n(a0) {
+      return {
+        animations: {
+          transform: [{
+            translateX: delayFunction10(delay10, _Module1678.withSequence(_Module1678.withTiming(-10, {
+              duration: 0.15 * duration10
+            }), _Module1678.withTiming(10, {
+              duration: 0.15 * duration10
+            }), _Module1678.withTiming(-20, {
+              duration: 0.15 * duration10
+            }), _Module1678.withTiming(a0.windowWidth, {
+              duration: 0.55 * duration10
+            })))
+          }]
+        },
+        initialValues: {
+          transform: [{
+            translateX: 0
+          }],
+          ...initialValues10
+        },
+        callback: callbackV10
+      };
+    };
+    r15.__closure = {
+      delayFunction: delayFunction10,
+      delay: delay10,
+      withSequence: _Module1678.withSequence,
+      withTiming: _Module1678.withTiming,
+      duration: duration10,
+      initialValues: initialValues10,
+      callback: callbackV10
+    };
+    r15.__workletHash = 11465945086863;
+    r15.__initData = c1365_15;
+    return r15;
+  };
+  return _this10;
+};
+_inherits(BounceOutRight, ComplexAnimationBuilder);
+const r191 = _createClass(BounceOutRight, [{
+  key: "getDuration",
+  value: function getDuration() {
+    let durationV = this.durationV;
+    if (durationV == null) {
+      durationV = 600;
+    }
+    return durationV;
+  }
+}], [{
+  key: "createInstance",
+  value: function createInstance() {
+    const r3 = {
+      __proto__: BounceOutRight.prototype
+    };
+    const r4 = BounceOutRight.call(r3);
+    return r4 instanceof Object ? r4 : r3;
+  }
+}, {
+  key: "getDuration",
+  value: function getDuration() {
+    return 600;
+  }
+}]);
+r191.presetName = "BounceOutRight";
+export { r11 as BounceIn };
+export { r10 as BounceInDown };
+export { r9 as BounceInUp };
+export { r8 as BounceInLeft };
+export { r110 as BounceInRight };
+export { r126 as BounceOut };
+export { r142 as BounceOutDown };
+export { r158 as BounceOutUp };
+export { r174 as BounceOutLeft };
+export { r191 as BounceOutRight };

_bundle/BoundingDimensions.js

@@ -0,0 +1,15 @@
+// Metro module 427 (f428).
+import standardReleaser from "./standardReleaser";
+const BoundingDimensions = function BoundingDimensions(a0, a1) {
+  this.width = a0;
+  this.height = a1;
+};
+BoundingDimensions.prototype.destructor = function() {
+  this.width = null;
+  this.height = null;
+};
+BoundingDimensions.getPooledFromElement = function(a0) {
+  return BoundingDimensions.getPooled(a0.offsetWidth, a0.offsetHeight);
+};
+standardReleaser.addPoolingTo(BoundingDimensions, standardReleaser.twoArgumentPooler);
+export default BoundingDimensions;

_bundle/BountiesScrollGradientRiveInner.jsx

@@ -0,0 +1,24 @@
+// Metro module 3970 (f3971).
+import _objectWithoutProperties from "./_objectWithoutProperties";
+import { forwardRef } from "react";
+import { BaseRive } from "./Module3918";
+import Module3971 from "./Module3971";
+import { RiveErrorBoundary } from "./Module3969";
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance"];
+const artboardProperties = {
+  "Bounty Scroll Gradient": {}
+};
+const artboardViewModelInstances = {
+  "Bounty Scroll Gradient": []
+};
+const BountiesScrollGradientRiveInner = forwardRef(function BountiesScrollGradientRiveInner(props, a1) {
+  props.fallback;
+  const { artboard: artboard2 = "Bounty Scroll Gradient", stateMachine, defaultViewModelInstance } = props;
+  return <BaseRive ref={a1} src={Module3971} artboard={artboard2} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance !== void 0 ? defaultViewModelInstance : void 0} stateMachine={stateMachine} {..._objectWithoutProperties(props, _excluded)} />;
+});
+const r30 = forwardRef(function BountiesScrollGradientRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <BountiesScrollGradientRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r30 as BountiesScrollGradientRive };

_bundle/BountiesScrollIndicatorRiveInner.jsx

@@ -0,0 +1,39 @@
+// Metro module 3972 (f3973).
+import { forwardRef, useCallback } from "react";
+import { useTriggerBinding, useBooleanBinding, useColorBinding, BaseRive } from "./Module3918";
+import Module3973 from "./Module3973";
+import { RiveErrorBoundary } from "./Module3969";
+let BountiesScrollIndicatorRiveInner;
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance", "dataBinding", "onDataBindingChange"];
+const artboardProperties = {
+  "Bounties Scroll Indicator": {
+    startAnimation: "trigger",
+    looping: "boolean",
+    color: "color"
+  }
+};
+const artboardViewModelInstances = {
+  "Bounties Scroll Indicator": ["Instance"]
+};
+let c2264_9 = {
+  "Bounties Scroll Indicator": function BountiesScrollIndicatorBindings({ instance, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useTriggerBinding("startAnimation", instance, dataBinding2?.startAnimation, onDataBindingChange2?.startAnimation, playIfNeeded);
+    useBooleanBinding("looping", instance, dataBinding2?.looping, onDataBindingChange2?.looping, playIfNeeded);
+    useColorBinding("color", instance, dataBinding2?.color, onDataBindingChange2?.color, playIfNeeded);
+    return null;
+  }
+};
+BountiesScrollIndicatorRiveInner = forwardRef(function BountiesScrollIndicatorRiveInner(props, a1) {
+  props.fallback;
+  const { artboard = "Bounties Scroll Indicator", stateMachine, defaultViewModelInstance: defaultViewModelInstance2 = "Instance", dataBinding, onDataBindingChange, ...rest } = props;
+  return <BaseRive ref={a1} src={Module3973} artboard={artboard} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance2} stateMachine={stateMachine} renderDataBinding={useCallback((a0) => {
+    const Component = c2264_9[artboard];
+    return Component != null ? <Component {...a0} dataBinding={dataBinding} onDataBindingChange={onDataBindingChange} /> : null;
+  }, [artboard, dataBinding, onDataBindingChange])} {...rest} />;
+});
+const r32 = forwardRef(function BountiesScrollIndicatorRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <BountiesScrollIndicatorRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r32 as BountiesScrollIndicatorRive };

_bundle/BrowserClient.js

@@ -0,0 +1,131 @@
+// Metro module 1030 (f1031).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+import * as _possibleConstructorReturn from "./_possibleConstructorReturn";
+import * as _getPrototypeOf from "./_getPrototypeOf";
+import * as _get from "./_get";
+import * as __inherits from "./_inherits";
+import { WINDOW } from "./ignoreNextOnError";
+import { applySdkMetadata, getSDKSource, _INTERNAL_flushLogsBuffer, _INTERNAL_flushMetricsBuffer, addAutoIpAddressToSession, Client } from "./Module817";
+import * as _exceptionFromError from "./exceptionFromError_1031";
+let BrowserClient;
+let env844 = {};
+env844[6] = function _isNativeReflectConstruct() {
+  let c12665_0;
+  try {
+    c12665_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12665_0;
+  };
+  env844[6] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+Object.defineProperty(exports, Symbol.toStringTag, {
+  value: "Module"
+});
+BrowserClient = function BrowserClient(a0) {
+  "use strict";
+  _classCallCheck(this, BrowserClient);
+  const r6 = {
+    release: typeof globalThis.__SENTRY_RELEASE__ === "string" ? __SENTRY_RELEASE__ : WINDOW.SENTRY_RELEASE?.id,
+    sendClientReports: true,
+    parentSpanIsAlwaysRootSpan: true,
+    ...a0
+  };
+  applySdkMetadata(r6, "browser", ["browser"], WINDOW.SENTRY_SDK_SOURCE || getSDKSource());
+  if (r6._metadata?.sdk) {
+    r6._metadata.sdk.settings = {
+      infer_ip: r6.sendDefaultPii ? "auto" : "never",
+      ...r6._metadata.sdk.settings
+    };
+  }
+  const r54 = [r6];
+  const r56 = _getPrototypeOf(BrowserClient);
+  const r61 = (0, env844[6])() ? Reflect.construct(r56, r54, _getPrototypeOf(this).constructor) : r56.apply(this, r54);
+  const r67 = _possibleConstructorReturn(this, r61);
+  const _options = r67._options;
+  const sendDefaultPii = _options.sendDefaultPii;
+  let sendClientReports2 = _options.sendClientReports;
+  const sendClientReports = sendClientReports2;
+  const { enableLogs, _experiments } = _options;
+  let enableMetrics = _options.enableMetrics;
+  if (enableMetrics == null) {
+    enableMetrics = _experiments?.enableMetrics;
+  }
+  if (enableMetrics == null) {
+    enableMetrics = true;
+  }
+  let c24018_3 = enableMetrics;
+  let document2 = WINDOW.document;
+  if (document2) {
+    if (!sendClientReports) {
+      sendClientReports2 = enableLogs;
+    }
+    if (!sendClientReports2) {
+      sendClientReports2 = enableMetrics;
+    }
+    document2 = sendClientReports2;
+  }
+  if (document2) {
+    WINDOW.document.addEventListener("visibilitychange", () => {
+      if (WINDOW.document.visibilityState === "hidden") {
+        if (sendClientReports) {
+          this._flushOutcomes();
+        }
+        if (enableLogs) {
+          _INTERNAL_flushLogsBuffer(this);
+        }
+        if (c24018_3) {
+          _INTERNAL_flushMetricsBuffer(this);
+        }
+      }
+    });
+  }
+  if (sendDefaultPii) {
+    r67.on("beforeSendSession", addAutoIpAddressToSession);
+  }
+  return r67;
+};
+__inherits(BrowserClient, Client);
+exports.BrowserClient = __createClass(BrowserClient, [{
+  key: "eventFromException",
+  value: function eventFromException(a0, a1) {
+    "use strict";
+    return _exceptionFromError.eventFromException(this._options.stackParser, a0, a1, this._options.attachStacktrace);
+  }
+}, {
+  key: "eventFromMessage",
+  value: function eventFromMessage(a0) {
+    "use strict";
+    let r7 = arguments[1];
+    if (r7 === void 0) {
+      r7 = "info";
+    }
+    return _exceptionFromError.eventFromMessage(this._options.stackParser, a0, r7, arguments[2], this._options.attachStacktrace);
+  }
+}, {
+  key: "_prepareEvent",
+  value: function _prepareEvent(a0, a1, a2, a3) {
+    "use strict";
+    const platform2 = a0.platform || "javascript";
+    a0.platform = platform2;
+    const _this = this;
+    let r13 = _get(_getPrototypeOf(BrowserClient.prototype), "_prepareEvent", this);
+    let c24019_1 = r13;
+    if (typeof r13 === "function") {
+      r13 = function(a0) {
+        return c24019_1.apply(_this, a0);
+      };
+    }
+    return r13([a0, a1, a2, a3]);
+  }
+}]);
+export function applyDefaultOptions(a0) {
+  return {
+    release: typeof globalThis.__SENTRY_RELEASE__ === "string" ? __SENTRY_RELEASE__ : WINDOW.SENTRY_RELEASE?.id,
+    sendClientReports: true,
+    parentSpanIsAlwaysRootSpan: true,
+    ...a0
+  };
+}

_bundle/BrowserMetricsAggregator.js

@@ -0,0 +1,83 @@
+// Metro module 6472 (f6473).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+import { DEFAULT_BROWSER_FLUSH_INTERVAL, SET_METRIC_TYPE } from "./Module6465";
+import { timestampInSeconds } from "./Module6382";
+import { sanitizeMetricKey, sanitizeTags, sanitizeUnit, getBucketKey } from "./Module6469";
+import { METRIC_MAP } from "./CounterMetric";
+import { updateMetricSummaryOnActiveSpan } from "./spanTimeInputToSeconds";
+import { captureAggregateMetrics } from "./createMetricEnvelope";
+let env4172 = {};
+const BrowserMetricsAggregator = function BrowserMetricsAggregator(a0) {
+  "use strict";
+  _classCallCheck(this, BrowserMetricsAggregator);
+  this._client = a0;
+  this._buckets = new Map();
+  this._interval = setInterval(() => this.flush(), DEFAULT_BROWSER_FLUSH_INTERVAL);
+};
+exports.BrowserMetricsAggregator = __createClass(BrowserMetricsAggregator, [{
+  key: "add",
+  value: function add(a0, a1, a2) {
+    "use strict";
+    let r61;
+    let r6 = arguments[3];
+    if (r6 === void 0) {
+      r6 = "none";
+    }
+    let r9 = arguments[4];
+    if (r9 === void 0) {
+      r9 = {};
+    }
+    let r5 = arguments[5];
+    if (r5 === void 0) {
+      r5 = timestampInSeconds();
+    }
+    const timestamp2 = Math.floor(r5);
+    const name = sanitizeMetricKey(a1);
+    const tags = sanitizeTags(r9);
+    const unit = sanitizeUnit(r6);
+    const bucketKey = getBucketKey(a0, name, unit, tags);
+    const r12 = this._buckets.get(bucketKey);
+    const r11 = r12 ? a0 === SET_METRIC_TYPE ? r12.metric.weight : 0 : 0;
+    let r53 = a2;
+    if (r12) {
+      r12.metric.add(a2);
+      const timestamp = r12.timestamp;
+      r61 = r12;
+      if (timestamp < timestamp2) {
+        r12.timestamp = timestamp2;
+        r61 = r12;
+      }
+    } else {
+      r61 = {
+        metric: new METRIC_MAP[a0](a2),
+        timestamp: timestamp2,
+        metricType: a0,
+        name,
+        unit,
+        tags
+      };
+      this._buckets.set(bucketKey, r61);
+    }
+    if (typeof a2 === "string") {
+      r53 = r61.metric.weight - r11;
+    }
+    updateMetricSummaryOnActiveSpan(a0, name, r53, unit, r9, bucketKey);
+  }
+}, {
+  key: "flush",
+  value: function flush() {
+    "use strict";
+    if (this._buckets.size !== 0) {
+      captureAggregateMetrics(this._client, Array.from(this._buckets.values()));
+      this._buckets.clear();
+    }
+  }
+}, {
+  key: "close",
+  value: function close() {
+    "use strict";
+    clearInterval(this._interval);
+    this.flush();
+  }
+}]);

_bundle/Button.jsx

@@ -0,0 +1,88 @@
+// Metro module 290 (f291).
+import TouchableNativeFeedback from "./TouchableNativeFeedback";
+import Module38 from "./Module38";
+import View from "./View";
+import TextImpl from "./TextImpl";
+import Module254 from "./Module254";
+let styles;
+const Button = (props) => {
+  const { ref, ...rest } = props;
+  const { accessibilityLabel, accessibilityState } = rest;
+  let busy = rest["aria-busy"];
+  let checked = rest["aria-checked"];
+  let disabled = rest["aria-disabled"];
+  let expanded = rest["aria-expanded"];
+  let accessibilityLabel2 = rest["aria-label"];
+  let selected = rest["aria-selected"];
+  const { importantForAccessibility, color, onPress, touchSoundDisabled, title, hasTVPreferredFocus, nextFocusDown, nextFocusForward, nextFocusLeft, nextFocusRight, nextFocusUp, testID, accessible, accessibilityActions, accessibilityHint, accessibilityLanguage, onAccessibilityAction } = rest;
+  const style2 = [styles.button];
+  const style = [styles.text];
+  if (color) {
+    style2.push({
+      backgroundColor: color
+    });
+  }
+  if (busy == null) {
+    busy = accessibilityState?.busy;
+  }
+  if (checked == null) {
+    checked = accessibilityState?.checked;
+  }
+  if (disabled == null) {
+    disabled = accessibilityState?.disabled;
+  }
+  if (expanded == null) {
+    expanded = accessibilityState?.expanded;
+  }
+  if (selected == null) {
+    selected = accessibilityState?.selected;
+  }
+  const r43 = {
+    busy,
+    checked,
+    disabled,
+    expanded,
+    selected
+  };
+  const disabled2 = rest.disabled != null ? rest.disabled : r43.disabled;
+  const accessibilityState2 = disabled2 !== r43.disabled ? {
+    ...r43,
+    disabled: disabled2
+  } : r43;
+  if (disabled2) {
+    style2.push(styles.buttonDisabled);
+    style.push(styles.textDisabled);
+  }
+  Module38(typeof title === "string", "The title prop of a Button must be a string");
+  const r75 = title.toUpperCase();
+  if (!accessibilityLabel2) {
+    accessibilityLabel2 = accessibilityLabel;
+  }
+  return <TouchableNativeFeedback accessible={accessible} accessibilityActions={accessibilityActions} onAccessibilityAction={onAccessibilityAction} accessibilityLabel={accessibilityLabel2} accessibilityHint={accessibilityHint} accessibilityLanguage={accessibilityLanguage} accessibilityRole="button" accessibilityState={accessibilityState2} importantForAccessibility={importantForAccessibility !== "no" ? importantForAccessibility : "no-hide-descendants"} hasTVPreferredFocus={hasTVPreferredFocus} nextFocusDown={nextFocusDown} nextFocusForward={nextFocusForward} nextFocusLeft={nextFocusLeft} nextFocusRight={nextFocusRight} nextFocusUp={nextFocusUp} testID={testID} disabled={disabled2} onPress={onPress} touchSoundDisabled={touchSoundDisabled} ref={ref}>
+    <View style={style2}>
+      <TextImpl style={style} disabled={disabled2}>{r75}</TextImpl>
+    </View>
+  </TouchableNativeFeedback>;
+};
+Button.displayName = "Button";
+styles = Module254.create({
+  button: {
+    elevation: 4,
+    backgroundColor: "#2196F3",
+    borderRadius: 2
+  },
+  text: {
+    textAlign: "center",
+    margin: 8,
+    color: "white",
+    fontWeight: "500"
+  },
+  buttonDisabled: {
+    elevation: 0,
+    backgroundColor: "#dfdfdf"
+  },
+  textDisabled: {
+    color: "#a1a1a1"
+  }
+});
+export default Button;

_bundle/Call.js

@@ -0,0 +1,13 @@
+// Metro module 4494 (f4495).
+import * as _GetIntrinsic from "./GetIntrinsic";
+import * as _callBoundIntrinsic from "./callBoundIntrinsic";
+import * as _Module4472 from "./Module4472";
+import * as _Module541 from "./Module541";
+let c2705_2 = _GetIntrinsic("%Reflect.apply%", true) || _callBoundIntrinsic("Function.prototype.apply");
+module.exports = function Call(a0, a1) {
+  const r5 = arguments.length > 2 ? arguments[2] : [];
+  if (_Module4472(r5)) {
+    return c2705_2(a0, a1, r5);
+  }
+  throw new _Module541("Assertion failed: optional `argumentsList`, if provided, must be a List");
+};

_bundle/Camera.jsx

@@ -0,0 +1,18 @@
+// Metro module 4293 (f4294).
+import Video from "./Video";
+const Camera = function Camera(props) {
+  const { disabled, deviceId, width, height } = props;
+  return disabled ? <div className="media-engine-video" style={{
+    width,
+    height
+  }} /> : <Video streamId={deviceId} style={{
+    width,
+    height
+  }} />;
+};
+Camera.defaultProps = {
+  disabled: false,
+  width: 320,
+  height: 180
+};
+export default Camera;

_bundle/CameraRiveInner.jsx

@@ -0,0 +1,41 @@
+// Metro module 3974 (f3975).
+import { forwardRef, useCallback } from "react";
+import { useBooleanBinding, useColorBinding, BaseRive } from "./Module3918";
+import Module3975 from "./Module3975";
+import { RiveErrorBoundary } from "./Module3969";
+let CameraRiveInner;
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance", "dataBinding", "onDataBindingChange"];
+const artboardProperties = {
+  "Icon Camera": {
+    reducedMotion: "boolean",
+    fill: "color",
+    on: "boolean"
+  },
+  "Animation Main": {}
+};
+const artboardViewModelInstances = {
+  "Icon Camera": ["CamOff", "CamOn"],
+  "Animation Main": []
+};
+let c2265_9 = {
+  "Icon Camera": function IconCameraBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("fill", instance, dataBinding2?.fill, onDataBindingChange2?.fill, playIfNeeded);
+    useBooleanBinding("on", instance, dataBinding2?.on, onDataBindingChange2?.on, playIfNeeded);
+    return null;
+  }
+};
+CameraRiveInner = forwardRef(function CameraRiveInner(props, a1) {
+  props.fallback;
+  const { artboard = "Icon Camera", stateMachine, defaultViewModelInstance: defaultViewModelInstance2 = "CamOff", dataBinding, onDataBindingChange, ...rest } = props;
+  return <BaseRive ref={a1} src={Module3975} artboard={artboard} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance2} stateMachine={stateMachine} renderDataBinding={useCallback((a0) => {
+    const Component = c2265_9[artboard];
+    return Component != null ? <Component {...a0} dataBinding={dataBinding} onDataBindingChange={onDataBindingChange} /> : null;
+  }, [artboard, dataBinding, onDataBindingChange])} {...rest} />;
+});
+const r34 = forwardRef(function CameraRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <CameraRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r34 as CameraRive };

_bundle/Cancellable.js

@@ -0,0 +1,97 @@
+// Metro module 5477 (f5478).
+import _classCallCheck from "./_classCallCheck_5425";
+import _createClass from "./_createClass_5426";
+function $mk114720($env) {
+  return () => {
+    L8: {
+      const r4 = $env;
+      const r7 = $env.$parent;
+      if (!r7[6].isCancelled()) {
+        const r20 = Date.now();
+        const r0 = r4[1] * (r20 - r4[6]);
+        r4[8] = r4[8] + r0 * r4[3];
+        const r13 = r7[0];
+        const r10 = r4[4];
+        const r9 = r7[3];
+        const r29 = r4[7] + r0 * r4[2];
+        r4[7] = r29;
+        const r12 = r10(r9, r29);
+        const r31 = r4[5];
+        const r32 = r7[4];
+        r13(r12, r31(r32, r4[8]), false);
+        r4[6] = r20;
+        if (r10(r9, r4[7]) === r9 && r31(r32, r4[8]) === r32) {
+          (0, r4[0])(true);
+          break L8;
+        }
+        requestAnimationFrame($mk114720(r4));
+        return void 0;
+      }
+      (0, r4[0])(false);
+    }
+  };
+}
+let c3363_1;
+let env3363 = {};
+const Cancellable = function Cancellable() {
+  _classCallCheck(this, Cancellable);
+  this._isCancelled = false;
+};
+c3363_1 = _createClass(Cancellable, [{
+  key: "cancel",
+  value: function cancel() {
+    this._isCancelled = true;
+  }
+}, {
+  key: "isCancelled",
+  value: function isCancelled() {
+    return this._isCancelled;
+  }
+}]);
+export function autoScroll(a0, a1, a2, a3, a4) {
+  let env14873 = {};
+  env14873[0] = a0;
+  env14873[1] = a1;
+  env14873[2] = a2;
+  env14873[3] = a3;
+  env14873[4] = a4;
+  let r12 = arguments[5];
+  if (r12 === void 0) {
+    r12 = 1;
+  }
+  env14873[5] = r12;
+  let r13 = arguments[6];
+  if (r13 === void 0) {
+    r13 = new c3363_1();
+  }
+  env14873[6] = r13;
+  return new Promise((resolve) => {
+    let env25477;
+    const r5 = env25477 = {
+      $parent: env14873
+    };
+    env25477[0] = resolve;
+    const r9 = env14873[0];
+    const r8 = env14873[1];
+    const r11 = env14873[2];
+    r9(r8, r11, false);
+    env25477[1] = 7 * env14873[5];
+    const r15 = env14873[3];
+    const r16 = r15 > r8;
+    let r17 = -1;
+    env25477[2] = r16 ? 1 : -1;
+    const r18 = env14873[4];
+    if (r18 > r11) {
+      r17 = 1;
+    }
+    env25477[3] = r17;
+    env25477[4] = r15 > r8 ? Math.min : Math.max;
+    env25477[5] = r18 > r11 ? Math.min : Math.max;
+    env25477[6] = Date.now();
+    env25477[7] = r8;
+    env25477[8] = r11;
+    env25477[9] = () => {};
+    requestAnimationFrame($mk114720(r5));
+  });
+}
+export { c3363_1 as Cancellable };

_bundle/Card.jsx

@@ -0,0 +1,369 @@
+// Metro module 5609 (f5610).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import { Component, createRef } from "react";
+import { Platform, StyleSheet, Animated, InteractionManager, View } from "react-native";
+import { jsx } from "react/jsx-runtime";
+import getInvertedMultiplier from "./getInvertedMultiplier";
+import getDistanceForDirection from "./getDistanceForDirection";
+import { GestureState, PanGestureHandler } from "./Module5575";
+import memoize from "./memoize_5607";
+import Color from "./Color";
+import Module5620 from "./Module5620";
+import Module5621 from "./Module5621";
+import * as _Module5622 from "./Module5622";
+let _excluded, c3454_16, styles;
+let Card;
+let env3454 = {};
+env3454[15] = function _isNativeReflectConstruct() {
+  let c14943_0;
+  try {
+    c14943_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c14943_0;
+  };
+  env3454[15] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+_excluded = ["styleInterpolator", "interpolationIndex", "current", "gesture", "next", "layout", "insets", "overlay", "overlayEnabled", "shadowEnabled", "gestureEnabled", "gestureDirection", "pageOverflowEnabled", "headerDarkContent", "children", "containerStyle", "contentStyle"];
+Platform;
+const StyleSheet2 = StyleSheet;
+c3454_16 = true;
+Card = function Card(...args) {
+  _classCallCheck(this, Card);
+  const r13 = [...args];
+  const r12 = _getPrototypeOf(Card);
+  const r30 = _possibleConstructorReturn(this, (0, env3454[15])() ? Reflect.construct(r12, r13, _getPrototypeOf(this).constructor) : r12.apply(this, r13));
+  r30.isCurrentlyMounted = false;
+  r30.isClosing = new Animated.Value(0);
+  r30.inverted = new Animated.Value(getInvertedMultiplier(r30.props.gestureDirection));
+  r30.layout = {
+    width: new Animated.Value(r30.props.layout.width),
+    height: new Animated.Value(r30.props.layout.height)
+  };
+  r30.isSwiping = new Animated.Value(0);
+  r30.animate = ({ closing, velocity }) => {
+    const props = this.props;
+    const { gesture, transitionSpec, onOpen, onClose, onTransition } = props;
+    const animateToValue = this.getAnimateToValue({
+      ...this.props,
+      closing
+    });
+    this.lastToValue = animateToValue;
+    this.isClosing.setValue(closing ? 1 : 0);
+    const r25 = closing ? transitionSpec.close : transitionSpec.open;
+    const r30 = r25.animation === "spring" ? Animated.spring : Animated.timing;
+    this.setPointerEventsEnabled(!closing);
+    this.handleStartInteraction();
+    clearTimeout(this.pendingGestureCallback);
+    if (onTransition != null) {
+      onTransition({
+        closing,
+        gesture: velocity !== void 0
+      });
+    }
+    r30(gesture, {
+      ...r25.config,
+      velocity,
+      toValue: animateToValue,
+      useNativeDriver: c3454_16,
+      isInteraction: false
+    }).start(({ finished }) => {
+      this.handleEndInteraction();
+      clearTimeout(this.pendingGestureCallback);
+      if (finished) {
+        if (closing) {
+          onClose();
+        } else {
+          onOpen();
+        }
+        if (this.isCurrentlyMounted) {
+          this.forceUpdate();
+        }
+      }
+    });
+  };
+  r30.getAnimateToValue = ({ closing: closing2, layout, gestureDirection }) => closing2 ? getDistanceForDirection(layout, gestureDirection) : 0;
+  r30.setPointerEventsEnabled = (a0) => {
+    const r3 = a0 ? "box-none" : "none";
+    const current = this.ref.current;
+    if (current != null) {
+      current.setPointerEvents(r3);
+    }
+  };
+  r30.handleStartInteraction = () => {
+    if (this.interactionHandle === void 0) {
+      this.interactionHandle = InteractionManager.createInteractionHandle();
+    }
+  };
+  r30.handleEndInteraction = () => {
+    if (this.interactionHandle !== void 0) {
+      InteractionManager.clearInteractionHandle(this.interactionHandle);
+      this.interactionHandle = void 0;
+    }
+  };
+  r30.handleGestureStateChange = ({ nativeEvent }) => {
+    let translationX, velocityX, width;
+    const props = this.props;
+    const { layout, onClose: onClose2, onGestureBegin, onGestureCanceled, onGestureEnd, gestureDirection, gestureVelocityImpact } = props;
+    const state = nativeEvent.state;
+    if (GestureState.ACTIVE === state) {
+      this.isSwiping.setValue(1);
+      this.handleStartInteraction();
+      if (onGestureBegin != null) {
+        onGestureBegin();
+      }
+    } else if (GestureState.CANCELLED === state) {
+      this.isSwiping.setValue(0);
+      this.handleEndInteraction();
+      this.animate({
+        closing: this.props.closing,
+        velocity: gestureDirection !== "vertical" && gestureDirection !== "vertical-inverted" ? nativeEvent.velocityX : nativeEvent.velocityY
+      });
+      if (onGestureCanceled != null) {
+        onGestureCanceled();
+      }
+    } else if (GestureState.END === state) {
+      this.isSwiping.setValue(0);
+      if (gestureDirection !== "vertical" && gestureDirection !== "vertical-inverted") {
+        width = layout.width;
+        translationX = nativeEvent.translationX;
+        velocityX = nativeEvent.velocityX;
+      } else {
+        width = layout.height;
+        translationX = nativeEvent.translationY;
+        velocityX = nativeEvent.velocityY;
+      }
+      const closing2 = (translationX + velocityX * gestureVelocityImpact) * getInvertedMultiplier(gestureDirection) > width / 2 ? velocityX !== 0 || translationX !== 0 : this.props.closing;
+      this.animate({
+        closing: closing2,
+        velocity: velocityX
+      });
+      if (closing2) {
+        this.pendingGestureCallback = setTimeout(() => {
+          onClose2();
+          this.forceUpdate();
+        }, 32);
+      }
+      if (onGestureEnd != null) {
+        onGestureEnd();
+      }
+    }
+  };
+  r30.getInterpolatedStyle = memoize((a0, a1) => a0(a1));
+  r30.getCardAnimation = memoize((a0, a1, a2, a3, a4, a5, a6, a7) => {
+    const next = a2 ? {
+      progress: a2
+    } : a2;
+    return {
+      index: a0,
+      current: {
+        progress: a1
+      },
+      next,
+      closing: this.isClosing,
+      swiping: this.isSwiping,
+      inverted: this.inverted,
+      layouts: {
+        screen: a3
+      },
+      insets: {
+        top: a4,
+        right: a5,
+        bottom: a6,
+        left: a7
+      }
+    };
+  });
+  r30.ref = createRef();
+  return r30;
+};
+_inherits(Card, Component);
+const r56 = _createClass(Card, [{
+  key: "componentDidMount",
+  value: function componentDidMount() {
+    this.animate({
+      closing: this.props.closing
+    });
+    this.isCurrentlyMounted = true;
+  }
+}, {
+  key: "componentDidUpdate",
+  value: function componentDidUpdate(a0) {
+    const props = this.props;
+    const { layout, gestureDirection, closing: closing2 } = props;
+    const { width, height } = layout;
+    if (width !== a0.layout.width) {
+      this.layout.width.setValue(width);
+    }
+    if (height !== a0.layout.height) {
+      this.layout.height.setValue(height);
+    }
+    if (gestureDirection !== a0.gestureDirection) {
+      this.inverted.setValue(getInvertedMultiplier(gestureDirection));
+    }
+    const animateToValue = this.getAnimateToValue(this.props);
+    if (!(this.getAnimateToValue(a0) === animateToValue && this.lastToValue === animateToValue)) {
+      this.animate({
+        closing: closing2
+      });
+    }
+  }
+}, {
+  key: "componentWillUnmount",
+  value: function componentWillUnmount() {
+    this.props.gesture.stopAnimation();
+    this.isCurrentlyMounted = false;
+    this.handleEndInteraction();
+  }
+}, {
+  key: "gestureActivationCriteria",
+  value: function gestureActivationCriteria() {
+    const props = this.props;
+    const { layout, gestureDirection, gestureResponseDistance = gestureDirection !== "vertical" ? gestureDirection === "vertical-inverted" ? 135 : 50 : 135 } = props;
+    if (gestureDirection === "vertical") {
+      return {
+        maxDeltaX: 15,
+        minOffsetY: 5,
+        hitSlop: {
+          bottom: -layout.height + gestureResponseDistance
+        },
+        enableTrackpadTwoFingerGesture: true
+      };
+    }
+    if (gestureDirection === "vertical-inverted") {
+      return {
+        maxDeltaX: 15,
+        minOffsetY: -5,
+        hitSlop: {
+          top: -layout.height + gestureResponseDistance
+        },
+        enableTrackpadTwoFingerGesture: true
+      };
+    }
+    const right = -layout.width + gestureResponseDistance;
+    return getInvertedMultiplier(gestureDirection) === 1 ? {
+      minOffsetX: 5,
+      maxDeltaY: 20,
+      hitSlop: {
+        right
+      },
+      enableTrackpadTwoFingerGesture: true
+    } : {
+      minOffsetX: -5,
+      maxDeltaY: 20,
+      hitSlop: {
+        left: right
+      },
+      enableTrackpadTwoFingerGesture: true
+    };
+  }
+}, {
+  key: "render",
+  value: function render() {
+    const props = this.props;
+    const { styleInterpolator, interpolationIndex, current, gesture, next, layout, insets, overlay: overlay2, overlayEnabled, shadowEnabled, gestureEnabled, gestureDirection, pageOverflowEnabled } = props;
+    props.headerDarkContent;
+    const { children, containerStyle, contentStyle, ...rest } = props;
+    const cardAnimation = this.getCardAnimation(interpolationIndex, current, next, layout, insets.top, insets.right, insets.bottom, insets.left);
+    const interpolatedStyle = this.getInterpolatedStyle(styleInterpolator, cardAnimation);
+    const { containerStyle: containerStyle2, cardStyle, overlayStyle, shadowStyle } = interpolatedStyle;
+    const onGestureEvent = gestureEnabled ? Animated.event([{
+      nativeEvent: gestureDirection !== "vertical" && gestureDirection !== "vertical-inverted" ? {
+        translationX: gesture
+      } : {
+        translationY: gesture
+      }
+    }], {
+      useNativeDriver: c3454_16
+    }) : void 0;
+    const backgroundColor = StyleSheet.flatten(contentStyle || {}).backgroundColor;
+    const r63 = typeof backgroundColor === "string" ? Color(backgroundColor).alpha() === 0 : typeof backgroundColor === "string";
+    const r82 = [null, <Animated.View style={{
+      opacity: current
+    }} collapsable={false} />, ,];
+    const r93 = [overlayEnabled ? <View pointerEvents="box-none" style={StyleSheet.absoluteFill}>
+      {overlay2({
+        style: overlayStyle
+      })}
+    </View> : null, ,];
+    const View2 = Animated.View;
+    const props2 = {
+      enabled: layout.width !== 0 && gestureEnabled,
+      onGestureEvent,
+      onHandlerStateChange: this.handleGestureStateChange,
+      ...this.gestureActivationCriteria()
+    };
+    props2.children = <Animated.View needsOffscreenAlphaCompositing={!!cardStyle && StyleSheet.flatten(cardStyle).opacity != null} style={[styles.container, cardStyle]}>
+      {shadowEnabled ? shadowStyle ? r63 ? null : <Animated.View style={[styles.shadow, gestureDirection === "horizontal" ? [styles.shadowHorizontal, styles.shadowLeft] : gestureDirection === "horizontal-inverted" ? [styles.shadowHorizontal, styles.shadowRight] : gestureDirection === "vertical" ? [styles.shadowVertical, styles.shadowTop] : [styles.shadowVertical, styles.shadowBottom], {
+        backgroundColor
+      }, shadowStyle]} pointerEvents="none" /> : null : null}
+      <Module5621 ref={this.ref} enabled={pageOverflowEnabled} layout={layout} style={contentStyle}>{children}</Module5621>
+    </Animated.View>;
+    r93[1] = <View2 style={[styles.container, containerStyle2, containerStyle]} pointerEvents="box-none">
+      <PanGestureHandler {...props2} />
+    </View2>;
+    r82[2] = <View pointerEvents="box-none" collapsable={false} {...rest}>{r93}</View>;
+    return <Module5620.Provider value={cardAnimation}>{r82}</Module5620.Provider>;
+  }
+}]);
+r56.defaultProps = {
+  shadowEnabled: false,
+  gestureEnabled: true,
+  gestureVelocityImpact: 0.3,
+  overlay: ({ style }) => style ? (0, jsx)(Animated.View, {
+    pointerEvents: "none",
+    style: [styles.overlay, style]
+  }) : null
+};
+styles = StyleSheet2.create({
+  container: {
+    flex: 1
+  },
+  overlay: {
+    flex: 1,
+    backgroundColor: "#000"
+  },
+  shadow: {
+    position: "absolute",
+    shadowRadius: 5,
+    shadowColor: "#000",
+    shadowOpacity: 0.3
+  },
+  shadowHorizontal: {
+    top: 0,
+    bottom: 0,
+    width: 3,
+    shadowOffset: {
+      width: -1,
+      height: 1
+    }
+  },
+  shadowLeft: {
+    left: 0
+  },
+  shadowRight: {
+    right: 0
+  },
+  shadowVertical: {
+    left: 0,
+    right: 0,
+    height: 3,
+    shadowOffset: {
+      width: 1,
+      height: -1
+    }
+  },
+  shadowTop: {
+    top: 0
+  },
+  shadowBottom: {
+    bottom: 0
+  }
+});
+export default r56;
+export const getIsModalPresentation = (a0) => a0 === _Module5622.forModalPresentationIOS || a0.name === "forModalPresentationIOS";

_bundle/CellRenderMask.js

@@ -0,0 +1,113 @@
+// Metro module 324 (f325).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import Module38 from "./Module38";
+let env337 = {};
+const CellRenderMask = function CellRenderMask(a0) {
+  _classCallCheck(this, CellRenderMask);
+  Module38(a0 >= 0, "CellRenderMask must contain a non-negative number os cells");
+  this._numCells = a0;
+  this._regions = a0 === 0 ? [] : [{
+    first: 0,
+    last: a0 - 1,
+    isSpacer: true
+  }];
+};
+exports.CellRenderMask = _createClass(CellRenderMask, [{
+  key: "enumerateRegions",
+  value: function enumerateRegions() {
+    return this._regions;
+  }
+}, {
+  key: "addCells",
+  value: function addCells(a0) {
+    const r3 = a0.first >= 0 && a0.first < this._numCells && a0.last >= -1 && a0.last < this._numCells && a0.last >= a0.first - 1;
+    L20: {
+      Module38(r3, "CellRenderMask.addCells called with invalid cell range");
+      if (!(a0.last < a0.first)) {
+        const [r13, r40] = this._findRegion(a0.first);
+        const [r14, r45] = this._findRegion(a0.last);
+        if (r40 === r45 && !r13.isSpacer) {
+          break L20;
+        }
+        const r12 = [];
+        const r47 = {
+          ...a0,
+          isSpacer: false
+        };
+        if (r13.first < r47.first) {
+          if (r13.isSpacer) {
+            r12.push({
+              first: r13.first,
+              last: r47.first - 1,
+              isSpacer: true
+            });
+          } else {
+            r47.first = r13.first;
+          }
+        }
+        const r60 = [];
+        if (r14.last > r47.last) {
+          if (r14.isSpacer) {
+            r60.push({
+              first: r47.last + 1,
+              last: r14.last,
+              isSpacer: true
+            });
+          } else {
+            r47.last = r14.last;
+          }
+        }
+        const r71 = [...r12, r47, ...r60];
+        const r81 = r45 - r40 + 1;
+        const _regions = this._regions;
+        _regions.splice.apply(_regions, [r40, r81, ...r71]);
+      }
+    }
+  }
+}, {
+  key: "numCells",
+  value: function numCells() {
+    return this._numCells;
+  }
+}, {
+  key: "equals",
+  value: function equals(a0) {
+    return this._numCells === a0._numCells && this._regions.length === a0._regions.length && this._regions.every((_region, index) => {
+      const first = _region.first;
+      return first === a0._regions[index].first && _region.last === a0._regions[index].last && _region.isSpacer === a0._regions[index].isSpacer;
+    });
+  }
+}, {
+  key: "_findRegion",
+  value: function _findRegion(a0) {
+    let r24, r25;
+    let r1 = this._regions.length - 1;
+    let r10 = 0;
+    while (r10 <= r1) {
+      const r18 = Math.floor((r10 + r1) / 2);
+      const r20 = this._regions[r18];
+      const first = r20.first;
+      const r2 = r1;
+      const r14 = r10;
+      if (a0 >= first && a0 <= r20.last) {
+        return [r20, r18];
+      }
+      if (a0 < r20.first) {
+        r24 = r18 - 1;
+        r25 = r14;
+      } else {
+        const last = r20.last;
+        r24 = r2;
+        r25 = r14;
+        if (a0 > last) {
+          r25 = r18 + 1;
+          r24 = r2;
+        }
+      }
+      r1 = r24;
+      r10 = r25;
+    }
+    Module38(false, `A region was not found containing cellIdx ${a0}`);
+  }
+}]);

_bundle/CellRenderer.jsx

@@ -0,0 +1,184 @@
+// Metro module 321 (f322).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import { PureComponent, isValidElement } from "react";
+import { StyleSheet, View } from "react-native";
+import { jsx } from "react/jsx-runtime";
+import Module38 from "./Module38";
+import { VirtualizedListCellContextProvider } from "./Module322";
+import { HermesBuiltin } from "../_hermes/prelude";
+let styles;
+let CellRenderer;
+let env334 = {};
+env334[10] = function _isNativeReflectConstruct() {
+  let c12240_0;
+  try {
+    c12240_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12240_0;
+  };
+  env334[10] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+CellRenderer = function CellRenderer(...args) {
+  _classCallCheck(this, CellRenderer);
+  const r10 = [...args];
+  const r9 = _getPrototypeOf(CellRenderer);
+  const r27 = _possibleConstructorReturn(this, (0, env334[10])() ? Reflect.construct(r9, r10, _getPrototypeOf(this).constructor) : r9.apply(this, r10));
+  r27.state = {
+    separatorProps: {
+      highlighted: false,
+      leadingItem: r27.props.item
+    }
+  };
+  r27._separators = {
+    highlight: () => {
+      const props = this.props;
+      this.props.onUpdateSeparators([props.cellKey, props.prevCellKey], {
+        highlighted: true
+      });
+    },
+    unhighlight: () => {
+      const props = this.props;
+      this.props.onUpdateSeparators([props.cellKey, props.prevCellKey], {
+        highlighted: false
+      });
+    },
+    updateProps: (a0, a1) => {
+      const props2 = this.props;
+      let cellKey = props2.cellKey;
+      const prevCellKey = props2.prevCellKey;
+      const props = this.props;
+      if (a0 === "leading") {
+        cellKey = prevCellKey;
+      }
+      props.onUpdateSeparators([cellKey], a1);
+    }
+  };
+  r27._onLayout = (a0) => {
+    const props = this.props;
+    const onCellLayout = props.onCellLayout;
+    if (onCellLayout != null) {
+      onCellLayout.call(props, a0, this.props.cellKey, this.props.index);
+    }
+  };
+  r27._onCellFocusCapture = (a0) => {
+    const props = this.props;
+    const onCellFocusCapture = props.onCellFocusCapture;
+    if (onCellFocusCapture != null) {
+      onCellFocusCapture.call(props, this.props.cellKey);
+    }
+  };
+  return r27;
+};
+_inherits(CellRenderer, PureComponent);
+const r53 = _createClass(CellRenderer, [{
+  key: "updateSeparatorProps",
+  value: function updateSeparatorProps(c23655_0) {
+    this.setState((state) => ({
+      separatorProps: {
+        ...state.separatorProps,
+        ...c23655_0
+      }
+    }));
+  }
+}, {
+  key: "componentWillUnmount",
+  value: function componentWillUnmount() {
+    this.props.onUnmount(this.props.cellKey);
+  }
+}, {
+  key: "_renderElement",
+  value: function _renderElement(a0, a1, a2, a3) {
+    let r21;
+    if (a0 ? a1 : a0) {
+      console.warn("VirtualizedList: Both ListItemComponent and renderItem props are present. ListItemComponent will take precedence over renderItem.");
+    }
+    if (a1) {
+      r21 = (0, jsx)(a1, {
+        item: a2,
+        index: a3,
+        separators: this._separators
+      });
+    } else if (a0) {
+      r21 = a0({
+        item: a2,
+        index: a3,
+        separators: this._separators
+      });
+    } else {
+      Module38(false, "VirtualizedList: Either ListItemComponent or renderItem props are required but none were found.");
+      r21 = void 0;
+    }
+    return r21;
+  }
+}, {
+  key: "render",
+  value: function render() {
+    let children, style;
+    const props = this.props;
+    const { CellRendererComponent, ItemSeparatorComponent, ListItemComponent, cellKey, horizontal, item, index, inversionStyle } = props;
+    let onCellLayout = props.onCellLayout;
+    const r9 = this._renderElement(props.renderItem, ListItemComponent, item, index);
+    const r8 = (0, isValidElement)(ItemSeparatorComponent) ? ItemSeparatorComponent : ItemSeparatorComponent ? <ItemSeparatorComponent {...this.state.separatorProps} /> : ItemSeparatorComponent;
+    if (inversionStyle) {
+      style = horizontal ? [styles.rowReverse, inversionStyle] : [styles.columnReverse, inversionStyle];
+    } else {
+      style = horizontal ? [styles.row, inversionStyle] : inversionStyle;
+    }
+    if (CellRendererComponent) {
+      const r50 = {
+        cellKey,
+        index,
+        item,
+        style,
+        onFocusCapture: this._onCellFocusCapture
+      };
+      if (onCellLayout) {
+        onCellLayout = {
+          onLayout: this._onLayout
+        };
+      }
+      HermesBuiltin.copyDataProperties(r50, onCellLayout);
+      r50.children = [r9, r8];
+      children = <CellRendererComponent {...r50} />;
+    } else {
+      children = <View style={style} onFocusCapture={this._onCellFocusCapture} {...onCellLayout ? {
+        onLayout: this._onLayout
+      } : onCellLayout}>
+        {r9}
+        {r8}
+      </View>;
+    }
+    return (0, jsx)(VirtualizedListCellContextProvider, {
+      cellKey: this.props.cellKey,
+      children
+    });
+  }
+}], [{
+  key: "getDerivedStateFromProps",
+  value: function getDerivedStateFromProps(a0, a1) {
+    return a0.item !== a1.separatorProps.leadingItem ? {
+      separatorProps: {
+        ...a1.separatorProps,
+        leadingItem: a0.item
+      }
+    } : null;
+  }
+}]);
+styles = StyleSheet.create({
+  row: {
+    flexDirection: "row"
+  },
+  rowReverse: {
+    flexDirection: "row-reverse"
+  },
+  columnReverse: {
+    flexDirection: "column-reverse"
+  }
+});
+export default r53;

_bundle/CheckpointCardRiveInner.jsx

@@ -0,0 +1,415 @@
+// Metro module 3976 (f3977).
+import { forwardRef, useCallback } from "react";
+import { useBooleanBinding, useArtboardBinding, useNumberBinding, useStringBinding, useColorBinding, BaseRive } from "./Module3918";
+import Module3977 from "./Module3977";
+import { RiveErrorBoundary } from "./Module3969";
+let CheckpointCardRiveInner;
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance", "dataBinding", "onDataBindingChange"];
+const artboardProperties = {
+  Main: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  Cassette: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Cassette Icon": {},
+  Cat: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Cat Icon": {},
+  Banana: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Banana Icon": {},
+  "Duck Icon": {},
+  Duck: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Snail Icon": {},
+  Snail: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Origami Icon": {},
+  Origami: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Disco Icon": {},
+  Disco: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  Capybara: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Capybara Icon": {},
+  Donut: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Donut Icon": {},
+  "Bonsai Icon": {},
+  Bonsai: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  "Globe Single Line": {},
+  "Card Back": {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  Knickknack: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  },
+  Globe: {},
+  Card: {
+    reducedMotion: "boolean",
+    Icon: "artboard",
+    Illustration: "artboard",
+    AnimationState: "number",
+    PowerMeter: "number",
+    LVL: "string",
+    PersonaName: "string",
+    "id#": "string",
+    Outof: "string",
+    FillColor: "color"
+  }
+};
+const artboardViewModelInstances = {
+  Main: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  Cassette: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Cassette Icon": [],
+  Cat: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Cat Icon": [],
+  Banana: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Banana Icon": [],
+  "Duck Icon": [],
+  Duck: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Snail Icon": [],
+  Snail: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Origami Icon": [],
+  Origami: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Disco Icon": [],
+  Disco: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  Capybara: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Capybara Icon": [],
+  Donut: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Donut Icon": [],
+  "Bonsai Icon": [],
+  Bonsai: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  "Globe Single Line": [],
+  "Card Back": ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  Knickknack: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"],
+  Globe: [],
+  Card: ["Bonsai", "Cassette-reducedMotion", "Cat-reducedMotion", "Banana-reducedMotion", "Duck-reducedMotion", "Snail-reducedMotion", "Origami-reducedMotion", "Disco-reducedMotion", "Capybara-reducedMotion", "Donut-reducedMotion", "Bonsai-reducedMotion", "Donut", "Capybara", "Disco", "Origami", "Snail", "Duck", "Banana", "Cat", "Cassette"]
+};
+let c2266_9 = {
+  Main: function MainBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Cassette: function CassetteBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Cat: function CatBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Banana: function BananaBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Duck: function DuckBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Snail: function SnailBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Origami: function OrigamiBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Disco: function DiscoBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Capybara: function CapybaraBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Donut: function DonutBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Bonsai: function BonsaiBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  "Card Back": function CardBackBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Knickknack: function KnickknackBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  },
+  Card: function CardBindings({ instance, reducedMotionEnabled, file, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useArtboardBinding("Icon", instance, file, dataBinding2?.Icon, playIfNeeded);
+    useArtboardBinding("Illustration", instance, file, dataBinding2?.Illustration, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("PowerMeter", instance, dataBinding2?.PowerMeter, onDataBindingChange2?.PowerMeter, playIfNeeded);
+    useStringBinding("LVL", instance, dataBinding2?.LVL, onDataBindingChange2?.LVL, playIfNeeded);
+    useStringBinding("PersonaName", instance, dataBinding2?.PersonaName, onDataBindingChange2?.PersonaName, playIfNeeded);
+    useStringBinding("id#", instance, dataBinding2 == null ? void 0 : dataBinding2["id#"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["id#"], playIfNeeded);
+    useStringBinding("Outof", instance, dataBinding2?.Outof, onDataBindingChange2?.Outof, playIfNeeded);
+    useColorBinding("FillColor", instance, dataBinding2?.FillColor, onDataBindingChange2?.FillColor, playIfNeeded);
+    return null;
+  }
+};
+CheckpointCardRiveInner = forwardRef(function CheckpointCardRiveInner(props, a1) {
+  props.fallback;
+  const { artboard = "Main", stateMachine, defaultViewModelInstance: defaultViewModelInstance2 = "Bonsai", dataBinding, onDataBindingChange, ...rest } = props;
+  return <BaseRive ref={a1} src={Module3977} artboard={artboard} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance2} stateMachine={stateMachine} renderDataBinding={useCallback((a0) => {
+    const Component = c2266_9[artboard];
+    return Component != null ? <Component {...a0} dataBinding={dataBinding} onDataBindingChange={onDataBindingChange} /> : null;
+  }, [artboard, dataBinding, onDataBindingChange])} {...rest} />;
+});
+const r95 = forwardRef(function CheckpointCardRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <CheckpointCardRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r95 as CheckpointCardRive };

_bundle/CheckpointFriendsRiveInner.jsx

@@ -0,0 +1,319 @@
+// Metro module 3978 (f3979).
+import { forwardRef, useCallback } from "react";
+import { useBooleanBinding, useNumberBinding, useColorBinding, useStringBinding, useImageBinding, BaseRive } from "./Module3918";
+import Module3979 from "./Module3979";
+import { RiveErrorBoundary } from "./Module3969";
+let CheckpointFriendsRiveInner;
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance", "dataBinding", "onDataBindingChange"];
+const artboardProperties = {
+  MAIN: {
+    reducedMotion: "boolean",
+    twoFriends: "boolean",
+    AnimationState: "number",
+    "Avatar01/ShadowVisibility": "number",
+    "Avatar01/StrokeVisibility": "number",
+    "Avatar01/UsernameVisibility": "number",
+    "Avatar01/Stroke": "color",
+    "Avatar01/Fill": "color",
+    "Avatar01/Username": "string",
+    "Avatar01/img": "image",
+    "Avatar02/ShadowVisibility": "number",
+    "Avatar02/StrokeVisibility": "number",
+    "Avatar02/UsernameVisibility": "number",
+    "Avatar02/Stroke": "color",
+    "Avatar02/Fill": "color",
+    "Avatar02/Username": "string",
+    "Avatar02/img": "image",
+    "Avatar03/ShadowVisibility": "number",
+    "Avatar03/StrokeVisibility": "number",
+    "Avatar03/UsernameVisibility": "number",
+    "Avatar03/Stroke": "color",
+    "Avatar03/Fill": "color",
+    "Avatar03/Username": "string",
+    "Avatar03/img": "image",
+    "Avatar04/ShadowVisibility": "number",
+    "Avatar04/StrokeVisibility": "number",
+    "Avatar04/UsernameVisibility": "number",
+    "Avatar04/Stroke": "color",
+    "Avatar04/Fill": "color",
+    "Avatar04/Username": "string",
+    "Avatar04/img": "image",
+    "Avatar05/ShadowVisibility": "number",
+    "Avatar05/StrokeVisibility": "number",
+    "Avatar05/UsernameVisibility": "number",
+    "Avatar05/Stroke": "color",
+    "Avatar05/Fill": "color",
+    "Avatar05/Username": "string",
+    "Avatar05/img": "image",
+    ConnectorColor: "color"
+  },
+  Sidekick: {
+    reducedMotion: "boolean",
+    twoFriends: "boolean",
+    AnimationState: "number",
+    "Avatar01/ShadowVisibility": "number",
+    "Avatar01/StrokeVisibility": "number",
+    "Avatar01/UsernameVisibility": "number",
+    "Avatar01/Stroke": "color",
+    "Avatar01/Fill": "color",
+    "Avatar01/Username": "string",
+    "Avatar01/img": "image",
+    "Avatar02/ShadowVisibility": "number",
+    "Avatar02/StrokeVisibility": "number",
+    "Avatar02/UsernameVisibility": "number",
+    "Avatar02/Stroke": "color",
+    "Avatar02/Fill": "color",
+    "Avatar02/Username": "string",
+    "Avatar02/img": "image",
+    "Avatar03/ShadowVisibility": "number",
+    "Avatar03/StrokeVisibility": "number",
+    "Avatar03/UsernameVisibility": "number",
+    "Avatar03/Stroke": "color",
+    "Avatar03/Fill": "color",
+    "Avatar03/Username": "string",
+    "Avatar03/img": "image",
+    "Avatar04/ShadowVisibility": "number",
+    "Avatar04/StrokeVisibility": "number",
+    "Avatar04/UsernameVisibility": "number",
+    "Avatar04/Stroke": "color",
+    "Avatar04/Fill": "color",
+    "Avatar04/Username": "string",
+    "Avatar04/img": "image",
+    "Avatar05/ShadowVisibility": "number",
+    "Avatar05/StrokeVisibility": "number",
+    "Avatar05/UsernameVisibility": "number",
+    "Avatar05/Stroke": "color",
+    "Avatar05/Fill": "color",
+    "Avatar05/Username": "string",
+    "Avatar05/img": "image",
+    ConnectorColor: "color"
+  },
+  Avatar: {
+    ShadowVisibility: "number",
+    StrokeVisibility: "number",
+    UsernameVisibility: "number",
+    Stroke: "color",
+    Fill: "color",
+    Username: "string",
+    img: "image"
+  },
+  Username: {
+    ShadowVisibility: "number",
+    StrokeVisibility: "number",
+    UsernameVisibility: "number",
+    Stroke: "color",
+    Fill: "color",
+    Username: "string",
+    img: "image"
+  },
+  "Friends 01 Rotation": {
+    reducedMotion: "boolean",
+    twoFriends: "boolean",
+    AnimationState: "number",
+    "Avatar01/ShadowVisibility": "number",
+    "Avatar01/StrokeVisibility": "number",
+    "Avatar01/UsernameVisibility": "number",
+    "Avatar01/Stroke": "color",
+    "Avatar01/Fill": "color",
+    "Avatar01/Username": "string",
+    "Avatar01/img": "image",
+    "Avatar02/ShadowVisibility": "number",
+    "Avatar02/StrokeVisibility": "number",
+    "Avatar02/UsernameVisibility": "number",
+    "Avatar02/Stroke": "color",
+    "Avatar02/Fill": "color",
+    "Avatar02/Username": "string",
+    "Avatar02/img": "image",
+    "Avatar03/ShadowVisibility": "number",
+    "Avatar03/StrokeVisibility": "number",
+    "Avatar03/UsernameVisibility": "number",
+    "Avatar03/Stroke": "color",
+    "Avatar03/Fill": "color",
+    "Avatar03/Username": "string",
+    "Avatar03/img": "image",
+    "Avatar04/ShadowVisibility": "number",
+    "Avatar04/StrokeVisibility": "number",
+    "Avatar04/UsernameVisibility": "number",
+    "Avatar04/Stroke": "color",
+    "Avatar04/Fill": "color",
+    "Avatar04/Username": "string",
+    "Avatar04/img": "image",
+    "Avatar05/ShadowVisibility": "number",
+    "Avatar05/StrokeVisibility": "number",
+    "Avatar05/UsernameVisibility": "number",
+    "Avatar05/Stroke": "color",
+    "Avatar05/Fill": "color",
+    "Avatar05/Username": "string",
+    "Avatar05/img": "image",
+    ConnectorColor: "color"
+  }
+};
+const artboardViewModelInstances = {
+  MAIN: ["threeFriends", "twoFriends-reducedMotion", "threeFriends-reducedMotion", "twoFriends"],
+  Sidekick: ["threeFriends", "twoFriends-reducedMotion", "threeFriends-reducedMotion", "twoFriends"],
+  Avatar: ["Instance 03", "Instance 05", "Instance 04", "Instance 02", "Instance 01"],
+  Username: ["Instance 03", "Instance 05", "Instance 04", "Instance 02", "Instance 01"],
+  "Friends 01 Rotation": ["threeFriends", "twoFriends-reducedMotion", "threeFriends-reducedMotion", "twoFriends"]
+};
+let c2267_9 = {
+  MAIN: function MAINBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useBooleanBinding("twoFriends", instance, dataBinding2?.twoFriends, onDataBindingChange2?.twoFriends, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("Avatar01/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar01/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar01/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar01/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Stroke"], playIfNeeded);
+    useColorBinding("Avatar01/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Fill"], playIfNeeded);
+    useStringBinding("Avatar01/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Username"], playIfNeeded);
+    useImageBinding("Avatar01/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/img"], playIfNeeded);
+    useNumberBinding("Avatar02/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar02/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar02/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar02/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Stroke"], playIfNeeded);
+    useColorBinding("Avatar02/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Fill"], playIfNeeded);
+    useStringBinding("Avatar02/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Username"], playIfNeeded);
+    useImageBinding("Avatar02/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/img"], playIfNeeded);
+    useNumberBinding("Avatar03/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar03/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar03/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar03/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Stroke"], playIfNeeded);
+    useColorBinding("Avatar03/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Fill"], playIfNeeded);
+    useStringBinding("Avatar03/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Username"], playIfNeeded);
+    useImageBinding("Avatar03/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/img"], playIfNeeded);
+    useNumberBinding("Avatar04/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar04/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar04/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar04/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Stroke"], playIfNeeded);
+    useColorBinding("Avatar04/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Fill"], playIfNeeded);
+    useStringBinding("Avatar04/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Username"], playIfNeeded);
+    useImageBinding("Avatar04/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/img"], playIfNeeded);
+    useNumberBinding("Avatar05/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar05/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar05/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar05/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Stroke"], playIfNeeded);
+    useColorBinding("Avatar05/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Fill"], playIfNeeded);
+    useStringBinding("Avatar05/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Username"], playIfNeeded);
+    useImageBinding("Avatar05/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/img"], playIfNeeded);
+    useColorBinding("ConnectorColor", instance, dataBinding2?.ConnectorColor, onDataBindingChange2?.ConnectorColor, playIfNeeded);
+    return null;
+  },
+  Sidekick: function SidekickBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useBooleanBinding("twoFriends", instance, dataBinding2?.twoFriends, onDataBindingChange2?.twoFriends, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("Avatar01/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar01/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar01/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar01/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Stroke"], playIfNeeded);
+    useColorBinding("Avatar01/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Fill"], playIfNeeded);
+    useStringBinding("Avatar01/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Username"], playIfNeeded);
+    useImageBinding("Avatar01/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/img"], playIfNeeded);
+    useNumberBinding("Avatar02/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar02/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar02/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar02/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Stroke"], playIfNeeded);
+    useColorBinding("Avatar02/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Fill"], playIfNeeded);
+    useStringBinding("Avatar02/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Username"], playIfNeeded);
+    useImageBinding("Avatar02/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/img"], playIfNeeded);
+    useNumberBinding("Avatar03/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar03/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar03/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar03/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Stroke"], playIfNeeded);
+    useColorBinding("Avatar03/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Fill"], playIfNeeded);
+    useStringBinding("Avatar03/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Username"], playIfNeeded);
+    useImageBinding("Avatar03/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/img"], playIfNeeded);
+    useNumberBinding("Avatar04/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar04/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar04/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar04/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Stroke"], playIfNeeded);
+    useColorBinding("Avatar04/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Fill"], playIfNeeded);
+    useStringBinding("Avatar04/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Username"], playIfNeeded);
+    useImageBinding("Avatar04/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/img"], playIfNeeded);
+    useNumberBinding("Avatar05/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar05/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar05/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar05/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Stroke"], playIfNeeded);
+    useColorBinding("Avatar05/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Fill"], playIfNeeded);
+    useStringBinding("Avatar05/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Username"], playIfNeeded);
+    useImageBinding("Avatar05/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/img"], playIfNeeded);
+    useColorBinding("ConnectorColor", instance, dataBinding2?.ConnectorColor, onDataBindingChange2?.ConnectorColor, playIfNeeded);
+    return null;
+  },
+  Avatar: function AvatarBindings({ instance, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useNumberBinding("ShadowVisibility", instance, dataBinding2?.ShadowVisibility, onDataBindingChange2?.ShadowVisibility, playIfNeeded);
+    useNumberBinding("StrokeVisibility", instance, dataBinding2?.StrokeVisibility, onDataBindingChange2?.StrokeVisibility, playIfNeeded);
+    useNumberBinding("UsernameVisibility", instance, dataBinding2?.UsernameVisibility, onDataBindingChange2?.UsernameVisibility, playIfNeeded);
+    useColorBinding("Stroke", instance, dataBinding2?.Stroke, onDataBindingChange2?.Stroke, playIfNeeded);
+    useColorBinding("Fill", instance, dataBinding2?.Fill, onDataBindingChange2?.Fill, playIfNeeded);
+    useStringBinding("Username", instance, dataBinding2?.Username, onDataBindingChange2?.Username, playIfNeeded);
+    useImageBinding("img", instance, dataBinding2?.img, onDataBindingChange2?.img, playIfNeeded);
+    return null;
+  },
+  Username: function UsernameBindings({ instance, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useNumberBinding("ShadowVisibility", instance, dataBinding2?.ShadowVisibility, onDataBindingChange2?.ShadowVisibility, playIfNeeded);
+    useNumberBinding("StrokeVisibility", instance, dataBinding2?.StrokeVisibility, onDataBindingChange2?.StrokeVisibility, playIfNeeded);
+    useNumberBinding("UsernameVisibility", instance, dataBinding2?.UsernameVisibility, onDataBindingChange2?.UsernameVisibility, playIfNeeded);
+    useColorBinding("Stroke", instance, dataBinding2?.Stroke, onDataBindingChange2?.Stroke, playIfNeeded);
+    useColorBinding("Fill", instance, dataBinding2?.Fill, onDataBindingChange2?.Fill, playIfNeeded);
+    useStringBinding("Username", instance, dataBinding2?.Username, onDataBindingChange2?.Username, playIfNeeded);
+    useImageBinding("img", instance, dataBinding2?.img, onDataBindingChange2?.img, playIfNeeded);
+    return null;
+  },
+  "Friends 01 Rotation": function Friends01RotationBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useBooleanBinding("twoFriends", instance, dataBinding2?.twoFriends, onDataBindingChange2?.twoFriends, playIfNeeded);
+    useNumberBinding("AnimationState", instance, dataBinding2?.AnimationState, onDataBindingChange2?.AnimationState, playIfNeeded);
+    useNumberBinding("Avatar01/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar01/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar01/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar01/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Stroke"], playIfNeeded);
+    useColorBinding("Avatar01/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Fill"], playIfNeeded);
+    useStringBinding("Avatar01/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/Username"], playIfNeeded);
+    useImageBinding("Avatar01/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar01/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar01/img"], playIfNeeded);
+    useNumberBinding("Avatar02/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar02/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar02/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar02/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Stroke"], playIfNeeded);
+    useColorBinding("Avatar02/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Fill"], playIfNeeded);
+    useStringBinding("Avatar02/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/Username"], playIfNeeded);
+    useImageBinding("Avatar02/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar02/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar02/img"], playIfNeeded);
+    useNumberBinding("Avatar03/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar03/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar03/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar03/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Stroke"], playIfNeeded);
+    useColorBinding("Avatar03/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Fill"], playIfNeeded);
+    useStringBinding("Avatar03/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/Username"], playIfNeeded);
+    useImageBinding("Avatar03/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar03/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar03/img"], playIfNeeded);
+    useNumberBinding("Avatar04/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar04/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar04/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar04/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Stroke"], playIfNeeded);
+    useColorBinding("Avatar04/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Fill"], playIfNeeded);
+    useStringBinding("Avatar04/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/Username"], playIfNeeded);
+    useImageBinding("Avatar04/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar04/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar04/img"], playIfNeeded);
+    useNumberBinding("Avatar05/ShadowVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/ShadowVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/ShadowVisibility"], playIfNeeded);
+    useNumberBinding("Avatar05/StrokeVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/StrokeVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/StrokeVisibility"], playIfNeeded);
+    useNumberBinding("Avatar05/UsernameVisibility", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/UsernameVisibility"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/UsernameVisibility"], playIfNeeded);
+    useColorBinding("Avatar05/Stroke", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Stroke"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Stroke"], playIfNeeded);
+    useColorBinding("Avatar05/Fill", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Fill"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Fill"], playIfNeeded);
+    useStringBinding("Avatar05/Username", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/Username"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/Username"], playIfNeeded);
+    useImageBinding("Avatar05/img", instance, dataBinding2 == null ? void 0 : dataBinding2["Avatar05/img"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["Avatar05/img"], playIfNeeded);
+    useColorBinding("ConnectorColor", instance, dataBinding2?.ConnectorColor, onDataBindingChange2?.ConnectorColor, playIfNeeded);
+    return null;
+  }
+};
+CheckpointFriendsRiveInner = forwardRef(function CheckpointFriendsRiveInner(props, a1) {
+  props.fallback;
+  const { artboard = "MAIN", stateMachine, defaultViewModelInstance: defaultViewModelInstance2 = "threeFriends", dataBinding, onDataBindingChange, ...rest } = props;
+  return <BaseRive ref={a1} src={Module3979} artboard={artboard} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance2} stateMachine={stateMachine} renderDataBinding={useCallback((a0) => {
+    const Component = c2267_9[artboard];
+    return Component != null ? <Component {...a0} dataBinding={dataBinding} onDataBindingChange={onDataBindingChange} /> : null;
+  }, [artboard, dataBinding, onDataBindingChange])} {...rest} />;
+});
+const r44 = forwardRef(function CheckpointFriendsRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <CheckpointFriendsRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r44 as CheckpointFriendsRive };

_bundle/CheckpointIntroRiveInner.jsx

@@ -0,0 +1,59 @@
+// Metro module 3980 (f3981).
+import { forwardRef, useCallback } from "react";
+import { useBooleanBinding, useStringBinding, BaseRive } from "./Module3918";
+import Module3981 from "./Module3981";
+import { RiveErrorBoundary } from "./Module3969";
+let CheckpointIntroRiveInner;
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance", "dataBinding", "onDataBindingChange"];
+const artboardProperties = {
+  "Checkpoint Intro Desktop": {
+    reducedMotion: "boolean",
+    Subtitle: "string",
+    "StartButton Pressed": "boolean",
+    StartButton: "string"
+  },
+  Globe: {},
+  "Globe Single Line": {},
+  "Start Button": {
+    reducedMotion: "boolean",
+    Subtitle: "string",
+    "StartButton Pressed": "boolean",
+    StartButton: "string"
+  }
+};
+const artboardViewModelInstances = {
+  "Checkpoint Intro Desktop": ["default", "reducedMotion"],
+  Globe: [],
+  "Globe Single Line": [],
+  "Start Button": ["default", "reducedMotion"]
+};
+let c2268_9 = {
+  "Checkpoint Intro Desktop": function CheckpointIntroDesktopBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useStringBinding("Subtitle", instance, dataBinding2?.Subtitle, onDataBindingChange2?.Subtitle, playIfNeeded);
+    useBooleanBinding("StartButton Pressed", instance, dataBinding2 == null ? void 0 : dataBinding2["StartButton Pressed"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["StartButton Pressed"], playIfNeeded);
+    useStringBinding("StartButton", instance, dataBinding2?.StartButton, onDataBindingChange2?.StartButton, playIfNeeded);
+    return null;
+  },
+  "Start Button": function StartButtonBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useStringBinding("Subtitle", instance, dataBinding2?.Subtitle, onDataBindingChange2?.Subtitle, playIfNeeded);
+    useBooleanBinding("StartButton Pressed", instance, dataBinding2 == null ? void 0 : dataBinding2["StartButton Pressed"], onDataBindingChange2 == null ? void 0 : onDataBindingChange2["StartButton Pressed"], playIfNeeded);
+    useStringBinding("StartButton", instance, dataBinding2?.StartButton, onDataBindingChange2?.StartButton, playIfNeeded);
+    return null;
+  }
+};
+CheckpointIntroRiveInner = forwardRef(function CheckpointIntroRiveInner(props, a1) {
+  props.fallback;
+  const { artboard = "Checkpoint Intro Desktop", stateMachine, defaultViewModelInstance: defaultViewModelInstance2 = "default", dataBinding, onDataBindingChange, ...rest } = props;
+  return <BaseRive ref={a1} src={Module3981} artboard={artboard} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance2} stateMachine={stateMachine} renderDataBinding={useCallback((a0) => {
+    const Component = c2268_9[artboard];
+    return Component != null ? <Component {...a0} dataBinding={dataBinding} onDataBindingChange={onDataBindingChange} /> : null;
+  }, [artboard, dataBinding, onDataBindingChange])} {...rest} />;
+});
+const r39 = forwardRef(function CheckpointIntroRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <CheckpointIntroRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r39 as CheckpointIntroRive };

_bundle/CheckpointKnickKnacksRiveInner.jsx

@@ -0,0 +1,159 @@
+// Metro module 3982 (f3983).
+import { forwardRef, useCallback } from "react";
+import { useBooleanBinding, useColorBinding, BaseRive } from "./Module3918";
+import Module3983 from "./Module3983";
+import { RiveErrorBoundary } from "./Module3969";
+let CheckpointKnickKnacksRiveInner;
+const _excluded = ["fallback", "artboard", "stateMachine", "defaultViewModelInstance", "dataBinding", "onDataBindingChange"];
+const artboardProperties = {
+  Preview: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Friends: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Globe: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  "Globe Single Line": {},
+  Emojis: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  "Wave Line": {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Games: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Voice: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  "Looping Checkboard": {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  CheckRow: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Quests: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Entry: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Messages: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  },
+  Servers: {
+    reducedMotion: "boolean",
+    iconColor: "color"
+  }
+};
+const artboardViewModelInstances = {
+  Preview: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Friends: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Globe: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  "Globe Single Line": [],
+  Emojis: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  "Wave Line": ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Games: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Voice: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  "Looping Checkboard": ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  CheckRow: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Quests: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Entry: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Messages: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"],
+  Servers: ["Pink", "Orange", "Green", "Lavender", "Yellow", "Cyan"]
+};
+let c2269_9 = {
+  Preview: function PreviewBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Friends: function FriendsBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Globe: function GlobeBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Emojis: function EmojisBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  "Wave Line": function WaveLineBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Games: function GamesBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Voice: function VoiceBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  "Looping Checkboard": function LoopingCheckboardBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  CheckRow: function CheckRowBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Quests: function QuestsBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Entry: function EntryBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Messages: function MessagesBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  },
+  Servers: function ServersBindings({ instance, reducedMotionEnabled, dataBinding: dataBinding2, onDataBindingChange: onDataBindingChange2, playIfNeeded }) {
+    useBooleanBinding("reducedMotion", instance, reducedMotionEnabled, void 0, playIfNeeded);
+    useColorBinding("iconColor", instance, dataBinding2?.iconColor, onDataBindingChange2?.iconColor, playIfNeeded);
+    return null;
+  }
+};
+CheckpointKnickKnacksRiveInner = forwardRef(function CheckpointKnickKnacksRiveInner(props, a1) {
+  props.fallback;
+  const { artboard = "Preview", stateMachine, defaultViewModelInstance: defaultViewModelInstance2 = "Pink", dataBinding, onDataBindingChange, ...rest } = props;
+  return <BaseRive ref={a1} src={Module3983} artboard={artboard} artboardProperties={artboardProperties} artboardViewModelInstances={artboardViewModelInstances} defaultViewModelInstance={defaultViewModelInstance2} stateMachine={stateMachine} renderDataBinding={useCallback((a0) => {
+    const Component = c2269_9[artboard];
+    return Component != null ? <Component {...a0} dataBinding={dataBinding} onDataBindingChange={onDataBindingChange} /> : null;
+  }, [artboard, dataBinding, onDataBindingChange])} {...rest} />;
+});
+const r70 = forwardRef(function CheckpointKnickKnacksRiveWithBoundary(props, a1) {
+  return <RiveErrorBoundary fallback={props.fallback}>
+    <CheckpointKnickKnacksRiveInner ref={a1} {...props} />
+  </RiveErrorBoundary>;
+});
+export { r70 as CheckpointKnickKnacksRive };

_bundle/ChildListCollection.js

@@ -0,0 +1,76 @@
+// Metro module 316 (f317).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import Module38 from "./Module38";
+let env328 = {};
+const ChildListCollection = function ChildListCollection() {
+  _classCallCheck(this, ChildListCollection);
+  this._cellKeyToChildren = new Map();
+  this._childrenToCellKey = new Map();
+};
+export default _createClass(ChildListCollection, [{
+  key: "add",
+  value: function add(a0, a1) {
+    Module38(!this._childrenToCellKey.has(a0), "Trying to add already present child list");
+    let r20 = this._cellKeyToChildren.get(a1);
+    if (r20 == null) {
+      r20 = new Set();
+    }
+    r20.add(a0);
+    this._cellKeyToChildren.set(a1, r20);
+    this._childrenToCellKey.set(a0, a1);
+  }
+}, {
+  key: "remove",
+  value: function remove(a0) {
+    const r10 = this._childrenToCellKey.get(a0);
+    Module38(r10 != null, "Trying to remove non-present child list");
+    this._childrenToCellKey.delete(a0);
+    const r21 = this._cellKeyToChildren.get(r10);
+    Module38(r21, "_cellKeyToChildren should contain cellKey");
+    r21.delete(a0);
+    if (r21.size === 0) {
+      this._cellKeyToChildren.delete(r10);
+    }
+  }
+}, {
+  key: "forEach",
+  value: function forEach(a0) {
+    for (const item of this._cellKeyToChildren.values()) {
+      for (const item2 of item) {
+        a0(item2);
+      }
+    }
+  }
+}, {
+  key: "forEachInCell",
+  value: function forEachInCell(a0, a1) {
+    let r18 = this._cellKeyToChildren.get(a0);
+    if (r18 == null) {
+      r18 = [];
+    }
+    for (const item of r18) {
+      a1(item);
+    }
+  }
+}, {
+  key: "anyInCell",
+  value: function anyInCell(a0, a1) {
+    let r18 = this._cellKeyToChildren.get(a0);
+    if (r18 == null) {
+      r18 = [];
+    }
+    for (const item of r18) {
+      if (!a1(item)) {
+        continue;
+      }
+      return true;
+    }
+    return false;
+  }
+}, {
+  key: "size",
+  value: function size() {
+    return this._childrenToCellKey.size;
+  }
+}]);

_bundle/Circle.jsx

@@ -0,0 +1,43 @@
+// Metro module 8559 (f8560).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import { extract } from "./extractProps";
+import Module8560 from "./Module8560";
+import SVGMatrix from "./SVGMatrix";
+let Circle;
+let env5491 = {};
+env5491[7] = function _isNativeReflectConstruct() {
+  let c16634_0;
+  try {
+    c16634_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c16634_0;
+  };
+  env5491[7] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+Circle = function Circle() {
+  _classCallCheck(this, Circle);
+  const r8 = _getPrototypeOf(Circle);
+  return _possibleConstructorReturn(this, (0, env5491[7])() ? Reflect.construct(r8, arguments, _getPrototypeOf(this).constructor) : r8.apply(this, arguments));
+};
+_inherits(Circle, SVGMatrix);
+const r37 = _createClass(Circle, [{
+  key: "render",
+  value: function render() {
+    const props = this.props;
+    const { cx, cy, r: r3 } = props;
+    return <Module8560 ref={(a0) => this.refMethod(a0)} {...extract(this, props)} cx={cx} cy={cy} r={r3} />;
+  }
+}]);
+r37.displayName = "Circle";
+r37.defaultProps = {
+  cx: 0,
+  cy: 0,
+  r: 0
+};
+export default r37;

_bundle/CircularProgress.jsx

@@ -0,0 +1,147 @@
+// Metro module 14085 (f14086).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import Module19 from "react";
+import { Animated, View } from "react-native";
+import { Path, Svg, G } from "./Module8531";
+import Module12253 from "./Module12253";
+let CircularProgress;
+let env9850 = {};
+env9850[8] = function _isNativeReflectConstruct() {
+  let c20890_0;
+  try {
+    c20890_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c20890_0;
+  };
+  env9850[8] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+const PureComponent = Module19.PureComponent;
+CircularProgress = function CircularProgress(...args) {
+  _classCallCheck(this, CircularProgress);
+  const r9 = [...args];
+  const r8 = _getPrototypeOf(CircularProgress);
+  const r26 = _possibleConstructorReturn(this, (0, env9850[8])() ? Reflect.construct(r8, r9, _getPrototypeOf(this).constructor) : r8.apply(this, r9));
+  r26.clampFill = (a0) => Math.min(100, Math.max(0, a0));
+  return r26;
+};
+_inherits(CircularProgress, PureComponent);
+const r45 = _createClass(CircularProgress, [{
+  key: "polarToCartesian",
+  value: function polarToCartesian(a0, a1, a2, a3) {
+    const r11 = (a3 - 90) * Math.PI / 180;
+    return {
+      x: a0 + a2 * Math.cos(r11),
+      y: a1 + a2 * Math.sin(r11)
+    };
+  }
+}, {
+  key: "circlePath",
+  value: function circlePath(a0, a1, a2, a3, a4) {
+    const r5 = this.polarToCartesian(a0, a1, a2, 0.9999999 * a4);
+    const r20 = this.polarToCartesian(a0, a1, a2, a3);
+    return ["M", r5.x, r5.y, "A", a2, a2, 0, a4 - a3 <= 180 ? "0" : "1", 0, r20.x, r20.y].join(" ");
+  }
+}, {
+  key: "render",
+  value: function render() {
+    const props = this.props;
+    const { size, width } = props;
+    let backgroundWidth = props.backgroundWidth;
+    const { tintColor, tintTransparency, backgroundColor, style, rotation, lineCap, fillLineCap = lineCap, arcSweepAngle, fill, children, childrenContainerStyle, padding } = props;
+    props.renderCap;
+    const { dashedBackground, dashedTint } = props;
+    const r45 = backgroundWidth ? Math.max(width, backgroundWidth) : width;
+    const r6 = size / 2;
+    const r1 = padding / 2;
+    const r7 = size / 2;
+    const r0 = r45 / 2;
+    const r8 = padding / 2;
+    const r5 = arcSweepAngle * this.clampFill(fill) / 100;
+    const circlePath2 = this.circlePath;
+    const r4 = tintTransparency ? 0 : r5;
+    const r52 = r6 + r1;
+    const r54 = r7 - r0 - r8;
+    const r37 = circlePath2.call(this, r52, r52, r54, r4, arcSweepAngle);
+    const r31 = this.circlePath(r52, r52, r54, 0, r5);
+    const center = this.polarToCartesian(r52, r52, r54, r5);
+    const r71 = this.props.renderCap ? this.props.renderCap({
+      center
+    }) : null;
+    const width2 = size - 2 * r45;
+    const style2 = {
+      position: "absolute",
+      left: r45 + padding / 2,
+      top: r45 + padding / 2,
+      width: width2,
+      height: width2,
+      borderRadius: width2 / 2,
+      alignItems: "center",
+      justifyContent: "center",
+      overflow: "hidden",
+      ...childrenContainerStyle
+    };
+    const strokeDasharray = dashedTint.gap > 0 ? Object.values(dashedTint).map((item) => parseInt(item)) : null;
+    const strokeDasharray2 = dashedBackground.gap > 0 ? Object.values(dashedBackground).map((item) => parseInt(item)) : null;
+    let r120 = backgroundColor;
+    if (r120) {
+      if (!backgroundWidth) {
+        backgroundWidth = width;
+      }
+      r120 = <Path d={r37} stroke={backgroundColor} strokeWidth={backgroundWidth} strokeLinecap={lineCap} strokeDasharray={strokeDasharray2} fill="transparent" />;
+    }
+    return <View style={style}>
+      <Svg width={size + padding} height={size + padding}>
+        <G rotation={rotation} originX={(size + padding) / 2} originY={(size + padding) / 2}>
+          {r120}
+          {fill > 0 && <Path d={r31} stroke={tintColor} strokeWidth={width} strokeLinecap={fillLineCap} strokeDasharray={strokeDasharray} fill="transparent" />}
+          {r71}
+        </G>
+      </Svg>
+      {children && <View style={style2}>
+        {children(fill)}
+      </View>}
+    </View>;
+  }
+}]);
+r45.propTypes = {
+  style: Module12253.object,
+  size: Module12253.oneOfType([Module12253.number, Module12253.instanceOf(Animated.Value)]).isRequired,
+  fill: Module12253.number.isRequired,
+  width: Module12253.number.isRequired,
+  backgroundWidth: Module12253.number,
+  tintColor: Module12253.string,
+  tintTransparency: Module12253.bool,
+  backgroundColor: Module12253.string,
+  rotation: Module12253.number,
+  lineCap: Module12253.string,
+  arcSweepAngle: Module12253.number,
+  children: Module12253.func,
+  childrenContainerStyle: Module12253.object,
+  padding: Module12253.number,
+  renderCap: Module12253.func,
+  dashedBackground: Module12253.object,
+  dashedTint: Module12253.object
+};
+r45.defaultProps = {
+  tintColor: "black",
+  tintTransparency: true,
+  rotation: 90,
+  lineCap: "butt",
+  arcSweepAngle: 360,
+  padding: 0,
+  dashedBackground: {
+    width: 0,
+    gap: 0
+  },
+  dashedTint: {
+    width: 0,
+    gap: 0
+  }
+};
+export default r45;

_bundle/ClipPath.jsx

@@ -0,0 +1,37 @@
+// Metro module 8561 (f8562).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import Module8562 from "./Module8562";
+import { extract } from "./extractProps";
+import SVGMatrix from "./SVGMatrix";
+let ClipPath;
+let env5494 = {};
+env5494[7] = function _isNativeReflectConstruct() {
+  let c16635_0;
+  try {
+    c16635_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c16635_0;
+  };
+  env5494[7] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+ClipPath = function ClipPath() {
+  _classCallCheck(this, ClipPath);
+  const r8 = _getPrototypeOf(ClipPath);
+  return _possibleConstructorReturn(this, (0, env5494[7])() ? Reflect.construct(r8, arguments, _getPrototypeOf(this).constructor) : r8.apply(this, arguments));
+};
+_inherits(ClipPath, SVGMatrix);
+const r37 = _createClass(ClipPath, [{
+  key: "render",
+  value: function render() {
+    const props = this.props;
+    return <Module8562 ref={this.refMethod} {...extract(this, props)}>{props.children}</Module8562>;
+  }
+}]);
+r37.displayName = "ClipPath";
+export default r37;

_bundle/CloseEvent.js

@@ -0,0 +1,47 @@
+// Metro module 221 (f222).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import Event2 from "./Event";
+let CloseEvent;
+let env239 = {};
+env239[3] = function _isNativeReflectConstruct() {
+  let c12209_0;
+  try {
+    c12209_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c12209_0;
+  };
+  env239[3] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+CloseEvent = function CloseEvent(a0, a1) {
+  _classCallCheck(this, CloseEvent);
+  const r12 = [a0, a1];
+  const r11 = _getPrototypeOf(CloseEvent);
+  const r25 = _possibleConstructorReturn(this, (0, env239[3])() ? Reflect.construct(r11, r12, _getPrototypeOf(this).constructor) : r11.apply(this, r12));
+  r25._wasClean = Boolean(a1?.wasClean);
+  r25._code = Number(a1?.code) || 0;
+  r25._reason = a1?.reason != null ? String(a1.reason) : "";
+  return r25;
+};
+_inherits(CloseEvent, Event2);
+export default _createClass(CloseEvent, [{
+  key: "wasClean",
+  get: function get() {
+    return this._wasClean;
+  }
+}, {
+  key: "code",
+  get: function get() {
+    return this._code;
+  }
+}, {
+  key: "reason",
+  get: function get() {
+    return this._reason;
+  }
+}]);

_bundle/Color.js

@@ -0,0 +1,479 @@
+// Metro module 5612 (f5613).
+import * as _slicedToArray from "./_slicedToArray";
+import * as _Module5613 from "./Module5613";
+import * as _Module5617 from "./Module5617";
+import { get } from "./Module5617";
+let _excluded, c3458_4, c3458_5;
+const Color = function Color(a0, a1) {
+  let model = a1;
+  if (this instanceof Color) {
+    if (a1 ? a1 in _excluded : a1) {
+      model = null;
+    }
+    if (model && !(model in _Module5613)) {
+      throw new Error("Unknown model: " + model);
+    }
+    if (a0 == null) {
+      this.model = "rgb";
+      this.color = [0, 0, 0];
+      this.valpha = 1;
+    } else if (a0 instanceof Color) {
+      this.model = a0.model;
+      this.color = [...a0.color];
+      this.valpha = a0.valpha;
+    } else if (typeof a0 === "string") {
+      const r120 = get(a0);
+      if (r120 === null) {
+        throw new Error("Unable to parse color from string: " + a0);
+      }
+      this.model = r120.model;
+      const channels3 = _Module5613[this.model].channels;
+      this.color = r120.value.slice(0, channels3);
+      this.valpha = typeof r120.value[channels3] === "number" ? r120.value[channels3] : 1;
+    } else if (a0.length > 0) {
+      if (!model) {
+        model = "rgb";
+      }
+      this.model = model;
+      const channels2 = _Module5613[this.model].channels;
+      const color2 = Array.prototype.slice.call(a0, 0, channels2);
+      const r108 = 0 < channels2;
+      let valpha = 1;
+      let r110 = 0;
+      if (r108) {
+        do {
+          const r111 = color2[r110];
+          const r112 = r110;
+          if (typeof r111 !== "number") {
+            color2[r112] = 0;
+          }
+          r110 = r112 + 1;
+        } while (r110 < channels2);
+      }
+      this.color = color2;
+      if (typeof a0[channels2] === "number") {
+        valpha = a0[channels2];
+      }
+      this.valpha = valpha;
+    } else if (typeof a0 === "number") {
+      this.model = "rgb";
+      this.color = [a0 >> 16 & 255, a0 >> 8 & 255, 255 & a0];
+      this.valpha = 1;
+    } else {
+      this.valpha = 1;
+      const r40 = Object.keys(a0);
+      if ("alpha" in a0) {
+        r40.splice(r40.indexOf("alpha"), 1);
+        this.valpha = typeof a0.alpha === "number" ? a0.alpha : 0;
+      }
+      const r52 = r40.sort().join("");
+      if (!(r52 in c3458_4)) {
+        throw new Error("Unable to parse color from object: " + JSON.stringify(a0));
+      }
+      this.model = c3458_4[r52];
+      const labels = _Module5613[this.model].labels;
+      const color = [];
+      const r6 = 0 < labels.length;
+      let r0 = 0;
+      if (r6) {
+        do {
+          color.push(a0[labels[r0]]);
+          r0 = r0 + 1;
+        } while (r0 < labels.length);
+      }
+      let r81 = 0;
+      while (r81 < void 0) {
+        const r82 = color[r81];
+        const r3 = r81;
+        if (typeof r82 !== "number") {
+          color[r3] = 0;
+        }
+        r81 = r3 + 1;
+      }
+      this.color = color;
+    }
+    if (c3458_5[this.model]) {
+      const channels4 = _Module5613[this.model].channels;
+      let r162 = 0;
+      while (r162 < channels4) {
+        const r168 = c3458_5[this.model][r162];
+        const r169 = r162;
+        if (r168) {
+          this.color[r169] = r168(this.color[r169]);
+        }
+        r162 = r169 + 1;
+      }
+    }
+    this.valpha = Math.max(0, Math.min(1, this.valpha));
+    if (Object.freeze) {
+      Object.freeze(this);
+    }
+    return void 0;
+  }
+  const r13 = {
+    __proto__: Color.prototype
+  };
+  const r20 = Color.call(r13, a0, a1);
+  return r20 instanceof Object ? r20 : r13;
+};
+_excluded = ["keyword", "gray", "hex"];
+c3458_4 = {};
+for (const item of Object.keys(_Module5613)) {
+  c3458_4[[..._Module5613[item].labels].sort().join("")] = item;
+}
+const getset = function getset(a0, a1, a2) {
+  let c14944_0 = a0;
+  const r26 = Array.isArray(a0) ? a0 : [a0];
+  c14944_0 = r26;
+  for (const item of r26) {
+    let r33 = c3458_5[item];
+    if (!r33) {
+      const r34 = [];
+      c3458_5[item] = r34;
+      r33 = r34;
+    }
+    r33[a1] = a2;
+  }
+  c14944_0 = r26[0];
+  return function(a0) {
+    let r11;
+    if (a0 !== void 0) {
+      const r13 = a2 ? a2(a0) : a0;
+      const r16 = this[c14944_0]();
+      r16.color[a1] = r13;
+      r11 = r16;
+    } else {
+      const r5 = this[c14944_0]().color[a1];
+      r11 = a2 ? a2(r5) : r5;
+    }
+    return r11;
+  };
+};
+const maxfn = function maxfn(c14945_0) {
+  return function(a0) {
+    return Math.max(0, Math.min(c14945_0, a0));
+  };
+};
+c3458_5 = {};
+Color.prototype = {
+  toString: function toString() {
+    return this.string();
+  },
+  toJSON: function toJSON() {
+    return this[this.model]();
+  },
+  string: function string(a0) {
+    const r8 = this.model in _Module5617.to ? this : this.rgb();
+    const r19 = r8.round.call(r8, typeof a0 === "number" ? a0 : 1);
+    return _Module5617.to[r19.model](r19.valpha === 1 ? r19.color : [...r19.color, this.valpha]);
+  },
+  percentString: function percentString(a0) {
+    const r11 = this.rgb().round(typeof a0 === "number" ? a0 : 1);
+    return _Module5617.to.rgb.percent(r11.valpha === 1 ? r11.color : [...r11.color, this.valpha]);
+  },
+  array: function array() {
+    return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha];
+  },
+  object: function object() {
+    const r4 = {};
+    const channels2 = _Module5613[this.model].channels;
+    const labels = _Module5613[this.model].labels;
+    let r0 = 0;
+    while (r0 < channels2) {
+      r4[labels[r0]] = this.color[r0];
+      r0 = r0 + 1;
+    }
+    if (this.valpha !== 1) {
+      r4.alpha = this.valpha;
+    }
+    return r4;
+  },
+  unitArray: function unitArray() {
+    const color = this.rgb().color;
+    color[0] = color[0] / 255;
+    color[1] = color[1] / 255;
+    color[2] = color[2] / 255;
+    if (this.valpha !== 1) {
+      color.push(this.valpha);
+    }
+    return color;
+  },
+  unitObject: function unitObject() {
+    const r6 = this.rgb().object();
+    r6.r = r6.r / 255;
+    r6.g = r6.g / 255;
+    r6.b = r6.b / 255;
+    if (this.valpha !== 1) {
+      r6.alpha = this.valpha;
+    }
+    return r6;
+  },
+  round: function round(a0) {
+    let r5 = a0;
+    const r4 = Math;
+    if (!a0) {
+      r5 = 0;
+    }
+    const r6 = r4.max(r5, 0);
+    const color = this.color;
+    let c14946_0 = r6;
+    const r16 = [...color.map(function(item) {
+      return Number(item.toFixed(c14946_0));
+    }), this.valpha];
+    const model = this.model;
+    const r21 = {
+      __proto__: Color.prototype
+    };
+    const r22 = Color.call(r21, r16, model);
+    return r22 instanceof Object ? r22 : r21;
+  },
+  alpha: function alpha(a0) {
+    let r4;
+    if (a0 !== void 0) {
+      const r7 = [...this.color, Math.max(0, Math.min(1, a0))];
+      const model = this.model;
+      const r22 = {
+        __proto__: Color.prototype
+      };
+      const r23 = Color.call(r22, r7, model);
+      r4 = r23 instanceof Object ? r23 : r22;
+    } else {
+      r4 = this.valpha;
+    }
+    return r4;
+  },
+  red: getset("rgb", 0, maxfn(255)),
+  green: getset("rgb", 1, maxfn(255)),
+  blue: getset("rgb", 2, maxfn(255)),
+  hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, (a0) => (a0 % 360 + 360) % 360),
+  saturationl: getset("hsl", 1, maxfn(100)),
+  lightness: getset("hsl", 2, maxfn(100)),
+  saturationv: getset("hsv", 1, maxfn(100)),
+  value: getset("hsv", 2, maxfn(100)),
+  chroma: getset("hcg", 1, maxfn(100)),
+  gray: getset("hcg", 2, maxfn(100)),
+  white: getset("hwb", 1, maxfn(100)),
+  wblack: getset("hwb", 2, maxfn(100)),
+  cyan: getset("cmyk", 0, maxfn(100)),
+  magenta: getset("cmyk", 1, maxfn(100)),
+  yellow: getset("cmyk", 2, maxfn(100)),
+  black: getset("cmyk", 3, maxfn(100)),
+  x: getset("xyz", 0, maxfn(95.047)),
+  y: getset("xyz", 1, maxfn(100)),
+  z: getset("xyz", 2, maxfn(108.833)),
+  l: getset("lab", 0, maxfn(100)),
+  a: getset("lab", 1),
+  b: getset("lab", 2),
+  keyword: function keyword(a0) {
+    let r12;
+    if (a0 !== void 0) {
+      const r15 = {
+        __proto__: Color.prototype
+      };
+      const r16 = Color.call(r15, a0);
+      r12 = r16 instanceof Object ? r16 : r15;
+    } else {
+      r12 = _Module5613[this.model].keyword(this.color);
+    }
+    return r12;
+  },
+  hex: function hex(a0) {
+    let r15;
+    if (a0 !== void 0) {
+      const r18 = {
+        __proto__: Color.prototype
+      };
+      const r19 = Color.call(r18, a0);
+      r15 = r19 instanceof Object ? r19 : r18;
+    } else {
+      r15 = _Module5617.to.hex(this.rgb().round().color);
+    }
+    return r15;
+  },
+  hexa: function hexa(a0) {
+    if (a0 !== void 0) {
+      const r35 = {
+        __proto__: Color.prototype
+      };
+      const r36 = Color.call(r35, a0);
+      return r36 instanceof Object ? r36 : r35;
+    }
+    const color = this.rgb().round().color;
+    const r20 = Math.round(255 * this.valpha).toString(16).toUpperCase();
+    const r23 = r20.length === 1 ? "0" + r20 : r20;
+    return _Module5617.to.hex(color) + r23;
+  },
+  rgbNumber: function rgbNumber() {
+    const color = this.rgb().color;
+    return (255 & color[0]) << 16 | (255 & color[1]) << 8 | 255 & color[2];
+  },
+  luminosity: function luminosity() {
+    const color = this.rgb().color;
+    const r29 = [];
+    for (const item of color.entries()) {
+      const r37 = _slicedToArray(item, 2);
+      const r38 = r37[0];
+      const r40 = r37[1] / 255;
+      r29[r38] = r40 <= 0.04045 ? r40 / 12.92 : ((r40 + 0.055) / 1.055) ** 2.4;
+    }
+    return 0.2126 * r29[0] + 0.7152 * r29[1] + 0.0722 * r29[2];
+  },
+  contrast: function contrast(a0) {
+    const r6 = this.luminosity();
+    const r8 = a0.luminosity();
+    return r6 > r8 ? (r6 + 0.05) / (r8 + 0.05) : (r8 + 0.05) / (r6 + 0.05);
+  },
+  level: function level(a0) {
+    const r5 = this.contrast(a0);
+    return r5 >= 7 ? "AAA" : r5 >= 4.5 ? "AA" : "";
+  },
+  isDark: function isDark() {
+    const color = this.rgb().color;
+    return (2126 * color[0] + 7152 * color[1] + 722 * color[2]) / 10000 < 128;
+  },
+  isLight: function isLight() {
+    return !this.isDark();
+  },
+  negate: function negate() {
+    const r8 = this.rgb();
+    let r0 = 0;
+    while (true) {
+      r8.color[r0] = 255 - r8.color[r0];
+      r0 = r0 + 1;
+      if (!(r0 < 3)) {
+        return r8;
+      }
+    }
+  },
+  lighten: function lighten(a0) {
+    const r6 = this.hsl();
+    const color = r6.color;
+    color[2] = color[2] + r6.color[2] * a0;
+    return r6;
+  },
+  darken: function darken(a0) {
+    const r6 = this.hsl();
+    const color = r6.color;
+    color[2] = color[2] - r6.color[2] * a0;
+    return r6;
+  },
+  saturate: function saturate(a0) {
+    const r6 = this.hsl();
+    const color = r6.color;
+    color[1] = color[1] + r6.color[1] * a0;
+    return r6;
+  },
+  desaturate: function desaturate(a0) {
+    const r6 = this.hsl();
+    const color = r6.color;
+    color[1] = color[1] - r6.color[1] * a0;
+    return r6;
+  },
+  whiten: function whiten(a0) {
+    const r6 = this.hwb();
+    const color = r6.color;
+    color[1] = color[1] + r6.color[1] * a0;
+    return r6;
+  },
+  blacken: function blacken(a0) {
+    const r6 = this.hwb();
+    const color = r6.color;
+    color[2] = color[2] + r6.color[2] * a0;
+    return r6;
+  },
+  grayscale: function grayscale() {
+    const color = this.rgb().color;
+    const r14 = 0.3 * color[0] + 0.59 * color[1] + 0.11 * color[2];
+    return Color.rgb(r14, r14, r14);
+  },
+  fade: function fade(a0) {
+    return this.alpha(this.valpha - this.valpha * a0);
+  },
+  opaquer: function opaquer(a0) {
+    return this.alpha(this.valpha + this.valpha * a0);
+  },
+  rotate: function rotate(a0) {
+    const r7 = this.hsl();
+    const r2 = (r7.color[0] + a0) % 360;
+    let r0 = r2;
+    if (r0 < 0) {
+      r0 = 360 + r2;
+    }
+    r7.color[0] = r0;
+    return r7;
+  },
+  mix: function mix(a0, a1) {
+    if (a0 && a0.rgb) {
+      const r26 = a0.rgb();
+      const r13 = this.rgb();
+      const r28 = a1 !== void 0 ? a1 : 0.5;
+      const r0 = 2 * r28 - 1;
+      const r33 = r26.alpha() - r13.alpha();
+      const r3 = ((r0 * r33 !== -1 ? (r0 + r33) / (1 + r0 * r33) : r0) + 1) / 2;
+      const r40 = 1 - r3;
+      const r45 = r3 * r26.red();
+      return Color.rgb(r45 + r40 * r13.red(), r3 * r26.green() + r40 * r13.green(), r3 * r26.blue() + r40 * r13.blue(), r26.alpha() * r28 + r13.alpha() * (1 - r28));
+    }
+    throw new Error("Argument to \"mix\" was not a Color instance, but rather an instance of " + typeof a0);
+  }
+};
+const _loop = function _loop(a0) {
+  if (_excluded.includes(a0)) {
+    return 1;
+  }
+  const channels = _Module5613[a0].channels;
+  Color.prototype[a0] = function(...args) {
+    let r36;
+    const model = this.model;
+    if (model === a0) {
+      const r45 = {
+        __proto__: Color.prototype
+      };
+      const r46 = Color.call(r45, this);
+      r36 = r46 instanceof Object ? r46 : r45;
+    } else if (args.length > 0) {
+      const r40 = {
+        __proto__: Color.prototype
+      };
+      const r41 = Color.call(r40, args, a0);
+      r36 = r41 instanceof Object ? r41 : r40;
+    } else {
+      const r22 = _Module5613[this.model][a0].raw(this.color);
+      const r29 = [...Array.isArray(r22) ? r22 : [r22], this.valpha];
+      const r34 = {
+        __proto__: Color.prototype
+      };
+      const r35 = Color.call(r34, r29, a0);
+      r36 = r35 instanceof Object ? r35 : r34;
+    }
+    return r36;
+  };
+  Color[a0] = function(...args) {
+    let r8 = args[0];
+    if (typeof r8 === "number") {
+      const r4 = 0 < channels;
+      let r0 = 0;
+      r8 = args;
+      if (r4) {
+        do {
+          const r9 = args[r0];
+          const r1 = r0;
+          if (typeof r9 !== "number") {
+            args[r1] = 0;
+          }
+          r0 = r1 + 1;
+          r8 = args;
+        } while (r0 < channels);
+      }
+    }
+    const r16 = {
+      __proto__: Color.prototype
+    };
+    const r17 = Color.call(r16, r8, a0);
+    return r17 instanceof Object ? r17 : r16;
+  };
+};
+for (const item2 of Object.keys(_Module5613)) {
+  _loop(item2);
+}
+module.exports = Color;

_bundle/Comparator.js

@@ -0,0 +1,137 @@
+// Metro module 12933 (f12934).
+import * as _classCallCheck from "./_classCallCheck";
+import * as __createClass from "./_createClass";
+import * as _Module12906 from "./Module12906";
+import * as _Module12908 from "./Module12908";
+import { safeRe, t } from "./Module12909";
+import * as _SemVer from "./SemVer";
+import * as _Module12931 from "./Module12931";
+import * as _Range from "./Range";
+let env8921 = {};
+const c8921_3 = Symbol("SemVer ANY");
+const Comparator = function Comparator(a0, a1) {
+  "use strict";
+  _classCallCheck(this, Comparator);
+  const options = _Module12906(a1);
+  const r1 = a0 instanceof Comparator;
+  let r16 = a0;
+  if (r1) {
+    if (a0.loose === !!options.loose) {
+      return a0;
+    }
+    r16 = a0.value;
+  }
+  const r27 = r16.trim().split(/\s+/).join(" ");
+  _Module12908("comparator", r27, options);
+  this.options = options;
+  this.loose = !!options.loose;
+  this.parse(r27);
+  if (this.semver === c8921_3) {
+    this.value = "";
+  } else {
+    this.value = this.operator + this.semver.version;
+  }
+  _Module12908("comp", this);
+};
+module.exports = __createClass(Comparator, [{
+  key: "parse",
+  value: function parse(a0) {
+    "use strict";
+    let r4, r6, r19;
+    if (this.options.loose) {
+      r6 = safeRe[t.COMPARATORLOOSE];
+      r19 = dependencyMap;
+      r4 = require;
+    } else {
+      r6 = safeRe[t.COMPARATOR];
+      r19 = dependencyMap;
+      r4 = require;
+    }
+    const r23 = a0.match(r6);
+    if (r23) {
+      this.operator = r23[1] !== void 0 ? r23[1] : "";
+      if (this.operator === "=") {
+        this.operator = "";
+      }
+      if (r23[2]) {
+        this.semver = new (r4(r19[5]))(r23[2], this.options.loose);
+      } else {
+        this.semver = c8921_3;
+      }
+      return void 0;
+    }
+    throw new TypeError(`Invalid comparator: ${a0}`);
+  }
+}, {
+  key: "toString",
+  value: function toString() {
+    "use strict";
+    return this.value;
+  }
+}, {
+  key: "test",
+  value: function test(a0) {
+    "use strict";
+    let r1 = a0;
+    _Module12908("Comparator.test", a0, this.options.loose);
+    const semver = this.semver;
+    if (semver !== c8921_3 && a0 !== c8921_3) {
+      if (typeof a0 === "string") {
+        try {
+          r1 = new _SemVer(a0, this.options);
+        } catch ($e) {
+          return false;
+        }
+      }
+      return _Module12931(r1, this.operator, this.semver, this.options);
+    }
+    return true;
+  }
+}, {
+  key: "intersects",
+  value: function intersects(a0, a1) {
+    "use strict";
+    let r35;
+    if (a0 instanceof Comparator) {
+      if (this.operator === "") {
+        r35 = this.value === "" || new _Range(a0.value, a1).test(this.value);
+      } else if (a0.operator === "") {
+        r35 = a0.value === "" || new _Range(this.value, a1).test(a0.semver);
+      } else {
+        const r16 = _Module12906(a1);
+        const includePrerelease = r16.includePrerelease;
+        r35 = includePrerelease ? this.value !== "<0.0.0-0" && a0.value !== "<0.0.0-0" : !includePrerelease;
+        if (r35) {
+          const includePrerelease2 = r16.includePrerelease;
+          const r40 = includePrerelease2 ? !includePrerelease2 : this.value.startsWith("<0.0.0") || a0.value.startsWith("<0.0.0");
+          let r44 = !r40;
+          if (!r40) {
+            const r48 = this.operator.startsWith(">");
+            const r3 = r48 ? !a0.operator.startsWith(">") : !r48;
+            let r5 = !r3;
+            if (r3) {
+              const r55 = this.operator.startsWith("<");
+              const r2 = r55 ? !a0.operator.startsWith("<") : !r55;
+              let r59 = !r2;
+              if (r2) {
+                const r0 = this.semver.version !== a0.semver.version || !this.operator.includes("=") || !a0.operator.includes("=");
+                r59 = r0 ? !!(_Module12931(this.semver, "<", a0.semver, r16) && this.operator.startsWith(">") && a0.operator.startsWith("<")) || !!(_Module12931(this.semver, ">", a0.semver, r16) && this.operator.startsWith("<") && a0.operator.startsWith(">")) : !r0;
+              }
+              r5 = r59;
+            }
+            r44 = r5;
+          }
+          r35 = r44;
+        }
+      }
+      return r35;
+    }
+    throw new TypeError("a Comparator is required");
+  }
+}], [{
+  key: "ANY",
+  get: function get() {
+    "use strict";
+    return c8921_3;
+  }
+}]);

_bundle/Compiler.js

@@ -0,0 +1,170 @@
+// Metro module 16058 (f16059).
+let StringFormat, PluralFormat, PluralOffsetString, SelectFormat;
+const Compiler = function Compiler(a0, a1, a2) {
+  this.locales = a0;
+  this.formats = a1;
+  this.pluralFn = a2;
+};
+StringFormat = function StringFormat(a0) {
+  this.id = a0;
+};
+PluralFormat = function PluralFormat(a0, a1, a2, a3, a4) {
+  this.id = a0;
+  this.useOrdinal = a1;
+  this.offset = a2;
+  this.options = a3;
+  this.pluralFn = a4;
+};
+PluralOffsetString = function PluralOffsetString(a0, a1, a2, a3) {
+  this.id = a0;
+  this.offset = a1;
+  this.numberFormat = a2;
+  this.string = a3;
+};
+SelectFormat = function SelectFormat(a0, a1) {
+  this.id = a0;
+  this.options = a1;
+};
+export default Compiler;
+Compiler.prototype.compile = function(a0) {
+  this.pluralStack = [];
+  this.currentPlural = null;
+  this.pluralNumberFormat = null;
+  return this.compileMessage(a0);
+};
+Compiler.prototype.compileMessage = function(a0) {
+  if (a0 && a0.type === "messageFormatPattern") {
+    const elements = a0.elements;
+    const r16 = [];
+    const length = elements.length;
+    let r0 = 0;
+    while (r0 < length) {
+      const r12 = elements[r0];
+      const type = r12.type;
+      const r1 = r0;
+      if (type === "messageTextElement") {
+        r16.push(this.compileMessageText(r12));
+      } else {
+        if (type !== "argumentElement") {
+          throw new Error("Message element does not have a valid type");
+        }
+        r16.push(this.compileArgument(r12));
+      }
+      r0 = r1 + 1;
+    }
+    return r16;
+  }
+  throw new Error("Message AST is not of type: \"messageFormatPattern\"");
+};
+Compiler.prototype.compileMessageText = function(a0) {
+  let r15;
+  if (this.currentPlural && /(^|[^\\])#/g.test(a0.value)) {
+    if (!this.pluralNumberFormat) {
+      this.pluralNumberFormat = new Intl.NumberFormat(this.locales);
+    }
+    const id = this.currentPlural.id;
+    const offset = this.currentPlural.format.offset;
+    const pluralNumberFormat = this.pluralNumberFormat;
+    const value = a0.value;
+    const r32 = {
+      __proto__: PluralOffsetString.prototype
+    };
+    r32.id = id;
+    r32.offset = offset;
+    r32.numberFormat = pluralNumberFormat;
+    r32.string = value;
+    r15 = r32;
+  } else {
+    r15 = a0.value.replace(/\\#/g, "#");
+  }
+  return r15;
+};
+Compiler.prototype.compileArgument = function(a0) {
+  const format = a0.format;
+  if (format) {
+    const formats = this.formats;
+    const locales = this.locales;
+    const pluralFn = this.pluralFn;
+    const type = format.type;
+    if (type === "numberFormat") {
+      return {
+        id: a0.id,
+        format: new Intl.NumberFormat(locales, formats.number[format.style]).format
+      };
+    }
+    if (type === "dateFormat") {
+      return {
+        id: a0.id,
+        format: new Intl.DateTimeFormat(locales, formats.date[format.style]).format
+      };
+    }
+    if (type === "timeFormat") {
+      return {
+        id: a0.id,
+        format: new Intl.DateTimeFormat(locales, formats.time[format.style]).format
+      };
+    }
+    if (type === "pluralFormat") {
+      const options2 = this.compileOptions(a0);
+      const id3 = a0.id;
+      const { ordinal, offset } = format;
+      const r38 = {
+        __proto__: PluralFormat.prototype
+      };
+      r38.id = id3;
+      r38.useOrdinal = ordinal;
+      r38.offset = offset;
+      r38.options = options2;
+      r38.pluralFn = pluralFn;
+      return r38;
+    }
+    if (type === "selectFormat") {
+      const options = this.compileOptions(a0);
+      const id2 = a0.id;
+      const r30 = {
+        __proto__: SelectFormat.prototype
+      };
+      r30.id = id2;
+      r30.options = options;
+      return r30;
+    }
+    throw new Error("Message element does not have a valid format type");
+  }
+  const id = a0.id;
+  const r15 = {
+    __proto__: StringFormat.prototype
+  };
+  r15.id = id;
+  return r15;
+};
+Compiler.prototype.compileOptions = function(a0) {
+  const format = a0.format;
+  const options = format.options;
+  this.pluralStack.push(this.currentPlural);
+  const currentPlural = format.type === "pluralFormat" ? a0 : null;
+  const r15 = {};
+  this.currentPlural = currentPlural;
+  const length = options.length;
+  let r0 = 0;
+  while (r0 < length) {
+    const r17 = options[r0];
+    r15[r17.selector] = this.compileMessage(r17.value);
+    r0 = r0 + 1;
+  }
+  this.currentPlural = this.pluralStack.pop();
+  return r15;
+};
+StringFormat.prototype.format = function(a0) {
+  return a0 ? typeof a0 !== "string" ? String(a0) : a0 : "";
+};
+PluralFormat.prototype.getOption = function(a0) {
+  const options = this.options;
+  return options["=" + a0] || options[this.pluralFn(a0 - this.offset, this.useOrdinal)] || options.other;
+};
+PluralOffsetString.prototype.format = function(a0) {
+  return this.string.replace(/(^|[^\\])#/g, "$1" + this.numberFormat.format(a0 - this.offset)).replace(/\\#/g, "#");
+};
+SelectFormat.prototype.getOption = function(a0) {
+  const options = this.options;
+  return options[a0] || options.other;
+};

_bundle/ComplexAnimationBuilder.js

@@ -0,0 +1,203 @@
+// Metro module 1690 (f1691).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import { withSpring, withTiming } from "./Module1678";
+import { BaseAnimationBuilder } from "./BaseAnimationBuilder";
+let ComplexAnimationBuilder;
+let env1332 = {};
+env1332[5] = function _isNativeReflectConstruct() {
+  let c13163_0;
+  try {
+    c13163_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c13163_0;
+  };
+  env1332[5] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+ComplexAnimationBuilder = function ComplexAnimationBuilder() {
+  _classCallCheck(this, ComplexAnimationBuilder);
+  const r8 = _getPrototypeOf(ComplexAnimationBuilder);
+  return _possibleConstructorReturn(this, (0, env1332[5])() ? Reflect.construct(r8, arguments, _getPrototypeOf(this).constructor) : r8.apply(this, arguments));
+};
+_inherits(ComplexAnimationBuilder, BaseAnimationBuilder);
+exports.ComplexAnimationBuilder = _createClass(ComplexAnimationBuilder, [{
+  key: "easing",
+  value: function easing(a0) {
+    this.easingV = a0;
+    return this;
+  }
+}, {
+  key: "rotate",
+  value: function rotate(a0) {
+    this.rotateV = a0;
+    return this;
+  }
+}, {
+  key: "springify",
+  value: function springify(a0) {
+    this.durationV = a0;
+    this.type = withSpring;
+    return this;
+  }
+}, {
+  key: "dampingRatio",
+  value: function dampingRatio(a0) {
+    this.dampingRatioV = a0;
+    return this;
+  }
+}, {
+  key: "damping",
+  value: function damping(a0) {
+    this.dampingV = a0;
+    return this;
+  }
+}, {
+  key: "mass",
+  value: function mass(a0) {
+    this.massV = a0;
+    return this;
+  }
+}, {
+  key: "stiffness",
+  value: function stiffness(a0) {
+    this.stiffnessV = a0;
+    return this;
+  }
+}, {
+  key: "overshootClamping",
+  value: function overshootClamping(a0) {
+    this.overshootClampingV = a0;
+    return this;
+  }
+}, {
+  key: "restDisplacementThreshold",
+  value: function restDisplacementThreshold(a0) {
+    this.restDisplacementThresholdV = a0;
+    return this;
+  }
+}, {
+  key: "restSpeedThreshold",
+  value: function restSpeedThreshold(a0) {
+    this.restSpeedThresholdV = a0;
+    return this;
+  }
+}, {
+  key: "withInitialValues",
+  value: function withInitialValues(a0) {
+    this.initialValues = a0;
+    return this;
+  }
+}, {
+  key: "getAnimationAndConfig",
+  value: function getAnimationAndConfig() {
+    const durationV = this.durationV;
+    const easingV = this.easingV;
+    const rotateV = this.rotateV;
+    const r19 = this.type ? this.type : withTiming;
+    const dampingV = this.dampingV;
+    const dampingRatioV = this.dampingRatioV;
+    const massV = this.massV;
+    const stiffnessV = this.stiffnessV;
+    const overshootClampingV = this.overshootClampingV;
+    const restDisplacementThresholdV = this.restDisplacementThresholdV;
+    const restSpeedThresholdV = this.restSpeedThresholdV;
+    const r21 = {};
+    let c24548_0 = r21;
+    if (r19 === withTiming && easingV) {
+      r21.easing = easingV;
+    }
+    [{
+      variableName: "damping",
+      value: dampingV
+    }, {
+      variableName: "dampingRatio",
+      value: dampingRatioV
+    }, {
+      variableName: "mass",
+      value: massV
+    }, {
+      variableName: "stiffness",
+      value: stiffnessV
+    }, {
+      variableName: "overshootClamping",
+      value: overshootClampingV
+    }, {
+      variableName: "restDisplacementThreshold",
+      value: restDisplacementThresholdV
+    }, {
+      variableName: "restSpeedThreshold",
+      value: restSpeedThresholdV
+    }, {
+      variableName: "duration",
+      value: durationV
+    }, {
+      variableName: "rotate",
+      value: rotateV
+    }].forEach(({ value, variableName }) => {
+      if (value) {
+        c24548_0[variableName] = value;
+      }
+    });
+    return [r19, r21];
+  }
+}], [{
+  key: "easing",
+  value: function easing(a0) {
+    return this.createInstance().easing(a0);
+  }
+}, {
+  key: "rotate",
+  value: function rotate(a0) {
+    return this.createInstance().rotate(a0);
+  }
+}, {
+  key: "springify",
+  value: function springify(a0) {
+    return this.createInstance().springify(a0);
+  }
+}, {
+  key: "dampingRatio",
+  value: function dampingRatio(a0) {
+    return this.createInstance().dampingRatio(a0);
+  }
+}, {
+  key: "damping",
+  value: function damping(a0) {
+    return this.createInstance().damping(a0);
+  }
+}, {
+  key: "mass",
+  value: function mass(a0) {
+    return this.createInstance().mass(a0);
+  }
+}, {
+  key: "stiffness",
+  value: function stiffness(a0) {
+    return this.createInstance().stiffness(a0);
+  }
+}, {
+  key: "overshootClamping",
+  value: function overshootClamping(a0) {
+    return this.createInstance().overshootClamping(a0);
+  }
+}, {
+  key: "restDisplacementThreshold",
+  value: function restDisplacementThreshold(a0) {
+    return this.createInstance().restDisplacementThreshold(a0);
+  }
+}, {
+  key: "restSpeedThreshold",
+  value: function restSpeedThreshold(a0) {
+    return this.createInstance().restSpeedThreshold(a0);
+  }
+}, {
+  key: "withInitialValues",
+  value: function withInitialValues(a0) {
+    return this.createInstance().withInitialValues(a0);
+  }
+}]);

_bundle/ComposedGesture.js

@@ -0,0 +1,116 @@
+// Metro module 5334 (f5335).
+import _classCallCheck from "./_classCallCheck";
+import _createClass from "./_createClass";
+import _possibleConstructorReturn from "./_possibleConstructorReturn";
+import _getPrototypeOf from "./_getPrototypeOf";
+import _inherits from "./_inherits";
+import { Gesture, BaseGesture } from "./Gesture";
+let ComposedGesture;
+let SimultaneousGesture;
+let ExclusiveGesture;
+let env3241 = {};
+env3241[5] = function _isNativeReflectConstruct() {
+  let c14808_0;
+  try {
+    c14808_0 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+  } catch ($e) {}
+  const _isNativeReflectConstruct2 = function _isNativeReflectConstruct() {
+    return !!c14808_0;
+  };
+  env3241[5] = _isNativeReflectConstruct2;
+  return _isNativeReflectConstruct2();
+};
+ComposedGesture = function ComposedGesture(...gestures) {
+  _classCallCheck(this, ComposedGesture);
+  const r10 = _getPrototypeOf(ComposedGesture);
+  const r25 = _possibleConstructorReturn(this, (0, env3241[5])() ? Reflect.construct(r10, [], _getPrototypeOf(this).constructor) : r10.apply(this, void 0));
+  r25.gestures = [];
+  r25.simultaneousGestures = [];
+  r25.requireGesturesToFail = [];
+  r25.gestures = gestures;
+  return r25;
+};
+_inherits(ComposedGesture, Gesture);
+const r38 = _createClass(ComposedGesture, [{
+  key: "prepareSingleGesture",
+  value: function prepareSingleGesture(a0, a1, a2) {
+    if (a0 instanceof BaseGesture) {
+      const config = {
+        ...a0.config
+      };
+      const simultaneousWith = config.simultaneousWith;
+      config.simultaneousWith = simultaneousWith === void 0 ? [...a1] : [...simultaneousWith, ...a1];
+      const requireToFail = config.requireToFail;
+      config.requireToFail = requireToFail === void 0 ? [...a2] : [...requireToFail, ...a2];
+      a0.config = config;
+    } else if (a0 instanceof ComposedGesture) {
+      a0.simultaneousGestures = a1;
+      a0.requireGesturesToFail = a2;
+      a0.prepare();
+    }
+  }
+}, {
+  key: "prepare",
+  value: function prepare() {
+    for (const gesture of this.gestures) {
+      this.prepareSingleGesture(gesture, this.simultaneousGestures, this.requireGesturesToFail);
+    }
+  }
+}, {
+  key: "initialize",
+  value: function initialize() {
+    for (const gesture of this.gestures) {
+      gesture.initialize();
+    }
+  }
+}, {
+  key: "toGestureArray",
+  value: function toGestureArray() {
+    return this.gestures.flatMap((gesture) => gesture.toGestureArray());
+  }
+}]);
+SimultaneousGesture = function SimultaneousGesture() {
+  _classCallCheck(this, SimultaneousGesture);
+  const r8 = _getPrototypeOf(SimultaneousGesture);
+  return _possibleConstructorReturn(this, (0, env3241[5])() ? Reflect.construct(r8, arguments, _getPrototypeOf(this).constructor) : r8.apply(this, arguments));
+};
+_inherits(SimultaneousGesture, r38);
+const r45 = _createClass(SimultaneousGesture, [{
+  key: "prepare",
+  value: function prepare() {
+    const r11 = this.gestures.map((c29496_0) => this.gestures.filter((gesture) => gesture !== c29496_0).flatMap((item) => item.toGestureArray()));
+    const length = this.gestures.length;
+    let r0 = 0;
+    if (0 < length) {
+      do {
+        this.prepareSingleGesture(this.gestures[r0], r11[r0], this.requireGesturesToFail);
+        r0 = r0 + 1;
+      } while (r0 < this.gestures.length);
+    }
+  }
+}]);
+ExclusiveGesture = function ExclusiveGesture() {
+  _classCallCheck(this, ExclusiveGesture);
+  const r8 = _getPrototypeOf(ExclusiveGesture);
+  return _possibleConstructorReturn(this, (0, env3241[5])() ? Reflect.construct(r8, arguments, _getPrototypeOf(this).constructor) : r8.apply(this, arguments));
+};
+_inherits(ExclusiveGesture, r38);
+const r52 = _createClass(ExclusiveGesture, [{
+  key: "prepare",
+  value: function prepare() {
+    const r13 = this.gestures.map((gesture) => gesture.toGestureArray());
+    let r14 = [];
+    const length = this.gestures.length;
+    let r0 = 0;
+    if (0 < length) {
+      do {
+        this.prepareSingleGesture(this.gestures[r0], this.simultaneousGestures, this.requireGesturesToFail.concat(r14));
+        r14 = r14.concat(r13[r0]);
+        r0 = r0 + 1;
+      } while (r0 < this.gestures.length);
+    }
+  }
+}]);
+export { r38 as ComposedGesture };
+export { r45 as SimultaneousGesture };
+export { r52 as ExclusiveGesture };

_bundle/CompressedTypes.js

@@ -0,0 +1,75 @@
+// Metro module 4786 (f4787).
+import * as __createClass from "./_createClass";
+import * as _classCallCheck from "./_classCallCheck";
+const CompressedTypes = function CompressedTypes() {
+  _classCallCheck(this, CompressedTypes);
+};
+const r16 = __createClass(CompressedTypes);
+export { r16 as CompressedTypes };
+r16._7Z = {
+  extension: "7z",
+  mimeType: "application/x-7z-compressed",
+  description: "7-Zip compressed file",
+  signatures: [{
+    sequence: [55, 122, 188, 175, 39, 28]
+  }]
+};
+r16.LZH = {
+  extension: "lzh",
+  mimeType: "application/x-lzh-compressed",
+  description: "Compressed file using Lempel-Ziv and Haruyasu (LZH) compression algorithm",
+  signatures: [{
+    sequence: [45, 104, 108, 48, 45],
+    description: "Lempel Ziv Huffman archive file Method 0 (No compression)",
+    compatibleExtensions: ["lha"]
+  }, {
+    sequence: [45, 104, 108, 53, 45],
+    description: "Lempel Ziv Huffman archive file Method 5 (8KiB sliding window)",
+    compatibleExtensions: ["lha"]
+  }]
+};
+r16.RAR = {
+  extension: "rar",
+  mimeType: "application/x-rar-compressed",
+  description: "Roshal ARchive compressed archive file",
+  signatures: [{
+    sequence: [82, 97, 114, 33, 26, 7, 0],
+    description: "Compressed archive v5.00 onwards"
+  }, {
+    sequence: [82, 97, 114, 33, 26, 7, 1, 0],
+    description: "Compressed archive v1.50 onwards"
+  }]
+};
+r16.ZIP = {
+  extension: "zip",
+  mimeType: "application/zip",
+  description: "Compressed archive file",
+  signatures: [{
+    sequence: [87, 105, 110, 90, 105, 112],
+    offset: 29152,
+    description: "WinZip compressed archive"
+  }, {
+    sequence: [80, 75, 3, 4, 20, 0, 1, 0, 99, 0, 0, 0, 0, 0],
+    description: "ZLock Pro encrypted ZIP"
+  }, {
+    sequence: [80, 75, 76, 73, 84, 69],
+    offset: 30,
+    description: "PKLITE compressed ZIP archive (see also PKZIP)"
+  }, {
+    sequence: [80, 75, 83, 112, 88],
+    offset: 526,
+    description: "PKSFX self-extracting executable compressed file (see also PKZIP)"
+  }, {
+    sequence: [80, 75, 3, 4],
+    description: "PKZIP archive file - zip file format and multiple formats based on it",
+    compatibleExtensions: ["aar", "apk", "docx", "epub", "ipa", "jar", "kmz", "maff", "msix", "odp", "ods", "odt", "pk3", "pk4", "pptx", "usdz", "vsdx", "xlsx", "xpi"]
+  }, {
+    sequence: [80, 75, 5, 6],
+    description: "PKZIP empty archive file - zip file format and multiple formats based on it",
+    compatibleExtensions: ["aar", "apk", "docx", "epub", "ipa", "jar", "kmz", "maff", "msix", "odp", "ods", "odt", "pk3", "pk4", "pptx", "usdz", "vsdx", "xlsx", "xpi"]
+  }, {
+    sequence: [80, 75, 7, 8],
+    description: "PKZIP multivolume archive file - zip file format and multiple formats based on it",
+    compatibleExtensions: ["aar", "apk", "docx", "epub", "ipa", "jar", "kmz", "maff", "msix", "odp", "ods", "odt", "pk3", "pk4", "pptx", "usdz", "vsdx", "xlsx", "xpi"]
+  }]
+};