I have some experience using both of these libraries, so I will do my best to explain each of them:

Intl.NumberFormat and decimal.js are both libraries in JavaScript that can be used to format and manipulate numbers. However, while they are similar in some ways, they are very different in others.

Intl.NumberFormat is a built-in JavaScript library that provides localization support for number formatting, including decimal and grouping separators, decimal precision, and currency formatting. It is widely used to format numbers based on a user's language and region.

Decimal.js is a third-party library that provides arbitrary-precision decimal arithmetic for JavaScript. It allows for precise calculations with decimal numbers, which are often required in financial and scientific applications where rounding errors can have significant consequences.

Although Intl.NumberFormat can handle basic currency formatting, it may not be suitable for all use cases. For example, it may not handle more complex currency formatting requirements, such as rounding rules or multiple currencies in the same document. In such cases, decimal.js can provide more precise and flexible currency handling capabilities.

I hope this answered your question!

You can use Math.floor to remove floating after decimal:

var val = 11067.64120858936;
var result = Math.floor(val);
console.log(result); // 11067 discard value after decimal

You can use Math.ceil will give you round figure by next digit i.e. 1 increment in case of float number like given example it doesn't matter whether digit after decimal is greater than 5 or not:

var val = 11067.64120858936;
var result = Math.ceil(val);
console.log(result); // result 11068

You can use Math.round will give you fixed digit either by 1+ or 1- depends on value after decimal:

var val = 11067.64120858936;
var result = Math.round(val); 
console.log(result); // result 11068 as there is 6 after decimal

To get specific digit after decimal you can try toFixed() method:

var val = 11067.64120858936;
var result = val.toFixed(2); // for two place digit after decimal
console.log(result); // result 11067.64

You can try this in your browser console.

Generally no. There are some possible performance implications when a number doesn't fit in a 31b signed int.

A tour of V8: object representation explains

According to the spec, all numbers in JavaScript are 64-bit floating point doubles. We frequently work with integers though, so V8 represents numbers with 31-bit signed integers whenever possible (the low bit is always 0; this helps the garbage collector distinguish numbers from pointers). So objects with the fast small integers elements kind only contain this type of number. If we want to store a fractional number or a larger integer or a special value like -0, then we need to upgrade the array to fast doubles. This involves a potentially expensive copy-and-convert operation, but it doesn't happen often in practice. fast doubles objects are still pretty fast because all of the numbers are stored in an unboxed representation. If we want to store any other kind of value, e.g., a string or an object, we must upgrade to a general array of fast elements.