Where does number end and bigint begin? It's not like values below some threshold are numbers, and above that threshold they're bigints. They're two entirely different ways of representing numeric values. JavaScript's "number" type is a floating point type , which means that numbers are rounded to about 53 significant binary digits (which is roughly equivalent to 16 significant decimal digits). So you can store very large numbers, but your results will be inexact. Try calculating 10000000000000001 - 10000000000000000 and see what you get. What does n stand for or translate to? It's just syntax that tells the JS parser to interpret your numeric constant as a BigInt instead of a Number, so that it will be represented exactly. Is it infinity, or does it make it some continuous number? No idea what you mean by this. Is there an explicit way to declare a number vs bigint? Yes, like I said, that's what the n suffix is for. I want to see what happens if I declare a bigint as a number and vice versa. This doesn't make any sense in JavaScript. Variables don't have types; only values have types. A variable could store a Number value, or a BigInt value, but it has to be one or the other. It can't be both at the same time. But number is reserved, so I can't "let number = 123456789999n". The name of your variable is just a name. It doesn't have any connection to the data type that you store in the variable. Lastly, does anyone use bigint in programming, I mean, does it serve a practical purpose? Well, any time you want to do exact integer arithmetic without rounding. Just as one example, cryptographic algorithms often do arithmetic on integers with hundreds of digits. The exact value of those integers is crucial, and any rounding or inaccuracy would completely ruin the output. More on reddit.com

There should not be artificial constraints on Number / BigInt comparison. More on github.com

JavaScript numbers are double-precision floating-point values, also known as a double in other languages like C. This covers the "float" side of things. Now, a double-precision floating-point value can perfectly represent integers up to 52 bits, which is a lot bigger than the 32 bits an int can typically store in other languages. JavaScript bitwise operators such as & or | or ^ also convert their values to 32-bit integers before doing their work. So, just use regular JavaScript numbers to perform your integer arithmetic, and then throw in a few | 0 operations if you want the rounding / clamping behavior found in other language's 32-bit int types. In other words, everything you want is already present. More on reddit.com

E.g. as part of a function: const add = (a: T, b: T) => a + b; Edit: The above does not work and but since TypeScript is explicitly told that both parameters a and b are always of type T, that T is either number or bigint and both can use the + operator, I think this should work… Edit II, I was wrong: Because there’s no way to link the types of a and b without using a generic, whose constraints need to be a union to allow for number and bigint, what I was trying to express using my example above is actually not as strict as I’d like it to be… I played around a bit further but got nowhere, stick to overloading, like u/jydu suggests. More on reddit.com