optimization: when NProgress.inc() and/or NProgress.set() are invoked with high frequency and the same 'progress value', then it's no use to re-render/update the DOM: that will slow us down even more in an already suboptimal usage pattern. The caller would be best served by inspecting his calling process here, but meanwhile we can very easily lighten the burden -- without the optimization NProgress.set() will spend a *lot* of time in the browser's DOM engine via querySelectorAll() and HTMLElement.offsetWidth (--> trigger DOM reflow/layout action).

Numbers from actual profile run in user app:
97 seconds spent in NProgress.inc/set @ get offsetWidth --> except for a few milliseconds, all time in .set()/.inc() is spent in the DOM, i.e. the browser's layout/render engine
9.1 seconds spent in NProgress.inc/set @ querySelectorAll --> these are the high number of II.findElementByAny() calls kicking in as .set() is invoked with very high frequency.
which consumes a total of ~100 seconds, while the app itself consumed a similar amount of time elsewhere.

After this optimization, NProgress.set() drops to 1.3 seconds total cost: all spent in 'get offsetWidth' while querySelectorAll doesn't feature in the profile anymore (mostly due to the user app having a *huge* DOM tree hence reflow/layout is always a high cost).
Feature: added addEventListener/removeEventListener API on top of our events `onDone` and `onDoneBefore`; when you do *not* set them in the classic way, e.g. through code like

```
NProgress.settings.onDone = function () { bla }
```

but instead *register* your event handlers like this:

```
NProgress.settings.onDone.addEventListener(function () { bla })
```

then you get all the benefits of the new API:

- `{event}.addEventListener`: Add a callback/listener to the event; a la the DOM addEventListener, duplicate registrations are skipped.

- `{event}.removeEventListener`: Remove the targeted listener (if it is still present in the event listener set); when no parameter or a non-function-type parameter is passed, it means *all* listeners will be removed at once.

A generator function, which produces a function/object which offers these methods, is accessible through `NProgress.Internals.generateFunctionRegister`. Example (pseudo)code:

```
// create new instance of event registrar
var evtIF = NProgress.Internals.generateFunctionRegister();
...
// register callback(s):
evtIF.addEventListener(a);
evtIF.addEventListener(b);
...
// 'fire' the 'event': this will invoke registered callbacks `a` and `b`, where each will receive the `args` passed into evtIF:
evtIF(args);
```
Feature: pass the arguments to each of the invoked, registered, event listeners. `this` in an event listener references the event function/object (NProgress.Internals.generateFunctionRegister instance)
typo fix