import { EJSONOptions } from "./extended_json.ts";import type { Timestamp } from "./timestamp.ts";
export interface LongExtended { $numberLong: string;}
interface LongWASMHelpers { get_high(): number; div_u( lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number, ): number; div_s( lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number, ): number; rem_u( lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number, ): number; rem_s( lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number, ): number; mul( lowBits: number, highBits: number, lowBitsMultiplier: number, highBitsMultiplier: number, ): number;}
const wasm = new WebAssembly.Instance( new WebAssembly.Module( new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11]), ), {},).exports as unknown as LongWASMHelpers;
const TWO_PWR_16_DBL = 1 << 16;const TWO_PWR_24_DBL = 1 << 24;const TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;const TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;const TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
const INT_CACHE: { [key in number]?: Long } = {};
const UINT_CACHE: { [key in number]?: Long } = {};
export class Long { _bsontype = "Long"; high!: number;
low!: number;
unsigned!: boolean;
constructor( low: number | bigint | string = 0, high?: number | boolean, unsigned?: boolean, ) { if (typeof low === "bigint") { Object.assign(this, Long.fromBigInt(low, !!high)); } else if (typeof low === "string") { Object.assign(this, Long.fromString(low, !!high)); } else { this.low = low | 0; this.high = (high as number) | 0; this.unsigned = !!unsigned; } }
static TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
static MAX_UNSIGNED_VALUE = Long.fromBits( 0xff_ff_ff_ff | 0, 0xff_ff_ff_ff | 0, true, ); static ZERO = Long.fromInt(0); static UZERO = Long.fromInt(0, true); static ONE = Long.fromInt(1); static UONE = Long.fromInt(1, true); static NEG_ONE = Long.fromInt(-1); static MAX_VALUE = Long.fromBits(0xff_ff_ff_ff | 0, 0x7f_ff_ff_ff | 0, false); static MIN_VALUE = Long.fromBits(0, 0x80_00_00_00 | 0, false);
static fromBits(lowBits: number, highBits: number, unsigned?: boolean): Long { return new Long(lowBits, highBits, unsigned); }
static fromInt(value: number, unsigned?: boolean): Long { let obj; let cache; if (unsigned) { value >>>= 0; if ((cache = 0 <= value && value < 256)) { const cachedObj = UINT_CACHE[value]; if (cachedObj) return cachedObj; } obj = Long.fromBits(value, (value | 0) < 0 ? -1 : 0, true); if (cache) UINT_CACHE[value] = obj; return obj; } value |= 0; if ((cache = -128 <= value && value < 128)) { const cachedObj = INT_CACHE[value]; if (cachedObj) return cachedObj; } obj = Long.fromBits(value, value < 0 ? -1 : 0, false); if (cache) INT_CACHE[value] = obj; return obj; }
static fromNumber(value: number, unsigned?: boolean): Long { if (isNaN(value)) return unsigned ? Long.UZERO : Long.ZERO; if (unsigned) { if (value < 0) return Long.UZERO; if (value >= TWO_PWR_64_DBL) return Long.MAX_UNSIGNED_VALUE; } else { if (value <= -TWO_PWR_63_DBL) return Long.MIN_VALUE; if (value + 1 >= TWO_PWR_63_DBL) return Long.MAX_VALUE; } if (value < 0) return Long.fromNumber(-value, unsigned).neg(); return Long.fromBits( value % TWO_PWR_32_DBL | 0, (value / TWO_PWR_32_DBL) | 0, unsigned, ); }
static fromBigInt(value: bigint, unsigned?: boolean): Long { return Long.fromString(value.toString(), unsigned); }
static fromString(str: string, unsigned?: boolean, radix?: number): Long { if (str.length === 0) throw Error("empty string"); if ( str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity" ) { return Long.ZERO; } if (typeof unsigned === "number") { (radix = unsigned), (unsigned = false); } else { unsigned = !!unsigned; } radix = radix || 10; if (radix < 2 || 36 < radix) throw RangeError("radix");
let p; if ((p = str.indexOf("-")) > 0) throw Error("interior hyphen"); else if (p === 0) { return Long.fromString(str.substring(1), unsigned, radix).neg(); }
const radixToPower = Long.fromNumber(radix ** 8);
let result = Long.ZERO; for (let i = 0; i < str.length; i += 8) { const size = Math.min(8, str.length - i); const value = parseInt(str.substring(i, i + size), radix); if (size < 8) { const power = Long.fromNumber(radix ** size); result = result.mul(power).add(Long.fromNumber(value)); } else { result = result.mul(radixToPower); result = result.add(Long.fromNumber(value)); } } result.unsigned = unsigned; return result; }
static fromBytes(bytes: number[], unsigned?: boolean, le?: boolean): Long { return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned); }
static fromBytesLE(bytes: number[], unsigned?: boolean): Long { return new Long( bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24), bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24), unsigned, ); }
static fromBytesBE(bytes: number[], unsigned?: boolean): Long { return new Long( (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7], (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3], unsigned, ); }
static isLong(value: any): value is Long { return value instanceof Long; }
static fromValue( val: number | string | { low: number; high: number; unsigned?: boolean }, unsigned?: boolean, ): Long { if (typeof val === "number") return Long.fromNumber(val, unsigned); if (typeof val === "string") return Long.fromString(val, unsigned); return Long.fromBits( val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned, ); }
add(addend: string | number | Long | Timestamp): Long { if (!Long.isLong(addend)) addend = Long.fromValue(addend);
const a48 = this.high >>> 16; const a32 = this.high & 0xff_ff; const a16 = this.low >>> 16; const a00 = this.low & 0xff_ff;
const b48 = addend.high >>> 16; const b32 = addend.high & 0xff_ff; const b16 = addend.low >>> 16; const b00 = addend.low & 0xff_ff;
let c48 = 0; let c32 = 0; let c16 = 0; let c00 = 0; c00 += a00 + b00; c16 += c00 >>> 16; c00 &= 0xff_ff; c16 += a16 + b16; c32 += c16 >>> 16; c16 &= 0xff_ff; c32 += a32 + b32; c48 += c32 >>> 16; c32 &= 0xff_ff; c48 += a48 + b48; c48 &= 0xff_ff; return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); }
and(other: string | number | Long | Timestamp): Long { if (!Long.isLong(other)) other = Long.fromValue(other); return Long.fromBits( this.low & other.low, this.high & other.high, this.unsigned, ); }
compare(other: string | number | Long | Timestamp): 0 | 1 | -1 { if (!Long.isLong(other)) other = Long.fromValue(other); if (this.eq(other)) return 0; const thisNeg = this.isNegative(); const otherNeg = other.isNegative(); if (thisNeg && !otherNeg) return -1; if (!thisNeg && otherNeg) return 1; if (!this.unsigned) return this.sub(other).isNegative() ? -1 : 1; return other.high >>> 0 > this.high >>> 0 || (other.high === this.high && other.low >>> 0 > this.low >>> 0) ? -1 : 1; }
comp(other: string | number | Long | Timestamp): 0 | 1 | -1 { return this.compare(other); }
divide(divisor: string | number | Long | Timestamp): Long { if (!Long.isLong(divisor)) divisor = Long.fromValue(divisor); if (divisor.isZero()) throw Error("division by zero");
if ( !this.unsigned && this.high === -0x80_00_00_00 && divisor.low === -1 && divisor.high === -1 ) { return this; } const low = (this.unsigned ? wasm.div_u : wasm.div_s)( this.low, this.high, divisor.low, divisor.high, ); return Long.fromBits(low, wasm.get_high(), this.unsigned); }
div(divisor: string | number | Long | Timestamp): Long { return this.divide(divisor); }
equals(other: string | number | Long | Timestamp): boolean { if (!Long.isLong(other)) other = Long.fromValue(other); if ( this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1 ) { return false; } return this.high === other.high && this.low === other.low; }
eq(other: string | number | Long | Timestamp): boolean { return this.equals(other); }
getHighBits(): number { return this.high; }
getHighBitsUnsigned(): number { return this.high >>> 0; }
getLowBits(): number { return this.low; }
getLowBitsUnsigned(): number { return this.low >>> 0; }
getNumBitsAbs(): number { if (this.isNegative()) { return this.eq(Long.MIN_VALUE) ? 64 : this.neg().getNumBitsAbs(); } const val = this.high !== 0 ? this.high : this.low; let bit: number; for (bit = 31; bit > 0; bit--) if ((val & (1 << bit)) !== 0) break; return this.high !== 0 ? bit + 33 : bit + 1; }
greaterThan(other: string | number | Long | Timestamp): boolean { return this.comp(other) > 0; }
gt(other: string | number | Long | Timestamp): boolean { return this.greaterThan(other); }
greaterThanOrEqual(other: string | number | Long | Timestamp): boolean { return this.comp(other) >= 0; }
gte(other: string | number | Long | Timestamp): boolean { return this.greaterThanOrEqual(other); } ge(other: string | number | Long | Timestamp): boolean { return this.greaterThanOrEqual(other); }
isEven(): boolean { return (this.low & 1) === 0; }
isNegative(): boolean { return !this.unsigned && this.high < 0; }
isOdd(): boolean { return (this.low & 1) === 1; }
isPositive(): boolean { return this.unsigned || this.high >= 0; }
isZero(): boolean { return this.high === 0 && this.low === 0; }
lessThan(other: string | number | Long | Timestamp): boolean { return this.comp(other) < 0; }
lt(other: string | number | Long | Timestamp): boolean { return this.lessThan(other); }
lessThanOrEqual(other: string | number | Long | Timestamp): boolean { return this.comp(other) <= 0; }
lte(other: string | number | Long | Timestamp): boolean { return this.lessThanOrEqual(other); }
modulo(divisor: string | number | Long | Timestamp): Long { if (!Long.isLong(divisor)) divisor = Long.fromValue(divisor);
const low = (this.unsigned ? wasm.rem_u : wasm.rem_s)( this.low, this.high, divisor.low, divisor.high, ); return Long.fromBits(low, wasm.get_high(), this.unsigned); }
mod(divisor: string | number | Long | Timestamp): Long { return this.modulo(divisor); } rem(divisor: string | number | Long | Timestamp): Long { return this.modulo(divisor); }
multiply(multiplier: string | number | Long | Timestamp): Long { if (this.isZero()) return Long.ZERO; if (!Long.isLong(multiplier)) multiplier = Long.fromValue(multiplier);
const low = wasm.mul( this.low, this.high, multiplier.low, multiplier.high, ); return Long.fromBits(low, wasm.get_high(), this.unsigned); }
mul(multiplier: string | number | Long | Timestamp): Long { return this.multiply(multiplier); }
negate(): Long { if (!this.unsigned && this.eq(Long.MIN_VALUE)) return Long.MIN_VALUE; return this.not().add(Long.ONE); }
neg(): Long { return this.negate(); }
not(): Long { return Long.fromBits(~this.low, ~this.high, this.unsigned); }
notEquals(other: string | number | Long | Timestamp): boolean { return !this.equals(other); }
neq(other: string | number | Long | Timestamp): boolean { return this.notEquals(other); } ne(other: string | number | Long | Timestamp): boolean { return this.notEquals(other); }
or(other: number | string | Long): Long { if (!Long.isLong(other)) other = Long.fromValue(other); return Long.fromBits( this.low | other.low, this.high | other.high, this.unsigned, ); }
shiftLeft(numBits: number | Long): Long { if (Long.isLong(numBits)) numBits = numBits.toInt(); if ((numBits &= 63) === 0) return this; if (numBits < 32) { return Long.fromBits( this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned, ); } return Long.fromBits(0, this.low << (numBits - 32), this.unsigned); }
shl(numBits: number | Long): Long { return this.shiftLeft(numBits); }
shiftRight(numBits: number | Long): Long { if (Long.isLong(numBits)) numBits = numBits.toInt(); if ((numBits &= 63) === 0) return this; if (numBits < 32) { return Long.fromBits( (this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned, ); } return Long.fromBits( this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned, ); }
shr(numBits: number | Long): Long { return this.shiftRight(numBits); }
shiftRightUnsigned(numBits: Long | number): Long { if (Long.isLong(numBits)) numBits = numBits.toInt(); numBits &= 63; if (numBits === 0) return this; const high = this.high; if (numBits < 32) { const low = this.low; return Long.fromBits( (low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned, ); } if (numBits === 32) return Long.fromBits(high, 0, this.unsigned); else return Long.fromBits(high >>> (numBits - 32), 0, this.unsigned); }
shr_u(numBits: number | Long): Long { return this.shiftRightUnsigned(numBits); } shru(numBits: number | Long): Long { return this.shiftRightUnsigned(numBits); }
subtract(subtrahend: string | number | Long | Timestamp): Long { if (!Long.isLong(subtrahend)) subtrahend = Long.fromValue(subtrahend); return this.add(subtrahend.neg()); }
sub(subtrahend: string | number | Long | Timestamp): Long { return this.subtract(subtrahend); }
toInt(): number { return this.unsigned ? this.low >>> 0 : this.low; }
toNumber(): number { if (this.unsigned) { return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0); } return this.high * TWO_PWR_32_DBL + (this.low >>> 0); }
toBigInt(): bigint { return BigInt(this.toString()); }
toBytes(le?: boolean): number[] { return le ? this.toBytesLE() : this.toBytesBE(); }
toBytesLE(): number[] { const hi = this.high; const lo = this.low; return [ lo & 0xff, (lo >>> 8) & 0xff, (lo >>> 16) & 0xff, lo >>> 24, hi & 0xff, (hi >>> 8) & 0xff, (hi >>> 16) & 0xff, hi >>> 24, ]; }
toBytesBE(): number[] { const hi = this.high; const lo = this.low; return [ hi >>> 24, (hi >>> 16) & 0xff, (hi >>> 8) & 0xff, hi & 0xff, lo >>> 24, (lo >>> 16) & 0xff, (lo >>> 8) & 0xff, lo & 0xff, ]; }
toSigned(): Long { if (!this.unsigned) return this; return Long.fromBits(this.low, this.high, false); }
toString(radix = 10): string { if (radix < 2 || 36 < radix) throw RangeError("radix"); if (this.isZero()) return "0"; if (this.isNegative()) { if (this.eq(Long.MIN_VALUE)) { const radixLong = Long.fromNumber(radix); const div = this.div(radixLong); const rem1 = div.mul(radixLong).sub(this); return div.toString(radix) + rem1.toInt().toString(radix); } return `-${this.neg().toString(radix)}`; }
const radixToPower = Long.fromNumber(radix ** 6, this.unsigned); let rem: Long = this; let result = ""; while (true) { const remDiv = rem.div(radixToPower); const intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0; let digits = intval.toString(radix); rem = remDiv; if (rem.isZero()) { return digits + result; } while (digits.length < 6) digits = `0${digits}`; result = `${digits}${result}`; } }
toUnsigned(): Long { if (this.unsigned) return this; return Long.fromBits(this.low, this.high, true); }
xor(other: Long | number | string): Long { if (!Long.isLong(other)) other = Long.fromValue(other); return Long.fromBits( this.low ^ other.low, this.high ^ other.high, this.unsigned, ); }
eqz(): boolean { return this.isZero(); }
le(other: string | number | Long | Timestamp): boolean { return this.lessThanOrEqual(other); }
[Symbol.for("Deno.customInspect")](): string { return `new Long("${this.toString()}"${this.unsigned ? ", true" : ""})`; }
toExtendedJSON(options?: EJSONOptions): number | LongExtended { if (options && options.relaxed) return this.toNumber(); return { $numberLong: this.toString() }; }
static fromExtendedJSON( doc: { $numberLong: string }, options?: EJSONOptions, ): number | Long { const result = Long.fromString(doc.$numberLong); return options && options.relaxed ? result.toNumber() : result; }}