| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647 | 
							- # minipass-flush
 
- A Minipass stream that calls a flush function before emitting 'end'
 
- ## USAGE
 
- ```js
 
- const Flush = require('minipass-flush')
 
- cons f = new Flush({
 
-   flush (cb) {
 
-     // call the cb when done, or return a promise
 
-     // the 'end' event will wait for it, along with
 
-     // close, finish, and prefinish.
 
-     // call the cb with an error, or return a rejecting
 
-     // promise to emit 'error' instead of doing the 'end'
 
-     return rerouteAllEncryptions().then(() => clearAllChannels())
 
-   },
 
-   // all other minipass options accepted as well
 
- })
 
- someDataSource.pipe(f).on('end', () => {
 
-   // proper flushing has been accomplished
 
- })
 
- // Or as a subclass implementing a 'flush' method:
 
- class MyFlush extends Flush {
 
-   flush (cb) {
 
-     // old fashioned callback style!
 
-     rerouteAllEncryptions(er => {
 
-       if (er)
 
-         return cb(er)
 
-       clearAllChannels(er => {
 
-         if (er)
 
-           cb(er)
 
-         cb()
 
-       })
 
-     })
 
-   }
 
- }
 
- ```
 
- That's about it.
 
- If your `flush` method doesn't have to do anything asynchronous, then it's
 
- better to call the callback right away in this tick, rather than returning
 
- `Promise.resolve()`, so that the `end` event can happen as soon as
 
- possible.
 
 
  |