A Long class for representing a 64-bit two's-complement integer value. 

dcode

long

   * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as signed integers. See the from* functions below for more convenient ways of constructing Longs.

  constructor(low: number, high?: number, unsigned?: boolean);

   * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is assumed to use 32 bits.

  static fromBits(lowBits: number, highBits: number, unsigned?: boolean): Long;

   * Returns a Long representing the given 32 bit integer value.

  static fromInt(value: number, unsigned?: boolean): Long;

   * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.

  static fromNumber(value: number, unsigned?: boolean): Long;

   * Returns a Long representation of the given string, written using the specified radix.

  static fromString(str: string, unsigned?: boolean | number, radix?: number): Long;

   * Creates a Long from its byte representation.

  static fromBytes(bytes: number[], unsigned?: boolean, le?: boolean): Long;

   * Creates a Long from its little endian byte representation.

  static fromBytesLE(bytes: number[], unsigned?: boolean): Long;

   * Creates a Long from its big endian byte representation.

  static fromBytesBE(bytes: number[], unsigned?: boolean): Long;

   * Tests if the specified object is a Long.

   * Converts the specified value to a Long.

  static fromValue(val: Long | number | string | { low: number, high: number, unsigned: boolean }, unsigned?: boolean): Long;

      | { low: number; high: number; unsigned: boolean },

   * Returns the sum of this and the specified Long.

  add(addend: number | Long | string): Long;

   * Returns the bitwise AND of this Long and the specified.

  and(other: Long | number | string): Long;

   * Compares this Long's value with the specified's.

  compare(other: Long | number | string): number;

  comp(other: Long | number | string): number;

   * Returns this Long divided by the specified.

  divide(divisor: Long | number | string): Long;

  div(divisor: Long | number | string): Long;

   * Tests if this Long's value equals the specified's.

  equals(other: Long | number | string): boolean;

  eq(other: Long | number | string): boolean;

   * Gets the high 32 bits as a signed integer.

   * Gets the high 32 bits as an unsigned integer.

   * Gets the low 32 bits as a signed integer.

   * Gets the low 32 bits as an unsigned integer.

   * Gets the number of bits needed to represent the absolute value of this Long.

   * Tests if this Long's value is greater than the specified's.

  greaterThan(other: Long | number | string): boolean;

  gt(other: Long | number | string): boolean;

   * Tests if this Long's value is greater than or equal the specified's.

  greaterThanOrEqual(other: Long | number | string): boolean;

  gte(other: Long | number | string): boolean;

  ge(other: Long | number | string): boolean;

   * Tests if this Long's value is negative.

export = Long; // compatible with `import Long from "long"`

export default Long; // compatible with `import Long from "long"`

  "author": "Daniel Wirtz <dcode@dcode.io>",

  "description": "A Long class for representing a 64-bit two's-complement integer value.",

    "url": "https://github.com/dcodeIO/long.js.git"

    "url": "https://github.com/dcodeIO/long.js/issues"

    "build": "esm2umd Long index.js > umd/index.js",

  Object.defineProperty(exports, "__esModule", {

   * Licensed under the Apache License, Version 2.0 (the "License");

   * you may not use this file except in compliance with the License.

   * You may obtain a copy of the License at

   *     http://www.apache.org/licenses/LICENSE-2.0

   * Unless required by applicable law or agreed to in writing, software

   * distributed under the License is distributed on an "AS IS" BASIS,

   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   * See the License for the specific language governing permissions and

  // WebAssembly optimizations to do native i64 multiplication and divide

    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;

   * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.

   *  See the from* functions below for more convenient ways of constructing Longs.

   * @class A Long class for representing a 64 bit two's-complement integer value.

   * @param {number} low The low (signed) 32 bits of the long

   * @param {number} high The high (signed) 32 bits of the long

   * @param {boolean=} unsigned Whether unsigned or not, defaults to signed

     * The low 32 bits as a signed value.

     * The high 32 bits as a signed value.

  } // The internal representation of a long is the two given signed, 32-bit values.

  // We use 32-bit pieces because these are the size of integers on which

  // Javascript performs bit-operations.  For operations like addition and

  // multiplication, we split each number into 16 bit pieces, which can easily be

  // multiplied within Javascript's floating-point representation without overflow

  // In the algorithms below, we frequently reduce the negative case to the

  // positive case by negating the input(s) and then post-processing the result.

  // Note that we must ALWAYS check specially whether those values are MIN_VALUE

  // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as

  // a positive number, it overflows back into a negative).  Not handling this

  // case would often result in infinite recursion.

  // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*

   * An indicator used to reliably determine if an object is a Long or not.

  Object.defineProperty(Long.prototype, "__isLong__", {

if (typeof define === 'function' && define.amd) define([], function() { return Long; });

else if (typeof module === 'object' && typeof exports==='object') module.exports = Long;

else if (typeof module === 'object' && typeof exports === 'object') module.exports = Long;

		{
		"name": "long",
		"version": "5.2.1",
		"version": "5.2.2",
		"author": "Daniel Wirtz <dcode@dcode.io>",
		@@ -21,8 +21,13 @@ "description": "A Long class for representing a 64-bit two's-complement integer value.",
		"main": "umd/index.js",
		"types": "index.d.ts",
		"types": "umd/index.d.ts",
		"exports": {
		".": {
		"types": "./index.d.ts",
		"import": "./index.js",
		"require": "./umd/index.js"
		"import": {
		"default": "./index.js",
		"types": "./index.d.ts"
		},
		"require": {
		"default": "./umd/index.js",
		"types": "./umd/index.d.ts"
		}
		}
		@@ -44,4 +49,4 @@ },
		"devDependencies": {
		"esm2umd": "^0.2.0"
		"esm2umd": "^0.2.1"
		}
		}

		@@ -80,3 +80,7 @@ declare class Long {
		*/
		static fromString(str: string, unsigned?: boolean \| number, radix?: number): Long;
		static fromString(
		str: string,
		unsigned?: boolean \| number,
		radix?: number
		): Long;

		@@ -106,3 +110,10 @@ /**
		*/
		static fromValue(val: Long \| number \| string \| { low: number, high: number, unsigned: boolean }, unsigned?: boolean): Long;
		static fromValue(
		val:
		\| Long
		\| number
		\| string
		\| { low: number; high: number; unsigned: boolean },
		unsigned?: boolean
		): Long;

		@@ -448,2 +459,2 @@ /**

		export = Long; // compatible with `import Long from "long"`
		export default Long; // compatible with `import Long from "long"`

		@@ -1432,2 +1432,2 @@ // GENERATED FILE. DO NOT EDIT.
		if (typeof define === 'function' && define.amd) define([], function() { return Long; });
		else if (typeof module === 'object' && typeof exports==='object') module.exports = Long;
		else if (typeof module === 'object' && typeof exports === 'object') module.exports = Long;

Improved metrics