Initial commit

sources/by-id/module-01336.jsx

@@ -0,0 +1,536 @@
+/* Metro module 1336; source: unknown; dependencies: [57, 6, 7, 1320, 1329, 1337, 1334] */
+function _fun15247(global, require, importDefault, importAll, module, exports, dependencyMap) { // fn#15247, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1463:6, offset: 0x00e29674, size: 123 bytes, params: 8, frame: 17
+    const env0_0 = require;
+    const env0_2 = require(57) /* metro dependency 57 */;
+    const env0_3 = require(6) /* metro dependency 6 */;
+    const env0_4 = require(7) /* metro dependency 7 */;
+    const Object = global.Object;
+    Object.defineProperty(exports, '__esModule', {value: true});
+    exports.ReflectionBinaryReader = undefined;
+    exports.ReflectionBinaryReader = _fun15248();
+}
+
+function _fun15248() { // fn#15248, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1463:171, offset: 0x00e296ef, size: 124 bytes, params: 1, frame: 15
+    return env0_4(ReflectionBinaryReader, [{key: 'prepare', value: function() {
+        var r4;
+        var property;
+        var value;
+        if (!this.fieldNoToField) {
+            property = this.info.fields;
+            r4 = property === null ? [] : property !== undefined ? property : [];
+            property = global.Map;
+            value = r4.map(_fun15251);
+            value = new property();
+            this.fieldNoToField = value;
+        }
+    }}, {key: 'read', value: value_15252}, {key: 'mapEntry', value: value_15253}, {key: 'scalar', value: value_15254}]);
+}
+
+function value_15250() { // fn#15250, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1463:294, offset: 0x00e2976b, size: 95 bytes, params: 1, frame: 13
+    var r4;
+    var fields;
+    var Map;
+    var value;
+    if (!this.fieldNoToField) {
+        fields = this.info.fields;
+        r4 = fields === null ? [] : fields !== undefined ? fields : [];
+        Map = global.Map;
+        value = r4.map(function(a0) {
+            return [a0.no, a0];
+        });
+        this.fieldNoToField = new Map();
+    }
+}
+
+function value_15252(a0, a1, a2, a3) { // fn#15252, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1463:482, offset: 0x00e297e0, size: 1190 bytes, params: 5, frame: 58
+    var r42;
+    var r39;
+    var r41;
+    var L;
+    var tag;
+    var value5;
+    var value6;
+    var property;
+    var property2;
+    var fieldNoToField;
+    var get;
+    var value7;
+    var readUnknownField;
+    var skip;
+    var value8;
+    var UnknownFieldHandler;
+    var onRead;
+    var info;
+    var typeName;
+    var Error;
+    var concat;
+    var repeat;
+    var localName;
+    var oneof;
+    var oneofKind;
+    var value10;
+    var object2;
+    var kind;
+    var mapEntry;
+    var value11;
+    var value12;
+    var property3;
+    var T;
+    var value13;
+    var internalBinaryRead;
+    var uint32;
+    var value14;
+    var value15;
+    var value16;
+    var push;
+    const ScalarType = (require(1329) /* metro dependency 1329 */).ScalarType;
+    var INT32;
+    var scalar;
+    var WireType;
+    var LengthDelimited;
+    var STRING;
+    var BYTES;
+    var value17;
+    var value18;
+    const value = a1;
+    this.prepare();
+    const value2 = undefined;
+    const r24 = value2 === a3 ? a0.len : a0.pos + a3;
+    let pos = a0.pos;
+    if (pos < r24) {
+        reducibleLoop4: while (true) {
+            tag = a0.tag;
+            value5 = Reflect.apply(tag, a0, []);
+            value6 = env1_2(value5, 2);
+            property = value6[0];
+            property2 = value6[1];
+            fieldNoToField = this.fieldNoToField;
+            get = fieldNoToField.get;
+            value7 = Reflect.apply(get, fieldNoToField, [property]);
+            if (value7) {
+                repeat = value7.repeat;
+                localName = value7.localName;
+                oneof = value7.oneof;
+                reducibleJoin13: while (true) {
+                    if (oneof) {
+                        oneof = value7.oneof;
+                        property = value[oneof];
+                        oneofKind = property.oneofKind;
+                        value10 = oneofKind !== localName;
+                        r39 = value10;
+                        r42 = property;
+                        break reducibleJoin13;
+                    }
+                    r39 = oneof;
+                    r42 = value;
+                    break reducibleJoin13;
+                }
+                reducibleJoin15: while (true) {
+                    if (r39) {
+                        oneof = value7.oneof;
+                        object2 = {oneofKind: localName};
+                        value[oneof] = object2;
+                        r42 = object2;
+                        break reducibleJoin15;
+                    }
+                    break reducibleJoin15;
+                }
+                kind = value7.kind;
+                reducibleJoin36: while (true) {
+                    reducibleJoin23: while (true) {
+                        if (kind === 'scalar') {
+                            break reducibleJoin23;
+                        }
+                        if (kind === 'enum') {
+                            break reducibleJoin23;
+                        }
+                        if (kind === 'message') {
+                            if (repeat) {
+                                property = r42[localName];
+                                value15 = value7.T();
+                                value16 = value15.internalBinaryRead(a0, a0.uint32(), a2);
+                                push = property.push;
+                                Reflect.apply(push, property, [value16]);
+                                break reducibleJoin36;
+                            }
+                            T = value7.T;
+                            value13 = Reflect.apply(T, value7, []);
+                            internalBinaryRead = value13.internalBinaryRead;
+                            uint32 = a0.uint32;
+                            value14 = Reflect.apply(uint32, a0, []);
+                            r42[localName] = Reflect.apply(internalBinaryRead, value13, [a0, value14, a2,
+                                r42[localName]]);
+                            break reducibleJoin36;
+                        }
+                        if (kind !== 'map') {
+                            break reducibleJoin36;
+                        }
+                        mapEntry = this.mapEntry;
+                        value11 = Reflect.apply(mapEntry, this, [value7, a0, a2]);
+                        value12 = env1_2(value11, 2);
+                        property = value12[0];
+                        property3 = value12[1];
+                        r42[localName][property] = property3;
+                        break reducibleJoin36;
+                    }
+                    kind = value7.kind;
+                    if (kind == 'enum') {
+                        INT32 = ScalarType.INT32;
+                        r41 = INT32;
+                    } else {
+                        T = value7.T;
+                        r41 = T;
+                    }
+                    kind = value7.kind;
+                    reducibleJoin28: while (true) {
+                        if (kind == 'scalar') {
+                            L = value7.L;
+                            break reducibleJoin28;
+                        }
+                        L = value2;
+                        break reducibleJoin28;
+                    }
+                    if (repeat) {
+                        property = r42[localName];
+                        WireType = (require(1320) /* metro dependency 1320 */).WireType;
+                        LengthDelimited = WireType.LengthDelimited;
+                        if (property2 == LengthDelimited) {
+                            STRING = ScalarType.STRING;
+                            if (r41 != STRING) {
+                                BYTES = ScalarType.BYTES;
+                                if (r41 != BYTES) {
+                                    uint32 = a0.uint32;
+                                    value17 = Reflect.apply(uint32, a0, []);
+                                    pos = a0.pos;
+                                    value18 = value17 + pos;
+                                    pos = a0.pos;
+                                    if (pos < value18) {
+                                        reducibleLoop35: while (true) {
+                                            push = property.push;
+                                            scalar = this.scalar;
+                                            Reflect.apply(push, property, [Reflect.apply(scalar, this, [a0, r41, L])]);
+                                            pos = a0.pos;
+                                            if (pos < value18) {
+                                                continue reducibleLoop35;
+                                            }
+                                            break reducibleJoin36;
+                                        }
+                                        pos = a0.pos;
+                                        if (!(pos < r24)) {
+                                            return value2;
+                                        }
+                                        continue reducibleLoop4;
+                                    }
+                                    break reducibleJoin36;
+                                }
+                            }
+                        }
+                        push = property.push;
+                        scalar = this.scalar;
+                        Reflect.apply(push, property, [Reflect.apply(scalar, this, [a0, r41, L])]);
+                        break reducibleJoin36;
+                    }
+                    scalar = this.scalar;
+                    r42[localName] = Reflect.apply(scalar, this, [a0, r41, L]);
+                    break reducibleJoin36;
+                }
+            } else {
+                readUnknownField = a2.readUnknownField;
+                if (readUnknownField == 'throw') {
+                    Error = global.Error;
+                    typeName = this.info.typeName;
+                    concat = global.HermesInternal.concat;
+                    throw new Error('Unknown field ' + property + ' (wire type ' + property2 + ') for ' + typeName);
+                }
+                skip = a0.skip;
+                value8 = Reflect.apply(skip, a0, [property2]);
+                reducibleJoin36: while (true) {
+                    if (readUnknownField === false) {
+                        break reducibleJoin36;
+                    }
+                    reducibleJoin9: while (true) {
+                        if (readUnknownField !== true) {
+                            r42 = readUnknownField;
+                            break reducibleJoin9;
+                        }
+                        UnknownFieldHandler = (require(1320) /* metro dependency 1320 */).UnknownFieldHandler;
+                        onRead = UnknownFieldHandler.onRead;
+                        r42 = onRead;
+                        break reducibleJoin9;
+                    }
+                    info = this.info;
+                    typeName = info.typeName;
+                    r42(typeName, value, property, property2, value8);
+                    break reducibleJoin36;
+                }
+            }
+            pos = a0.pos;
+            if (!(pos < r24)) {
+                return value2;
+            }
+            continue reducibleLoop4;
+        }
+    }
+    return value2;
+}
+
+function value_15253(a0, a1, a2) { // fn#15253, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1463:1573, offset: 0x00e29c86, size: 704 bytes, params: 4, frame: 42
+    var r6;
+    var r11;
+    var r1;
+    var r19;
+    var r20;
+    var r2;
+    var r8;
+    var tag;
+    var value5;
+    var value6;
+    var property;
+    var property2;
+    var Error;
+    var typeName;
+    var name;
+    var concat;
+    var V;
+    var kind;
+    var T;
+    var value8;
+    var internalBinaryRead;
+    var value9;
+    var int32;
+    var value10;
+    var scalar;
+    var L;
+    var value11;
+    var K;
+    const ScalarType = (require(1329) /* metro dependency 1329 */).ScalarType;
+    var BOOL;
+    var LongType;
+    var STRING;
+    var value12;
+    var bool;
+    var value13;
+    var toString;
+    var value14;
+    var reflectionScalarDefault;
+    var create;
+    let value = a1.uint32();
+    let pos = a1.pos;
+    value = pos + value;
+    pos = a1.pos;
+    const value2 = undefined;
+    const value4 = 0;
+    if (pos < value) {
+        r6 = value2;
+        r11 = value2;
+        reducibleLoop1: while (true) {
+            tag = a1.tag;
+            value5 = Reflect.apply(tag, a1, []);
+            value6 = env1_2(value5, 2);
+            property = value6[value4];
+            property2 = value6[1];
+            if (property === 1) {
+                K = a0.K;
+                BOOL = ScalarType.BOOL;
+                if (K == BOOL) {
+                    bool = a1.bool;
+                    value13 = Reflect.apply(bool, a1, []);
+                    toString = value13.toString;
+                    value14 = Reflect.apply(toString, value13, []);
+                    r1 = value14;
+                } else {
+                    scalar = this.scalar;
+                    K = a0.K;
+                    LongType = (require(1329) /* metro dependency 1329 */).LongType;
+                    STRING = LongType.STRING;
+                    value12 = Reflect.apply(scalar, this, [a1, K, STRING]);
+                    r1 = value12;
+                }
+                r19 = r6;
+                r20 = r1;
+            } else {
+                if (property !== 2) {
+                    Error = global.Error;
+                    typeName = this.info.typeName;
+                    name = a0.name;
+                    concat = global.HermesInternal.concat;
+                    throw new Error('Unknown field ' + property + ' (wire type ' + property2 + ') in map entry for ' + typeName + '#' + name);
+                }
+                V = a0.V;
+                kind = V.kind;
+                if (kind === 'scalar') {
+                    scalar = this.scalar;
+                    V = a0.V;
+                    T = V.T;
+                    V = a0.V;
+                    L = V.L;
+                    value11 = Reflect.apply(scalar, this, [a1, T, L]);
+                    r19 = value11;
+                    r20 = r11;
+                } else if (kind === 'enum') {
+                    int32 = a1.int32;
+                    value10 = Reflect.apply(int32, a1, []);
+                    r19 = value10;
+                    r20 = r11;
+                } else {
+                    reducibleJoin14: while (true) {
+                        if (kind !== 'message') {
+                            r19 = r6;
+                            r20 = r11;
+                            break reducibleJoin14;
+                        }
+                        V = a0.V;
+                        T = V.T;
+                        value8 = Reflect.apply(T, V, []);
+                        internalBinaryRead = value8.internalBinaryRead;
+                        value9 = Reflect.apply(internalBinaryRead, value8, [a1, a1.uint32(), a2]);
+                        r19 = value9;
+                        r20 = r11;
+                        break reducibleJoin14;
+                    }
+                }
+            }
+            pos = a1.pos;
+            if (pos < value) {
+                r6 = r19;
+                r11 = r20;
+                continue reducibleLoop1;
+            }
+            r2 = r20;
+            r8 = r19;
+            break reducibleLoop1;
+        }
+    } else {
+        r2 = value2;
+        r8 = value2;
+    }
+    reducibleJoin19: while (true) {
+        if (value2 !== r2) {
+            break reducibleJoin19;
+        }
+        value = require(1337) /* metro dependency 1337 */;
+        reflectionScalarDefault = value.reflectionScalarDefault;
+        K = a0.K;
+        value = Reflect.apply(reflectionScalarDefault, value, [K]);
+        K = a0.K;
+        BOOL = ScalarType.BOOL;
+        reducibleJoin18: while (true) {
+            if (K != BOOL) {
+                r1 = value;
+                break reducibleJoin18;
+            }
+            toString = value.toString;
+            value = Reflect.apply(toString, value, []);
+            r1 = value;
+            break reducibleJoin18;
+        }
+        r2 = r1;
+        break reducibleJoin19;
+    }
+    reducibleJoin25: while (true) {
+        if (value2 !== r8) {
+            r1 = r8;
+            break reducibleJoin25;
+        }
+        V = a0.V;
+        kind = V.kind;
+        if (kind === 'scalar') {
+            value = require(1337) /* metro dependency 1337 */;
+            reflectionScalarDefault = value.reflectionScalarDefault;
+            V = a0.V;
+            T = V.T;
+            V = a0.V;
+            L = V.L;
+            value = Reflect.apply(reflectionScalarDefault, value, [T, L]);
+            r1 = value;
+            break reducibleJoin25;
+        }
+        if (kind === 'enum') {
+            r1 = value4;
+            break reducibleJoin25;
+        }
+        if (kind !== 'message') {
+            r1 = r8;
+            break reducibleJoin25;
+        }
+        V = a0.V;
+        T = V.T;
+        value = Reflect.apply(T, V, []);
+        create = value.create;
+        value = Reflect.apply(create, value, []);
+        r1 = value;
+        break reducibleJoin25;
+    }
+    return [r2, r1];
+}
+
+function value_15254(a0, a1, a2) { // fn#15254, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:1463:2384, offset: 0x00e29f46, size: 900 bytes, params: 4, frame: 17
+    let value = environment.__proto__;
+    const ScalarType = (require(1329) /* metro dependency 1329 */).ScalarType;
+    const INT32 = ScalarType.INT32;
+    if (INT32 === a1) {
+        return a0.int32();
+    }
+    const STRING = ScalarType.STRING;
+    if (STRING === a1) {
+        return a0.string();
+    }
+    const BOOL = ScalarType.BOOL;
+    if (BOOL === a1) {
+        return a0.bool();
+    }
+    const DOUBLE = ScalarType.DOUBLE;
+    if (DOUBLE === a1) {
+        return a0.double();
+    }
+    const FLOAT = ScalarType.FLOAT;
+    if (FLOAT === a1) {
+        return a0.float();
+    }
+    const INT64 = ScalarType.INT64;
+    if (INT64 === a1) {
+        value = require(1334) /* metro dependency 1334 */;
+        return value.reflectionLongConvert(a0.int64(), a2);
+    }
+    const UINT64 = ScalarType.UINT64;
+    if (UINT64 === a1) {
+        value = require(1334) /* metro dependency 1334 */;
+        return value.reflectionLongConvert(a0.uint64(), a2);
+    }
+    const FIXED64 = ScalarType.FIXED64;
+    if (FIXED64 === a1) {
+        value = require(1334) /* metro dependency 1334 */;
+        return value.reflectionLongConvert(a0.fixed64(), a2);
+    }
+    const FIXED32 = ScalarType.FIXED32;
+    if (FIXED32 === a1) {
+        return a0.fixed32();
+    }
+    const BYTES = ScalarType.BYTES;
+    if (BYTES === a1) {
+        return a0.bytes();
+    }
+    const UINT32 = ScalarType.UINT32;
+    if (UINT32 === a1) {
+        return a0.uint32();
+    }
+    const SFIXED32 = ScalarType.SFIXED32;
+    if (SFIXED32 === a1) {
+        return a0.sfixed32();
+    }
+    const SFIXED64 = ScalarType.SFIXED64;
+    if (SFIXED64 === a1) {
+        value = require(1334) /* metro dependency 1334 */;
+        return value.reflectionLongConvert(a0.sfixed64(), a2);
+    }
+    const SINT32 = ScalarType.SINT32;
+    if (SINT32 === a1) {
+        return a0.sint32();
+    }
+    const SINT64 = ScalarType.SINT64;
+    if (SINT64 === a1) {
+        value = require(1334) /* metro dependency 1334 */;
+        return value.reflectionLongConvert(a0.sint64(), a2);
+    }
+}
+