372 lines
8.5 KiB
JavaScript
372 lines
8.5 KiB
JavaScript
// Metro module 506 (f507).
|
|
import _slicedToArray from "./_slicedToArray";
|
|
import Integer from "./Integer";
|
|
let c490_4, c490_5, c490_6, c490_7, c490_8, c490_9, c490_10;
|
|
class HighLow {
|
|
constructor(a0, a1) {
|
|
this.parts = a0;
|
|
this.str = a1;
|
|
}
|
|
static fromString(a0) {
|
|
let r10;
|
|
const r19 = [];
|
|
const r15 = 0 < a0.length;
|
|
let r8 = 0;
|
|
if (r15) {
|
|
do {
|
|
L7: {
|
|
const r27 = Number(a0[r8]);
|
|
r10 = r8;
|
|
let r9 = 0;
|
|
let r28 = r27;
|
|
if (!r27) {
|
|
const r29 = 0 < r19.length;
|
|
r9 = 0;
|
|
r28 = r27;
|
|
if (!r29) {
|
|
break L7;
|
|
}
|
|
}
|
|
while (true) {
|
|
let r30 = r19[r9];
|
|
const r12 = r9;
|
|
const r31 = r28;
|
|
if (!r30) {
|
|
r30 = 0;
|
|
}
|
|
const r33 = r31 + 10 * r30;
|
|
r19[r12] = r33 % 16;
|
|
const r37 = (r33 - r19[r12]) / 16;
|
|
const r38 = r12 + 1;
|
|
r9 = r38;
|
|
r28 = r37;
|
|
if (!r37) {
|
|
const length = r19.length;
|
|
r28 = r37;
|
|
r9 = r38;
|
|
if (!(r9 < length)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
r8 = r10 + 1;
|
|
} while (r8 < a0.length);
|
|
}
|
|
const parts5 = Array(4);
|
|
let r46 = 0;
|
|
loop9: while (true) {
|
|
const r11 = 4 * r46;
|
|
const r47 = r46;
|
|
let r1 = 0;
|
|
let r48 = 0;
|
|
while (true) {
|
|
const r49 = r19[r11 + r1];
|
|
const r5 = r1;
|
|
const r4 = r48;
|
|
let r50 = r4;
|
|
if (r49 !== void 0) {
|
|
r48 = r4 + r49 * 16 ** r5;
|
|
r1 = r5 + 1;
|
|
r50 = r48;
|
|
if (r1 < 4) {
|
|
continue;
|
|
}
|
|
}
|
|
parts5[3 - r47] = r50;
|
|
r46 = r47 + 1;
|
|
if (r46 < 4) {
|
|
continue loop9;
|
|
}
|
|
const r57 = {
|
|
__proto__: HighLow.prototype
|
|
};
|
|
r57.parts = parts5;
|
|
r57.str = a0;
|
|
return r57;
|
|
}
|
|
}
|
|
}
|
|
static fromBit(a0) {
|
|
const parts5 = Array(4);
|
|
const r17 = Math.floor(a0 / 16);
|
|
let r18 = 0;
|
|
while (true) {
|
|
const r3 = r18;
|
|
parts5[3 - r3] = r3 === r17 ? 1 << a0 - 16 * r17 : 0;
|
|
r18 = r3 + 1;
|
|
if (!(r18 < 4)) {
|
|
const r26 = {
|
|
__proto__: HighLow.prototype
|
|
};
|
|
r26.parts = parts5;
|
|
r26.str = void 0;
|
|
return r26;
|
|
}
|
|
}
|
|
}
|
|
static asUintN(a0, { parts: parts5 }) {
|
|
let r32;
|
|
const r6 = 0 < a0;
|
|
let r5 = 0;
|
|
if (r6) {
|
|
const r0 = 16 * parts5.length;
|
|
let r16 = 0;
|
|
let r2 = 0;
|
|
r5 = 0;
|
|
if (0 < r0) {
|
|
do {
|
|
const r18 = Math.min(a0 - r16, 16);
|
|
const r19 = 1 << r18;
|
|
const r29 = r2 | (parts5[parts5.length - Math.floor(r16 / 16) - 1] & r19 - 1) << r16;
|
|
const r30 = r16 + r18;
|
|
r5 = r29;
|
|
if (!(r30 < a0)) {
|
|
break;
|
|
}
|
|
r32 = 16 * parts5.length;
|
|
r2 = r29;
|
|
r5 = r2;
|
|
r16 = r30;
|
|
} while (r16 < r32);
|
|
}
|
|
}
|
|
return r5;
|
|
}
|
|
and({ parts }) {
|
|
const parts5 = this.parts.map((part, index) => part & parts[index]);
|
|
const r15 = {
|
|
__proto__: HighLow.prototype
|
|
};
|
|
r15.parts = parts5;
|
|
r15.str = void 0;
|
|
return r15;
|
|
}
|
|
or({ parts: parts2 }) {
|
|
const parts5 = this.parts.map((part, index) => part | parts2[index]);
|
|
const r15 = {
|
|
__proto__: HighLow.prototype
|
|
};
|
|
r15.parts = parts5;
|
|
r15.str = void 0;
|
|
return r15;
|
|
}
|
|
xor({ parts: parts3 }) {
|
|
const parts5 = this.parts.map((part, index) => part ^ parts3[index]);
|
|
const r15 = {
|
|
__proto__: HighLow.prototype
|
|
};
|
|
r15.parts = parts5;
|
|
r15.str = void 0;
|
|
return r15;
|
|
}
|
|
not() {
|
|
const parts5 = this.parts.map((part) => ~part);
|
|
const r12 = {
|
|
__proto__: HighLow.prototype
|
|
};
|
|
r12.parts = parts5;
|
|
r12.str = void 0;
|
|
return r12;
|
|
}
|
|
equals({ parts: parts4 }) {
|
|
return this.parts.every((part, index) => part === parts4[index]);
|
|
}
|
|
toString() {
|
|
if (this.str != null) {
|
|
return this.str;
|
|
}
|
|
const array = new Array(16);
|
|
let c12349_0 = array;
|
|
this.parts.forEach((part, index) => {
|
|
let r4, r39;
|
|
const r17 = part.toString();
|
|
const r21 = [];
|
|
const r11 = 0 < r17.length;
|
|
let r0 = 0;
|
|
let r3 = 0;
|
|
if (r11) {
|
|
do {
|
|
L7: {
|
|
const r24 = Number(r17[r0]);
|
|
r4 = r0;
|
|
let r1 = 0;
|
|
let r25 = r24;
|
|
if (!r24) {
|
|
const r26 = 0 < r21.length;
|
|
r1 = 0;
|
|
r25 = r24;
|
|
if (!r26) {
|
|
break L7;
|
|
}
|
|
}
|
|
while (true) {
|
|
let r27 = r21[r1];
|
|
const r6 = r1;
|
|
const r28 = r25;
|
|
if (!r27) {
|
|
r27 = 0;
|
|
}
|
|
const r30 = r28 + 10 * r27;
|
|
r21[r6] = r30 % 16;
|
|
const r34 = (r30 - r21[r6]) / 16;
|
|
const r35 = r6 + 1;
|
|
r1 = r35;
|
|
r25 = r34;
|
|
if (!r34) {
|
|
const length = r21.length;
|
|
r25 = r34;
|
|
r1 = r35;
|
|
if (!(r1 < length)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r37 = r4 + 1;
|
|
r39 = r37 < r17.length;
|
|
r0 = r37;
|
|
r3 = 0;
|
|
} while (r39);
|
|
}
|
|
while (true) {
|
|
const r41 = 4 * index;
|
|
let r43 = r21[3 - r3];
|
|
const r44 = r3;
|
|
if (!r43) {
|
|
r43 = 0;
|
|
}
|
|
c12349_0[r44 + r41] = r43;
|
|
r3 = r44 + 1;
|
|
if (!(r3 < 4)) {
|
|
return void 0;
|
|
}
|
|
}
|
|
});
|
|
const str = Integer.fromArray(array, 16).toString();
|
|
this.str = str;
|
|
return str;
|
|
}
|
|
toJSON() {
|
|
return this.toString();
|
|
}
|
|
}
|
|
const r4 = (function checkBrowserSupportsBigInt() {
|
|
try {
|
|
BigInt;
|
|
} catch ($e) {
|
|
return false;
|
|
}
|
|
return true;
|
|
})();
|
|
if (r4 && BigInt.prototype.toJSON == null) {
|
|
BigInt.prototype.toJSON = function() {
|
|
return this.toString();
|
|
};
|
|
}
|
|
const r14 = r4 ? function(a0) {
|
|
return typeof a0 === "bigint";
|
|
} : function(a0) {
|
|
return a0 instanceof HighLow;
|
|
};
|
|
c490_4 = {};
|
|
const r52 = r4 ? function(a0) {
|
|
return BigInt(a0);
|
|
} : function(a0) {
|
|
const r0 = a0 instanceof HighLow;
|
|
let r1 = a0;
|
|
if (!r0) {
|
|
const r3 = typeof a0 === "number" ? a0.toString() : a0;
|
|
if (c490_4[r3] == null) {
|
|
c490_4[r3] = HighLow.fromString(r3);
|
|
}
|
|
r1 = c490_4[r3];
|
|
}
|
|
return r1;
|
|
};
|
|
c490_5 = r52(0);
|
|
c490_6 = r4 ? function(r2 = c490_5, r1 = c490_5) {
|
|
return r2 & r1;
|
|
} : function(r3 = c490_5, r2 = c490_5) {
|
|
return r3.and(r2);
|
|
};
|
|
c490_7 = r4 ? function(r2 = c490_5, r1 = c490_5) {
|
|
return r2 | r1;
|
|
} : function(r3 = c490_5, r2 = c490_5) {
|
|
return r3.or(r2);
|
|
};
|
|
c490_8 = r4 ? function(r2 = c490_5, r1 = c490_5) {
|
|
return r2 ^ r1;
|
|
} : function(r3 = c490_5, r2 = c490_5) {
|
|
return r3.xor(r2);
|
|
};
|
|
const r57 = r4 ? function(r1 = c490_5) {
|
|
return ~r1;
|
|
} : function(r2 = c490_5) {
|
|
return r2.not();
|
|
};
|
|
c490_9 = r4 ? function(a0, a1) {
|
|
return a0 === a1;
|
|
} : function(a0, a1) {
|
|
return a0 != null && a1 != null ? a0.equals(a1) : a0 == a1;
|
|
};
|
|
c490_10 = r4 ? function(a0) {
|
|
return BigInt(1) << BigInt(a0);
|
|
} : function(a0) {
|
|
return HighLow.fromBit(a0);
|
|
};
|
|
const r60 = r4 ? function(a0, a1) {
|
|
return Number(BigInt.asUintN(a0, a1));
|
|
} : function(a0, a1) {
|
|
return HighLow.asUintN(a0, a1);
|
|
};
|
|
export { r14 as isBigFlag };
|
|
export { r52 as deserialize };
|
|
export { c490_5 as EMPTY_FLAG };
|
|
export { c490_6 as filter };
|
|
export { r57 as invert };
|
|
export { c490_9 as equals };
|
|
export function combine(...args) {
|
|
let length;
|
|
let r7 = args[0];
|
|
const r4 = 1 < args.length;
|
|
let r0 = 1;
|
|
let r5 = r7;
|
|
if (r4) {
|
|
do {
|
|
r7 = c490_7(r7, args[r0]);
|
|
r0 = r0 + 1;
|
|
length = args.length;
|
|
r5 = r7;
|
|
} while (r0 < length);
|
|
}
|
|
return r5;
|
|
}
|
|
export function has(a0, a1) {
|
|
return c490_9(c490_6(a0, a1), a1);
|
|
}
|
|
export function hasAny(a0, a1) {
|
|
return !c490_9(c490_6(a0, a1), c490_5);
|
|
}
|
|
export function add(a0, a1) {
|
|
return a1 !== c490_5 ? c490_7(a0, a1) : a0;
|
|
}
|
|
export function remove(a0, a1) {
|
|
return a1 !== c490_5 ? c490_8(a0, c490_6(a0, a1)) : a0;
|
|
}
|
|
export { c490_10 as getFlag };
|
|
export { r60 as asUintN };
|
|
export function getBrandedFlag(a0) {
|
|
return c490_10(a0);
|
|
}
|
|
export function flagNameOf(a0, a1) {
|
|
for (const item of Object.entries(a1)) {
|
|
const r29 = _slicedToArray(item, 2);
|
|
const r30 = r29[0];
|
|
if (!c490_9(a0, r29[1])) {
|
|
continue;
|
|
}
|
|
return r30;
|
|
}
|
|
}
|