Initial commit

sources/by-id/module-06469.jsx

@@ -0,0 +1,706 @@
+/* Metro module 6469; source: unknown; dependencies: [6470, 6458, 6471, 6472, 6445, 6446] */
+function _fun50856(global, require, importDefault, importAll, module, exports, dependencyMap) { // fn#50856, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:6, offset: 0x012237c9, size: 70 bytes, params: 8, frame: 16
+    const env0_0 = require;
+    const Object = global.Object;
+    Object.defineProperty(exports, '__esModule', {value: true});
+    exports.default = _fun50857();
+}
+
+function _fun50857() { // fn#50857, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:100, offset: 0x0122380f, size: 345 bytes, params: 1, frame: 4
+    const closure = VirtualRenderer;
+    closure.prototype.getLayoutDimension = function() {
+        return this._layoutManager ? this._layoutManager.getContentDimension() : {'height': 0, 'width': 0};
+    };
+    closure.prototype.setOptimizeForAnimations = function(a0) {
+        this._optimizeForAnimations = a0;
+    };
+    closure.prototype.hasPendingAnimationOptimization = function() {
+        return this._optimizeForAnimations;
+    };
+    closure.prototype.updateOffset = function(a0, a1, a2, a3) {
+        var r2;
+        if (this._viewabilityTracker) {
+            r2 = this._params && this._params.isHorizontal ? a0 : a1;
+            if (!this._isViewTrackerRunning) {
+                if (a2) {
+                    this._viewabilityTracker.setActualOffset(r2);
+                }
+                this.startViewabilityTracker(a3);
+            }
+            this._viewabilityTracker.updateOffset(r2, a2, a3);
+        }
+    };
+    closure.prototype.attachVisibleItemsListener = function(a0) {
+        this.onVisibleItemsChanged = a0;
+    };
+    closure.prototype.removeVisibleItemsListener = function() {
+        this.onVisibleItemsChanged = null;
+        if (this._viewabilityTracker) {
+            this._viewabilityTracker.onVisibleRowsChanged = null;
+        }
+    };
+    closure.prototype.getLayoutManager = function() {
+        return this._layoutManager;
+    };
+    closure.prototype.setParamsAndDimensions = function(a0, a1) {
+        this._params = a0;
+        this._dimensions = a1;
+    };
+    closure.prototype.setLayoutManager = function(a0) {
+        this._layoutManager = a0;
+        if (this._params) {
+            this._layoutManager.relayoutFromIndex(0, this._params.itemCount);
+        }
+    };
+    closure.prototype.setLayoutProvider = function(a0) {
+        this._layoutProvider = a0;
+    };
+    closure.prototype.getViewabilityTracker = function() {
+        return this._viewabilityTracker;
+    };
+    closure.prototype.refreshWithAnchor = refreshWithAnchor;
+    closure.prototype.refresh = function() {
+        if (this._viewabilityTracker) {
+            this._prepareViewabilityTracker();
+            this._viewabilityTracker.forceRefresh();
+        }
+    };
+    closure.prototype.getInitialOffset = getInitialOffset;
+    closure.prototype.init = init_50875;
+    closure.prototype.startViewabilityTracker = function(a0) {
+        if (this._viewabilityTracker) {
+            this._isViewTrackerRunning = true;
+            this._viewabilityTracker.init(a0);
+        }
+    };
+    closure.prototype.syncAndGetKey = syncAndGetKey;
+    closure.prototype.handleDataSetChange = handleDataSetChange;
+    closure.prototype._getCollisionAvoidingKey = function() {
+        var _startKey = this._startKey;
+        var value = typeof _startKey === 'bigint' ? _startKey : +_startKey;
+        this._startKey = typeof value === 'bigint' ? value + 1n : +value + 1;
+        return '#' + value + '_rlv_c';
+    };
+    closure.prototype._prepareViewabilityTracker = _prepareViewabilityTracker;
+    closure.prototype._updateRenderStack = function(a0) {
+        var r4;
+        var r0;
+        var property;
+        var _markDirty;
+        var value3;
+        var value = false;
+        this._markDirty = value;
+        var length = a0.length;
+        var value2 = 0;
+        if (value2 < length) {
+            for (r4 = value2; true; r4 = value3) {
+                property = a0[r4];
+                this._engagedIndexes[property] = 1;
+                this.syncAndGetKey(property);
+                _markDirty = this._markDirty;
+                value3 = typeof r4 === 'bigint' ? r4 + 1n : +r4 + 1;
+                if (!(value3 < length)) {
+                    r0 = _markDirty;
+                    break;
+                }
+            }
+        } else {
+            r0 = value;
+        }
+        this._markDirty = value;
+        return r0;
+    };
+    return closure;
+}
+
+function VirtualRenderer(a0, a1, a2, a3) { // fn#50858, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:111, offset: 0x01223968, size: 228 bytes, params: 5, frame: 17
+    const property = (require(6470) /* metro dependency 6470 */).default;
+    this._layoutProvider = property.cast(null);
+    this._recyclePool = property.cast(null);
+    this._layoutManager = null;
+    this._viewabilityTracker = null;
+    this._optimizeForAnimations = false;
+    this._onVisibleItemsChanged = _onVisibleItemsChanged;
+    this._onEngagedItemsChanged = _onEngagedItemsChanged;
+    this._renderStack = {};
+    this._fetchStableId = a2;
+    this._stableIdToRenderKeyMap = {};
+    this._engagedIndexes = {};
+    this._renderStackChanged = a0;
+    this._scrollOnNextUpdate = a1;
+    this._dimensions = null;
+    this._params = null;
+    this._isRecyclingEnabled = a3;
+    this._isViewTrackerRunning = false;
+    this._markDirty = false;
+    this._startKey = 0;
+    this.onVisibleItemsChanged = null;
+}
+
+function refreshWithAnchor() { // fn#50872, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:2638, offset: 0x01223cee, size: 180 bytes, params: 1, frame: 16
+    var r2;
+    var value;
+    var _layoutManager;
+    var value2;
+    var _params;
+    var Math;
+    var min;
+    let _viewabilityTracker = this._viewabilityTracker;
+    if (_viewabilityTracker) {
+        _viewabilityTracker = this._viewabilityTracker;
+        value = _viewabilityTracker.findFirstLogicallyVisibleIndex();
+        this._prepareViewabilityTracker();
+        _layoutManager = this._layoutManager;
+        value2 = 0;
+        if (_layoutManager) {
+            _params = this._params;
+            if (_params) {
+                Math = global.Math;
+                min = Math.min;
+                _params = this._params;
+                value = Reflect.apply(min, Math, [_params.itemCount - 1, value]);
+                value = this._layoutManager.getOffsetForIndex(value);
+                this._scrollOnNextUpdate(value);
+                _params = this._params;
+                r2 = _params.isHorizontal ? value.x : value.y;
+            } else {
+                r2 = value2;
+            }
+        } else {
+            r2 = value2;
+        }
+        _viewabilityTracker = this._viewabilityTracker;
+        _viewabilityTracker.forceRefreshWithOffset(r2);
+    }
+}
+
+function getInitialOffset() { // fn#50874, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:3216, offset: 0x01223dcc, size: 253 bytes, params: 1, frame: 19
+    var r0;
+    var value;
+    const Default = (require(6458) /* metro dependency 6458 */).Default;
+    var value2;
+    var value3;
+    var isHorizontal;
+    const object2 = {'x': 0, 'y': 0};
+    let _params = this._params;
+    if (_params) {
+        value = environment.__proto__;
+        value2 = Default.value;
+        _params = this._params;
+        value3 = Reflect.apply(value2, Default, [_params.initialRenderIndex, 0]);
+        if (value3 > 0) {
+            if (this._layoutManager) {
+                value = this._layoutManager.getOffsetForIndex(value3);
+                this._params.initialOffset = this._params.isHorizontal ? value.x : value.y;
+                r0 = value;
+            } else {
+                _params = this._params;
+                isHorizontal = _params.isHorizontal;
+                value = Default.value;
+                _params = this._params;
+                value = Reflect.apply(value, Default, [_params.initialOffset, 0]);
+                if (isHorizontal) {
+                    object2.x = value;
+                    object2.y = 0;
+                    r0 = object2;
+                } else {
+                    object2.y = value;
+                    object2.x = 0;
+                    r0 = object2;
+                }
+            }
+        } else {
+            _params = this._params;
+            isHorizontal = _params.isHorizontal;
+            value = Default.value;
+            _params = this._params;
+            value = Reflect.apply(value, Default, [_params.initialOffset, 0]);
+            if (isHorizontal) {
+                object2.x = value;
+                object2.y = 0;
+                r0 = object2;
+            } else {
+                object2.y = value;
+                object2.x = 0;
+                r0 = object2;
+            }
+        }
+    } else {
+        r0 = object2;
+    }
+    return r0;
+}
+
+function init_50875() { // fn#50875, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:3649, offset: 0x01223ec9, size: 257 bytes, params: 1, frame: 19
+    const Default = (require(6458) /* metro dependency 6458 */).Default;
+    var value6;
+    var value7;
+    this.getInitialOffset();
+    let value = environment.__proto__;
+    let property = (require(6471) /* metro dependency 6471 */).default;
+    const value2 = Object.create(property.prototype, {constructor: {value: property}});
+    const property2 = new property();
+    this._recyclePool = property2 instanceof Object ? property2 : value2;
+    let _params = this._params;
+    property = (require(6472) /* metro dependency 6472 */).default;
+    if (_params) {
+        value = Default.value;
+        _params = this._params;
+        value = Reflect.apply(value, Default, [_params.renderAheadOffset, 0]);
+        value6 = Default.value;
+        _params = this._params;
+        value7 = Reflect.apply(value6, Default, [_params.initialOffset, 0]);
+        value = new property(value);
+        this._viewabilityTracker = value;
+    } else {
+        this._viewabilityTracker = new property(0, 0);
+    }
+    this._prepareViewabilityTracker();
+}
+
+function syncAndGetKey(a0, a1, a2, a3) { // fn#50877, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:4171, offset: 0x01223ff6, size: 501 bytes, params: 5, frame: 23
+    var r9;
+    var r5;
+    var r0;
+    var layoutTypeForIndex;
+    var recycledObject;
+    var dataIndex;
+    var value8;
+    let value = a1;
+    const value2 = a2;
+    const value3 = a3;
+    const r8 = value || this._fetchStableId;
+    const r1 = value2 || this._renderStack;
+    const _stableIdToRenderKeyMap = this._stableIdToRenderKeyMap;
+    value = undefined;
+    let property = _stableIdToRenderKeyMap[r8(a0)];
+    const key = property ? property.key : value;
+    const ObjectUtil = (require(6458) /* metro dependency 6458 */).ObjectUtil;
+    if (ObjectUtil.isNullOrUndefined(key)) {
+        layoutTypeForIndex = this._layoutProvider.getLayoutTypeForIndex(a0);
+        recycledObject = this._recyclePool.getRecycledObject(layoutTypeForIndex);
+        if (ObjectUtil.isNullOrUndefined(recycledObject)) {
+            value8 = r8(a0);
+            r9 = r1[value8] ? this._getCollisionAvoidingKey() : value8;
+            r1[r9] = {dataIndex: a0};
+            r5 = r9;
+        } else {
+            property = r1[recycledObject];
+            if (property) {
+                dataIndex = property.dataIndex;
+                property.dataIndex = a0;
+                if (ObjectUtil.isNullOrUndefined(dataIndex) || dataIndex === a0) {
+                    r5 = recycledObject;
+                } else {
+                    delete this._stableIdToRenderKeyMap[r8(dataIndex)];
+                    r5 = recycledObject;
+                }
+            } else {
+                r1[recycledObject] = {dataIndex: a0};
+                if (value3 && value3[recycledObject]) {
+                    delete this._stableIdToRenderKeyMap[value3[recycledObject]];
+                    r5 = recycledObject;
+                } else {
+                    r5 = recycledObject;
+                }
+            }
+        }
+        this._markDirty = true;
+        this._stableIdToRenderKeyMap[r8(a0)] = {key: r5, type: layoutTypeForIndex};
+        r0 = r5;
+    } else {
+        r0 = key;
+    }
+    if (!ObjectUtil.isNullOrUndefined(this._engagedIndexes[a0])) {
+        this._recyclePool.removeFromPool(r0);
+    }
+    property = r1[r0];
+    if (property && property.dataIndex !== a0) {
+        global.console.warn('Possible stableId collision @', a0);
+    }
+    return r0;
+}
+
+function handleDataSetChange(a0) { // fn#50878, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:5063, offset: 0x012241eb, size: 1028 bytes, params: 2, frame: 37
+    var r0;
+    var r5;
+    var r22;
+    var dataIndex;
+    var r24;
+    var r10;
+    var r3;
+    var _recyclePool;
+    var propertyName;
+    var propertyName2;
+    var _renderStack2;
+    var hasOwnProperty;
+    var _renderStack3;
+    const ObjectUtil = (require(6458) /* metro dependency 6458 */).ObjectUtil;
+    var isNullOrUndefined;
+    var property;
+    var property2;
+    var value6;
+    var _isRecyclingEnabled;
+    var putRecycledObject;
+    var type;
+    var key;
+    var isNullOrUndefined2;
+    var value7;
+    var value8;
+    var _layoutManager;
+    var value9;
+    var value12;
+    var property3;
+    var dataIndex2;
+    var value13;
+    var stableId;
+    var _layoutProvider;
+    var value15;
+    var propertyName3;
+    var _renderStack4;
+    var _renderStack5;
+    var _engagedIndexes;
+    const getStableId = a0.getStableId;
+    let value = a0.getSize();
+    value -= 1;
+    let object4 = {};
+    const object5 = {};
+    const object6 = {};
+    let _optimizeForAnimations = this._optimizeForAnimations;
+    if (_optimizeForAnimations) {
+        _recyclePool = this._recyclePool;
+        r0 = _recyclePool;
+    } else {
+        r0 = _optimizeForAnimations;
+    }
+    if (r0) {
+        _recyclePool = this._recyclePool;
+        _recyclePool.clearAll();
+    }
+    let _renderStack = this._renderStack;
+    const value2 = undefined;
+    for (propertyName in _renderStack) {
+        _renderStack2 = this._renderStack;
+        hasOwnProperty = _renderStack2.hasOwnProperty;
+        if (!Reflect.apply(hasOwnProperty, _renderStack2, [propertyName])) {
+            r5 = propertyName2;
+            continue;
+        }
+        _renderStack3 = this._renderStack;
+        dataIndex = _renderStack3[propertyName].dataIndex;
+        isNullOrUndefined = ObjectUtil.isNullOrUndefined;
+        if (Reflect.apply(isNullOrUndefined, ObjectUtil, [dataIndex])) {
+            r5 = propertyName2;
+            continue;
+        }
+        if (!(dataIndex <= value)) {
+            r5 = propertyName2;
+            continue;
+        }
+        object4[getStableId(dataIndex)] = 1;
+        r5 = propertyName2;
+    }
+    let Object = global.Object;
+    const keys = Object.keys;
+    let _stableIdToRenderKeyMap = this._stableIdToRenderKeyMap;
+    const value4 = Reflect.apply(keys, Object, [_stableIdToRenderKeyMap]);
+    let length = value4.length;
+    const value5 = 0;
+    if (value5 < length) {
+        r5 = value5;
+        while (true) {
+            property = value4[r5];
+            _stableIdToRenderKeyMap = this._stableIdToRenderKeyMap;
+            property2 = _stableIdToRenderKeyMap[property];
+            if (property2) {
+                if (object4[property]) {
+                    object6[property2.key] = property;
+                    break;
+                }
+                _optimizeForAnimations = this._optimizeForAnimations;
+                value6 = !_optimizeForAnimations;
+                if (_optimizeForAnimations) {
+                    r22 = value6;
+                    continue;
+                }
+                _isRecyclingEnabled = this._isRecyclingEnabled;
+                r22 = _isRecyclingEnabled;
+                if (!r22) {
+                    continue;
+                }
+                _recyclePool = this._recyclePool;
+                putRecycledObject = _recyclePool.putRecycledObject;
+                type = property2.type;
+                Reflect.apply(putRecycledObject, _recyclePool, [type, property2.key]);
+                _stableIdToRenderKeyMap = this._stableIdToRenderKeyMap;
+                delete _stableIdToRenderKeyMap[property];
+                _renderStack = this._renderStack;
+                key = property2.key;
+                property = _renderStack[key];
+                if (!property) {
+                    dataIndex = value2;
+                    continue;
+                }
+                dataIndex = property.dataIndex;
+                isNullOrUndefined2 = ObjectUtil.isNullOrUndefined(dataIndex);
+                value7 = !isNullOrUndefined2;
+                if (isNullOrUndefined2) {
+                    r24 = value7;
+                    continue;
+                }
+                value8 = dataIndex <= value;
+                r24 = value8;
+                if (!r24) {
+                    continue;
+                }
+                _layoutManager = this._layoutManager;
+                r24 = _layoutManager;
+                if (r24) {
+                    _layoutManager = this._layoutManager;
+                    _layoutManager.removeLayout(dataIndex);
+                    break;
+                }
+                break;
+            }
+            value9 = typeof r5 === 'bigint' ? r5 + 1n : +r5 + 1;
+            if (value9 < length) {
+                r5 = value9;
+                continue;
+            }
+            break;
+        }
+    }
+    Object = global.Object;
+    const value11 = Object.keys(this._renderStack).sort(_fun50879);
+    length = value11.length;
+    if (value5 < length) {
+        r10 = value5;
+        while (true) {
+            property = value11[r10];
+            _renderStack = this._renderStack;
+            dataIndex = _renderStack[property].dataIndex;
+            isNullOrUndefined = ObjectUtil.isNullOrUndefined;
+            if (!Reflect.apply(isNullOrUndefined, ObjectUtil, [dataIndex])) {
+                if (dataIndex <= value) {
+                    value12 = this.syncAndGetKey(dataIndex, getStableId, object5, object6);
+                    property3 = object5[value12];
+                    if (property3) {
+                        dataIndex2 = property3.dataIndex;
+                        if (dataIndex2 === dataIndex) {
+                            break;
+                        }
+                        value13 = this._getCollisionAvoidingKey();
+                        object5[value13] = {dataIndex: dataIndex};
+                        _stableIdToRenderKeyMap = this._stableIdToRenderKeyMap;
+                        stableId = getStableId(dataIndex);
+                        object4 = {key: value13};
+                        _layoutProvider = this._layoutProvider;
+                        object4.type = _layoutProvider.getLayoutTypeForIndex(dataIndex);
+                        _stableIdToRenderKeyMap[stableId] = object4;
+                        break;
+                    }
+                    object5[value12] = {dataIndex: dataIndex};
+                    break;
+                }
+                break;
+            }
+            _renderStack = this._renderStack;
+            delete _renderStack[property];
+            value15 = typeof r10 === 'bigint' ? r10 + 1n : +r10 + 1;
+            if (value15 < length) {
+                r10 = value15;
+                continue;
+            }
+            break;
+        }
+    }
+    Object = global.Object;
+    Object.assign(this._renderStack, object5);
+    for (propertyName in this._renderStack) {
+        _renderStack4 = this._renderStack;
+        hasOwnProperty = _renderStack4.hasOwnProperty;
+        if (!Reflect.apply(hasOwnProperty, _renderStack4, [propertyName])) {
+            r3 = propertyName3;
+            continue;
+        }
+        _renderStack5 = this._renderStack;
+        dataIndex = _renderStack5[propertyName].dataIndex;
+        isNullOrUndefined = ObjectUtil.isNullOrUndefined;
+        if (Reflect.apply(isNullOrUndefined, ObjectUtil, [dataIndex])) {
+            r3 = propertyName3;
+            continue;
+        }
+        isNullOrUndefined = ObjectUtil.isNullOrUndefined;
+        _engagedIndexes = this._engagedIndexes;
+        if (!Reflect.apply(isNullOrUndefined, ObjectUtil, [_engagedIndexes[dataIndex]])) {
+            r3 = propertyName3;
+            continue;
+        }
+        _layoutProvider = this._layoutProvider;
+        value = _layoutProvider.getLayoutTypeForIndex(dataIndex);
+        _recyclePool = this._recyclePool;
+        _recyclePool.putRecycledObject(value, propertyName);
+        r3 = propertyName3;
+    }
+    return value2;
+}
+
+function _prepareViewabilityTracker() { // fn#50881, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:6888, offset: 0x01224672, size: 344 bytes, params: 1, frame: 17
+    var _layoutManager;
+    var _dimensions;
+    var _params;
+    var value;
+    const property = (require(6445) /* metro dependency 6445 */).default;
+    var initializationException;
+    var setLayouts;
+    var isHorizontal;
+    var contentDimension;
+    var setDimensions;
+    var object2;
+    var Default;
+    let _viewabilityTracker = this._viewabilityTracker;
+    if (_viewabilityTracker) {
+        _layoutManager = this._layoutManager;
+        if (_layoutManager) {
+            _dimensions = this._dimensions;
+            if (_dimensions) {
+                _params = this._params;
+                if (_params) {
+                    _viewabilityTracker = this._viewabilityTracker;
+                    _viewabilityTracker.onEngagedRowsChanged = this._onEngagedItemsChanged;
+                    if (this.onVisibleItemsChanged) {
+                        this._viewabilityTracker.onVisibleRowsChanged = this._onVisibleItemsChanged;
+                    }
+                    _viewabilityTracker = this._viewabilityTracker;
+                    setLayouts = _viewabilityTracker.setLayouts;
+                    _layoutManager = this._layoutManager;
+                    value = _layoutManager.getLayouts();
+                    _params = this._params;
+                    isHorizontal = _params.isHorizontal;
+                    _layoutManager = this._layoutManager;
+                    contentDimension = _layoutManager.getContentDimension();
+                    Reflect.apply(setLayouts, _viewabilityTracker, [value,
+                        isHorizontal ? contentDimension.width : contentDimension.height]);
+                    _viewabilityTracker = this._viewabilityTracker;
+                    setDimensions = _viewabilityTracker.setDimensions;
+                    object2 = {};
+                    _dimensions = this._dimensions;
+                    object2.height = _dimensions.height;
+                    _dimensions = this._dimensions;
+                    object2.width = _dimensions.width;
+                    value = environment.__proto__;
+                    Default = (require(6458) /* metro dependency 6458 */).Default;
+                    value = Default.value;
+                    _params = this._params;
+                    isHorizontal = _params.isHorizontal;
+                    Reflect.apply(setDimensions, _viewabilityTracker, [object2, Reflect.apply(value, Default,
+                        [isHorizontal,
+                        false])]);
+                    return undefined;
+                }
+                value = environment.__proto__;
+                initializationException = (require(6446) /* metro dependency 6446 */).default.initializationException;
+                throw new property();
+            }
+            value = environment.__proto__;
+            initializationException = (require(6446) /* metro dependency 6446 */).default.initializationException;
+            throw new property();
+        }
+        value = environment.__proto__;
+        initializationException = (require(6446) /* metro dependency 6446 */).default.initializationException;
+        throw new property();
+    }
+    value = environment.__proto__;
+    initializationException = (require(6446) /* metro dependency 6446 */).default.initializationException;
+    throw new property();
+}
+
+function _onVisibleItemsChanged(a0, a1, a2) { // fn#50859, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:363, owner: VirtualRenderer._onVisibleItemsChanged, offset: 0x01223a4c, size: 46 bytes, params: 4, frame: 15
+    if (env0_0.onVisibleItemsChanged) {
+        env0_0.onVisibleItemsChanged(a0, a1, a2);
+    }
+}
+
+function _onEngagedItemsChanged(a0, a1, a2) { // fn#50860, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:464, owner: VirtualRenderer._onEngagedItemsChanged, offset: 0x01223a7a, size: 267 bytes, params: 4, frame: 23
+    var r5;
+    var r8;
+    var value2;
+    var value3;
+    var property;
+    var binding;
+    var _engagedIndexes;
+    var _params;
+    var itemCount;
+    var value4;
+    var _stableIdToRenderKeyMap;
+    var _fetchStableId;
+    var property2;
+    var ObjectUtil;
+    var isNullOrUndefined;
+    var _recyclePool;
+    var putRecycledObject;
+    var _layoutProvider;
+    var layoutTypeForIndex;
+    var key;
+    var value6;
+    const length = a2.length;
+    if (env0_0._isRecyclingEnabled) {
+        value2 = 0;
+        value3 = environment.__proto__.__proto__;
+        if (value2 < length) {
+            r5 = value2;
+            while (true) {
+                property = a2[r5];
+                binding = env0_0;
+                _engagedIndexes = binding._engagedIndexes;
+                delete _engagedIndexes[property];
+                _params = binding._params;
+                if (_params) {
+                    _params = env0_0._params;
+                    itemCount = _params.itemCount;
+                    value4 = property < itemCount;
+                    r8 = value4;
+                } else {
+                    r8 = _params;
+                }
+                if (!r8) {
+                    continue;
+                }
+                binding = env0_0;
+                _stableIdToRenderKeyMap = binding._stableIdToRenderKeyMap;
+                _fetchStableId = binding._fetchStableId;
+                property2 = _stableIdToRenderKeyMap[Reflect.apply(_fetchStableId, binding, [property])];
+                ObjectUtil = (require(6458) /* metro dependency 6458 */).ObjectUtil;
+                isNullOrUndefined = ObjectUtil.isNullOrUndefined;
+                if (Reflect.apply(isNullOrUndefined, ObjectUtil, [property2])) {
+                    continue;
+                }
+                binding = env0_0;
+                _recyclePool = binding._recyclePool;
+                putRecycledObject = _recyclePool.putRecycledObject;
+                _layoutProvider = binding._layoutProvider;
+                layoutTypeForIndex = _layoutProvider.getLayoutTypeForIndex(property);
+                key = property2.key;
+                Reflect.apply(putRecycledObject, _recyclePool, [layoutTypeForIndex, key]);
+                value6 = typeof r5 === 'bigint' ? r5 + 1n : +r5 + 1;
+                if (value6 < length) {
+                    r5 = value6;
+                    continue;
+                }
+                break;
+            }
+        }
+    }
+    if (Reflect.apply(env0_0._updateRenderStack, binding, [a1])) {
+        binding = env0_0;
+        binding._renderStackChanged(binding._renderStack);
+    }
+}
+
+function _fun50879(a0, a1) { // fn#50879, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:6647:5878, offset: 0x012245ef, size: 90 bytes, params: 3, frame: 5
+    const binding = env0_0;
+    const property = binding._renderStack[a0];
+    const property2 = binding._renderStack[a1];
+    return property && property.dataIndex && (property2 && property2.dataIndex) ? property.dataIndex - property2.dataIndex : 1;
+}
+