Initial commit

sources/by-id/module-01024.jsx

@@ -0,0 +1,498 @@
+/* Metro module 1024; source: unknown; dependencies: [1010, 825, 826, 822, 1025] */
+function _fun10679(global, require, importDefault, importAll, module, exports, dependencyMap) { // fn#10679, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:6, offset: 0x00d9371a, size: 119 bytes, params: 8, frame: 17
+    var closure;
+    let value = this;
+    let env0_0 = require;
+    const Object = global.Object;
+    Object.defineProperty(exports, '__esModule', {value: true});
+    if (!(value && value.__awaiter)) {
+        closure = function(a0, a1, a2, a3) {
+            var r2;
+            var value = a2;
+            var env0_0 = a0;
+            var env0_1 = a1;
+            var env0_2 = value;
+            var env0_3 = a3;
+            r2 = value || global.Promise;
+            value = Object.create(r2.prototype, {constructor: {value: r2}});
+            var value2 = new r2(_fun10681);
+            return value2 instanceof Object ? value2 : value;
+        };
+    }
+    object = {onUnhandled: onUnhandled, onHandled: function(a0) {
+    }};
+    exports.reactNativeErrorHandlersIntegration = function() {
+        var env0_0 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        return {name: 'ReactNativeErrorHandlers', setupOnce: _fun10690};
+    };
+}
+
+function _fun10680(a0, a1, a2, a3) { // fn#10680, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:122, offset: 0x00d93791, size: 75 bytes, params: 5, frame: 12
+    let value = a2;
+    const env0_0 = a0;
+    const env0_1 = a1;
+    const env0_3 = a3;
+    let r2 = value || global.Promise;
+    value = Object.create(r2.prototype, {constructor: {value: r2}});
+    r2 = new r2(_fun10681);
+    return r2 instanceof Object ? r2 : value;
+}
+
+function onUnhandled(a0, a1) { // fn#10687, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:492, offset: 0x00d938c1, size: 141 bytes, params: 3, frame: 19
+    var r5;
+    var value;
+    const value2 = undefined;
+    const moduleValue = require(826) /* metro dependency 826 */;
+    const captureException = moduleValue.captureException;
+    const moduleValue2 = require(822) /* metro dependency 822 */;
+    if (moduleValue2.isErrorLike(a1)) {
+        r5 = value2;
+    } else {
+        value = moduleValue2;
+        value = value.createSyntheticError();
+        r5 = value;
+    }
+    Reflect.apply(captureException, moduleValue, [a1, {data: {id: a0}, originalException: a1, syntheticException: r5,
+        mechanism: {'handled': true, 'type': 'onunhandledrejection'}}]);
+    return value2;
+}
+
+function reactNativeErrorHandlersIntegration() { // fn#10689, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:786, offset: 0x00d9394e, size: 59 bytes, params: 1, frame: 5
+    const env0_0 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return {name: 'ReactNativeErrorHandlers', setupOnce: setupOnce_10690};
+}
+
+function _fun10681(a0, a1) { // fn#10681, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:168, offset: 0x00d937dc, size: 98 bytes, params: 3, frame: 16
+    const env0_0 = a0;
+    const env0_1 = a1;
+    const closure = step_10684;
+    const value2 = importAll.apply(env0_0, require || []);
+    closure(value2.next());
+}
+
+function reactNativeErrorHandlersIntegrationSetupOnce() { // fn#10690, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:946, owner: reactNativeErrorHandlersIntegration.setupOnce, offset: 0x00d93989, size: 52 bytes, params: 1, frame: 13
+    const Object = global.Object;
+    ((a0) => {
+        if (a0.onunhandledrejection) {
+            _fun10692(a0.patchGlobalPromise);
+        }
+        if (a0.onerror) {
+            _fun10694();
+        }
+    })(Object.assign({'onerror': true, 'onunhandledrejection': true, 'patchGlobalPromise': true}, env0_0));
+}
+
+function step_10684(a0) { // fn#10684, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:296, offset: 0x00d9383e, size: 77 bytes, params: 2, frame: 14
+    var value;
+    if (a0.done) {
+        env0_0(a0.value);
+    } else {
+        value = a0.value;
+        value = step_10684Adopt(value);
+        value.then(fulfilled_10682, rejected_10683);
+    }
+}
+
+function setupOnceSetup(a0) { // fn#10691, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:974, owner: reactNativeErrorHandlersIntegration.setupOnce.setup, offset: 0x00d939bd, size: 56 bytes, params: 2, frame: 13
+    if (a0.onunhandledrejection) {
+        setupUnhandledRejectionsTracking(a0.patchGlobalPromise);
+    }
+    if (a0.onerror) {
+        setupErrorUtilsGlobalHandler();
+    }
+}
+
+function step_10684Adopt(a0) { // fn#10685, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:331, owner: step_10684.adopt, offset: 0x00d9388b, size: 54 bytes, params: 2, frame: 12
+    const value = a0;
+    return value instanceof env2_2 ? value : new env2_2(_fun10686);
+}
+
+function setupUnhandledRejectionsTracking(a0) { // fn#10692, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:1016, owner: reactNativeErrorHandlersIntegration.setupOnce.setup.setupUnhandledRejectionsTracking, offset: 0x00d939f5, size: 732 bytes, params: 2, frame: 19
+    var environment;
+    var enablePromiseRejectionTracker;
+    var HermesInternal;
+    var hasPromise;
+    var r2;
+    var value2;
+    var property;
+    var moduleValue;
+    var isHermesEnabled2;
+    var moduleValue2;
+    var RN_GLOBAL_OBJ;
+    var value3;
+    var value4;
+    var moduleValue3;
+    var value5;
+    var moduleValue4;
+    var value6;
+    var moduleValue5;
+    var value7;
+    var value8;
+    var value9;
+    var value10;
+    var value11;
+    var moduleValue6;
+    var isWeb2;
+    var moduleValue7;
+    var debug;
+    var moduleValue8;
+    var moduleValue9;
+    var value12;
+    var enable;
+    var binding;
+    var onUnhandled;
+    var onHandled;
+    var moduleValue10;
+    var moduleValue11;
+    var moduleValue12;
+    var closure;
+    var moduleValue13;
+    var moduleValue14;
+    var moduleValue15;
+    var error;
+    const value = undefined;
+    try {
+        value2 = environment.__proto__.__proto__.__proto__;
+        property = dependencyMap[0];
+        moduleValue = require(property);
+        isHermesEnabled2 = moduleValue.isHermesEnabled();
+        if (isHermesEnabled2) {
+            property = dependencyMap[1];
+            moduleValue2 = require(property);
+            RN_GLOBAL_OBJ = moduleValue2.RN_GLOBAL_OBJ;
+            HermesInternal = RN_GLOBAL_OBJ.HermesInternal;
+            value3 = HermesInternal === null;
+            if (value3) {
+                enablePromiseRejectionTracker = value;
+            } else {
+                value4 = value === HermesInternal;
+                enablePromiseRejectionTracker = value4 ? value : HermesInternal.enablePromiseRejectionTracker;
+            }
+            if (enablePromiseRejectionTracker) {
+                property = dependencyMap[1];
+                moduleValue3 = require(property);
+                RN_GLOBAL_OBJ = moduleValue3.RN_GLOBAL_OBJ;
+                value5 = RN_GLOBAL_OBJ === null;
+                if (value5) {
+                    HermesInternal = value;
+                } else {
+                    moduleValue4 = require(dependencyMap[1]);
+                    RN_GLOBAL_OBJ = moduleValue4.RN_GLOBAL_OBJ;
+                    value6 = value === RN_GLOBAL_OBJ;
+                    if (value6) {
+                        HermesInternal = value;
+                    } else {
+                        moduleValue5 = require(dependencyMap[1]);
+                        RN_GLOBAL_OBJ = moduleValue5.RN_GLOBAL_OBJ;
+                        HermesInternal = RN_GLOBAL_OBJ.HermesInternal;
+                    }
+                }
+                value7 = HermesInternal === null;
+                if (value7) {
+                    hasPromise = value;
+                } else {
+                    value8 = value === HermesInternal;
+                    hasPromise = value8 ? value : HermesInternal.hasPromise;
+                }
+                value9 = hasPromise === null;
+                if (value9) {
+                    r2 = value;
+                } else {
+                    value10 = value === hasPromise;
+                    if (value10) {
+                        r2 = value;
+                    } else {
+                        value11 = hasPromise.call(HermesInternal);
+                        r2 = value11;
+                    }
+                }
+                if (r2) {
+                    property = dependencyMap[2];
+                    moduleValue13 = require(property);
+                    debug = moduleValue13.debug;
+                    debug.log('Using Hermes native promise rejection tracking');
+                    property = dependencyMap[1];
+                    moduleValue14 = require(property);
+                    RN_GLOBAL_OBJ = moduleValue14.RN_GLOBAL_OBJ;
+                    HermesInternal = RN_GLOBAL_OBJ.HermesInternal;
+                    enablePromiseRejectionTracker = HermesInternal.enablePromiseRejectionTracker;
+                    binding = env3_3;
+                    onUnhandled = binding.onUnhandled;
+                    binding = env3_3;
+                    onHandled = binding.onHandled;
+                    Reflect.apply(enablePromiseRejectionTracker, HermesInternal, [{allRejections: true,
+                        onUnhandled: onUnhandled,
+                        onHandled: onHandled}]);
+                    property = dependencyMap[2];
+                    moduleValue15 = require(property);
+                    debug = moduleValue15.debug;
+                    debug.log('Unhandled promise rejections will be caught by Sentry.');
+                } else {
+                    property = dependencyMap[0];
+                    moduleValue6 = require(property);
+                    isWeb2 = moduleValue6.isWeb();
+                    if (isWeb2) {
+                        property = dependencyMap[2];
+                        moduleValue11 = require(property);
+                        debug = moduleValue11.debug;
+                        debug.log('Using Browser JS promise rejection tracking for React Native Web');
+                        property = dependencyMap[2];
+                        moduleValue12 = require(property);
+                        closure = _fun10693;
+                        moduleValue12.addGlobalUnhandledRejectionInstrumentationHandler(closure);
+                    } else if (a0) {
+                        property = dependencyMap[4];
+                        moduleValue8 = require(property);
+                        moduleValue8.polyfillPromise();
+                        property = dependencyMap[4];
+                        moduleValue9 = require(property);
+                        value12 = moduleValue9.requireRejectionTracking();
+                        enable = value12.enable;
+                        binding = env3_3;
+                        onUnhandled = binding.onUnhandled;
+                        binding = env3_3;
+                        onHandled = binding.onHandled;
+                        Reflect.apply(enable, value12, [{allRejections: true, onUnhandled: onUnhandled,
+                            onHandled: onHandled}]);
+                        property = dependencyMap[4];
+                        moduleValue10 = require(property);
+                        moduleValue10.checkPromiseAndWarn();
+                    } else {
+                        property = dependencyMap[2];
+                        moduleValue7 = require(property);
+                        debug = moduleValue7.debug;
+                        debug.log('Unhandled promise rejections will not be caught by Sentry.');
+                    }
+                }
+            } else {
+                property = dependencyMap[0];
+                moduleValue6 = require(property);
+                isWeb2 = moduleValue6.isWeb();
+                if (isWeb2) {
+                    property = dependencyMap[2];
+                    moduleValue11 = require(property);
+                    debug = moduleValue11.debug;
+                    debug.log('Using Browser JS promise rejection tracking for React Native Web');
+                    property = dependencyMap[2];
+                    moduleValue12 = require(property);
+                    closure = _fun10693;
+                    moduleValue12.addGlobalUnhandledRejectionInstrumentationHandler(closure);
+                } else if (a0) {
+                    property = dependencyMap[4];
+                    moduleValue8 = require(property);
+                    moduleValue8.polyfillPromise();
+                    property = dependencyMap[4];
+                    moduleValue9 = require(property);
+                    value12 = moduleValue9.requireRejectionTracking();
+                    enable = value12.enable;
+                    binding = env3_3;
+                    onUnhandled = binding.onUnhandled;
+                    binding = env3_3;
+                    onHandled = binding.onHandled;
+                    Reflect.apply(enable, value12, [{allRejections: true, onUnhandled: onUnhandled,
+                        onHandled: onHandled}]);
+                    property = dependencyMap[4];
+                    moduleValue10 = require(property);
+                    moduleValue10.checkPromiseAndWarn();
+                } else {
+                    property = dependencyMap[2];
+                    moduleValue7 = require(property);
+                    debug = moduleValue7.debug;
+                    debug.log('Unhandled promise rejections will not be caught by Sentry.');
+                }
+            }
+        } else {
+            property = dependencyMap[0];
+            moduleValue6 = require(property);
+            isWeb2 = moduleValue6.isWeb();
+            if (isWeb2) {
+                property = dependencyMap[2];
+                moduleValue11 = require(property);
+                debug = moduleValue11.debug;
+                debug.log('Using Browser JS promise rejection tracking for React Native Web');
+                property = dependencyMap[2];
+                moduleValue12 = require(property);
+                closure = _fun10693;
+                moduleValue12.addGlobalUnhandledRejectionInstrumentationHandler(closure);
+            } else if (a0) {
+                property = dependencyMap[4];
+                moduleValue8 = require(property);
+                moduleValue8.polyfillPromise();
+                property = dependencyMap[4];
+                moduleValue9 = require(property);
+                value12 = moduleValue9.requireRejectionTracking();
+                enable = value12.enable;
+                binding = env3_3;
+                onUnhandled = binding.onUnhandled;
+                binding = env3_3;
+                onHandled = binding.onHandled;
+                Reflect.apply(enable, value12, [{allRejections: true, onUnhandled: onUnhandled, onHandled: onHandled}]);
+                property = dependencyMap[4];
+                moduleValue10 = require(property);
+                moduleValue10.checkPromiseAndWarn();
+            } else {
+                property = dependencyMap[2];
+                moduleValue7 = require(property);
+                debug = moduleValue7.debug;
+                debug.log('Unhandled promise rejections will not be caught by Sentry.');
+            }
+        }
+    } catch (error) {
+        debug = require(dependencyMap[2]).debug;
+        debug.warn('Failed to set up promise rejection tracking. Unhandled promise rejections will not be caught by Sentry.See https://docs.sentry.io/platforms/react-native/troubleshooting/ for more details.');
+    }
+    return value;
+}
+
+function setupErrorUtilsGlobalHandler() { // fn#10694, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:2584, owner: reactNativeErrorHandlersIntegration.setupOnce.setup.setupErrorUtilsGlobalHandler, offset: 0x00d93d51, size: 153 bytes, params: 1, frame: 14
+    var environment;
+    var getGlobalHandler;
+    let value = environment.__proto__.__proto__.__proto__;
+    const value2 = undefined;
+    const RN_GLOBAL_OBJ = (require(825) /* metro dependency 825 */).RN_GLOBAL_OBJ;
+    const ErrorUtils = RN_GLOBAL_OBJ.ErrorUtils;
+    if (ErrorUtils) {
+        getGlobalHandler = ErrorUtils.getGlobalHandler;
+        if (getGlobalHandler !== null) {
+            if (value2 !== getGlobalHandler) {
+                value = getGlobalHandler.call(ErrorUtils);
+            }
+        }
+        ErrorUtils.setGlobalHandler(_fun10695);
+    } else {
+        (require(826) /* metro dependency 826 */).debug.warn('ErrorUtils not found. Can be caused by different environment for example react-native-web.');
+    }
+    return value2;
+}
+
+function _fun10693(a0) { // fn#10693, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:1837, offset: 0x00d93cd1, size: 128 bytes, params: 2, frame: 18
+    var r5;
+    let value = environment.__proto__.__proto__.__proto__.__proto__;
+    const value2 = undefined;
+    const moduleValue = require(826) /* metro dependency 826 */;
+    const captureException = moduleValue.captureException;
+    const moduleValue2 = require(822) /* metro dependency 822 */;
+    if (moduleValue2.isErrorLike(a0)) {
+        r5 = value2;
+    } else {
+        value = moduleValue2;
+        value = value.createSyntheticError();
+        r5 = value;
+    }
+    Reflect.apply(captureException, moduleValue, [a0, {originalException: a0, syntheticException: r5,
+        mechanism: {'handled': false, 'type': 'onunhandledrejection'}}]);
+    return value2;
+}
+
+function _fun10695(a0, a1) { // fn#10695, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:2893, offset: 0x00d93dea, size: 47 bytes, params: 3, frame: 15
+    const env0_0 = a0;
+    const env0_1 = a1;
+    return env4_2(env0_0, undefined, undefined, _fun10697);
+}
+
+function* _fun10697() { // fn#10697, original name: ?anon_0_, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:2933, offset: 0x00d93e22, size: 478 bytes, params: 1, frame: 21
+    var environment;
+    var shutdownTimeout;
+    var value3;
+    var value4;
+    var binding;
+    var client;
+    var debug;
+    var error;
+    var value7;
+    var object2;
+    var currentScope;
+    var value10;
+    var flush;
+    var value12;
+    if (true) {
+        value = environment.__proto__;
+        if (env1_1) {
+            value3 = environment.__proto__.__proto__;
+            if (env2_1) {
+                value12 = environment.__proto__.__proto__.__proto__.__proto__.__proto__.__proto__;
+                env6_0(env6_1[2]).debug.log('Encountered multiple fatals in a row. The latest:', env1_0);
+                return undefined;
+            }
+            value4 = environment.__proto__.__proto__.__proto__.__proto__.__proto__.__proto__;
+            binding = env6_0;
+            client = binding(env6_1[2]).getClient();
+            if (client) {
+                object2 = {};
+                binding = env1_0;
+                object2.originalException = binding;
+                currentScope = env6_0(env6_1[2]).getCurrentScope();
+                object2.attachments = currentScope.getScopeData().attachments;
+                yield client.eventFromException(binding, object2);
+                value10 = undefined;
+                if (false) {
+                    return value10;
+                }
+                if (env1_1) {
+                    value10.level = 'fatal';
+                    env6_0(env6_1[2]).addExceptionMechanism(value10, {'handled': false, 'type': 'onerror'});
+                } else {
+                    value10.level = 'error';
+                    env6_0(env6_1[2]).addExceptionMechanism(value10, {'handled': true, 'type': 'generic'});
+                }
+                client.captureEvent(value10, object2);
+                flush = client.flush;
+                shutdownTimeout = client.getOptions().shutdownTimeout;
+                shutdownTimeout = !shutdownTimeout ? 2000 : shutdownTimeout;
+                Reflect.apply(flush, client, [shutdownTimeout]).then(_fun10698, _fun10699);
+                return undefined;
+            }
+            binding = env6_0;
+            debug = binding(env6_1[2]).debug;
+            error = debug.error;
+            binding = env1_0;
+            Reflect.apply(error, debug, ['Sentry client is missing, the error event might be lost.', binding]);
+            value7 = environment.__proto__.__proto__;
+            env2_2(binding, env1_1);
+        } else {
+            binding = env6_0;
+            client = binding(env6_1[2]).getClient();
+            if (client) {
+                object2 = {};
+                binding = env1_0;
+                object2.originalException = binding;
+                currentScope = env6_0(env6_1[2]).getCurrentScope();
+                object2.attachments = currentScope.getScopeData().attachments;
+                yield client.eventFromException(binding, object2);
+                value10 = undefined;
+                if (false) {
+                    return value10;
+                }
+                if (env1_1) {
+                    value10.level = 'fatal';
+                    env6_0(env6_1[2]).addExceptionMechanism(value10, {'handled': false, 'type': 'onerror'});
+                } else {
+                    value10.level = 'error';
+                    env6_0(env6_1[2]).addExceptionMechanism(value10, {'handled': true, 'type': 'generic'});
+                }
+                client.captureEvent(value10, object2);
+                flush = client.flush;
+                shutdownTimeout = client.getOptions().shutdownTimeout;
+                shutdownTimeout = !shutdownTimeout ? 2000 : shutdownTimeout;
+                Reflect.apply(flush, client, [shutdownTimeout]).then(_fun10698, _fun10699);
+                return undefined;
+            }
+            binding = env6_0;
+            debug = binding(env6_1[2]).debug;
+            error = debug.error;
+            binding = env1_0;
+            Reflect.apply(error, debug, ['Sentry client is missing, the error event might be lost.', binding]);
+            env2_2(binding, env1_1);
+        }
+    }
+}
+
+function _fun10698() { // fn#10698, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:3541, offset: 0x00d94000, size: 28 bytes, params: 1, frame: 13
+    env3_2(env2_0, env2_1);
+}
+
+function _fun10699(a0) { // fn#10699, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1151:3562, offset: 0x00d9401c, size: 53 bytes, params: 2, frame: 14
+    env7_0(env7_1[2]).debug.error('[ReactNativeErrorHandlers] Error while flushing the event cache after uncaught error.',
+        a0);
+}
+