The dynamic import causes the `describe` blocks to happen later, which
means the `after` and `afterEach` have already run (and cleaned up) at
that point.

It also turns out the old version of rimraf wasn't awaitable, so it has
been upgraded in this change.

This reverts to what the test is in `master` but fixes an async race
condition.

Essentially:

```ts
await waitForWatcher(watcher1);
// at this point, the ready event has fired for watcher1 _and_ watcher2
await waitForWatcher(watcher2);
// this never gets reached because it fired before we added the event
// handler
```

Awaiting both in a `Promise.all` fixes this since the event handlers
will be attached immediately.

Since we're locally importing this, node will not resolve the import
path as if it is an NPM package (i.e. it will not infer the `main` path,
or package exports).

Instead, we need to import the exact path it seems (`lib/index.js`).

This reverts the test for ignoring events after close, since it seems
the original passes fine and makes this consistent with the other tests
again in structure.

This reworks the anymatch function to be a little less generic since we
now know exactly what we want to call it with. This means we have much
clearer/stronger types.

On top of that, support for ignored paths has been implemented again (it
was removed with a `TODO` until now, in v4).

Keep in mind the way we store ignored paths may change in future so we
can more efficiently access and remove them without the need for full
iterations through the set.

We were running ESLint against `*.js` (the default) which no longer
exists, so `--ext` has been added to make it check `*.ts` files.

Alongside that, TSESLint has been added and the recommended config
enabled.

For now, these two rules are disabled:

- `no-explicit-any` - until we strongly type everything
- `no-unused-vars` - probably permanently, using typescript's own
  `noUnusedLocals` instead

This basically does two things:

1. Adds `WatchHelper` to some of the methods for a stronger type
2. Reworks how we add/remove ignore paths ("matchers")

In the latter, thanks to a previous change where we can have "matcher
objects", we need to iterate through existing ignore paths to make sure
we don't duplicate them.

Similarly, when removing a "path", we need to find any matcher objects
which use the same path and remove those too.

Basically introducing `addIgnorePath` and `removeIgnorePath` instead of
mutating the set directly.

Trying to fix some tests, the `interval` used to be `undefined` by
default. That mean we would later compare `n > undefined` (which would
be false). Changing it to `0` means `n > 0` would now be true.

This doesn't actually fix the tests most likely but may as well revert
to the same behavior for now.

When a file changes in linux, it gets a new inode which means our
`fs.watch` will still be watching the old inode, not the new one.

To get around this, we already remove the watcher and add a new one for
the new inode.

However, we don't apply this logic to MacOS, which also has the same
behaviour (creates a new inode when a file changes in some cases).

This change just makes it so we run the same logic for linux _and_ mac.

This just enables running the build script in CI such that tests have
access to the build output when they run (as we're now using
typescript).

This re-enables the conditional import of `fsevents` since it will be
unavailable on some platforms.

A bit of chicken-and-egg situation means we can't pull the official
fsevents types.

Basically, fsevents will only install on certain platforms (macOS?).

Of course, if we're not on a supported platform, that also means we
won't have access to the shipped typescript types.

To solve this, we have to keep a copy of the types ourselves.

Upgrades to typescript 5.x since the latest node types require that for
some newer syntax.

As per the nodeJS docs, the built-in `fs.watch` will now use `fsevents`
under the hood for watching directories. This means we should no longer
need the `fsevents` dependency and can instead just delegate to node.

Some stability changes have been made to the tests, too. Generally
waiting for explicit conditions rather than arbitrary delays.

On windows, a symlink can be created as a `file`, a `dir`, or a
`junction`. Meanwhile, on unix-like systems, this type doesn't seem to
matter much (or is ignored).

By default, the type will be `file` on windows.

Due to this, all directories we symlink in tests are actually created as
"files" which leads to all sorts of permissions errors.

This change basically makes it explicit that the symlinked directories
are in fact directories (`dir`), thus making tests pass.

This test is incredibly flaky across different platforms, node versions,
etc when we try write all the files at once. Instead, we now write a
file at a time and wait for the spy to have been called before moving
on.

Not quite as accurate as real world but seems to be the only way to make
this stable.

This adds node 21.x to the matrix in our CI workflow (making it now run
on 18, 20 and 21).

Attempts to fix some timing issues in tests by waiting for watchers to
be ready before continuing with the test cases.

Bumps the version to `>= 18` and replaces `21` with `22` in the CI
workflows.

[DRAFT] v4 fixes

Switches to using the built-in node test runner and drops mocha.

Temporarily also introduces a `TEST_TIMEOUT` as `--test-timeout` is only
available in 20.x and above, but we run CI in 18.x.

Adds a small delay in some tests after the initial path has been added
(to avoid the FS de-duping/cancelling events).

test: switch to node test runner

Upgrades eslint and switches to using the new flat config structure.

chore: upgrade to flat eslint configs

Moves to using `node:fs/promises` rather than using `promisify`
manually.

feat: move to node:fs/promises