npm - muhammara - Versions diffs - 3.6.0 → 3.7.0 - Mend

muhammara 3.6.0 → 3.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/CHANGELOG.md +17 -1
package/README.md +1 -1
package/lib/recipe/htmlToTextObjects.js +6 -4
package/node_modules/minipass/LICENSE +1 -1
package/node_modules/minipass/README.md +127 -123
package/node_modules/minipass/index.d.ts +2 -2
package/node_modules/minipass/index.js +233 -224
package/node_modules/minipass/package.json +9 -9
package/node_modules/node-fetch/browser.js +1 -1
package/node_modules/node-fetch/lib/index.es.js +3 -1
package/node_modules/node-fetch/lib/index.js +3 -1
package/node_modules/node-fetch/lib/index.mjs +3 -1
package/node_modules/node-fetch/package.json +5 -5
package/node_modules/yallist/package.json +0 -1
package/package.json +2 -2

package/CHANGELOG.md CHANGED Viewed

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ## [Unreleased]
+## [3.7.0] - 2023-02-09
+### Added
+- Electron 21.4, 22.1 and 22.2
+### Fixed
+- Update xmldom to new 0.8.6 and fix security issues
+- Fix arm64 on mac builds
+### Removed
+- Pre-builts for macos on arm for node < 15 (eg 14, 12, 10 etc)
 ## [3.6.0] - 2023-01-24
 ### Added
@@ -343,7 +358,8 @@ with the following changes.
 - Initial release
-[unreleased]: https://github.com/julianhille/MuhammaraJS/compare/3.6.0...HEAD
+[unreleased]: https://github.com/julianhille/MuhammaraJS/compare/3.7.0...HEAD
+[3.7.0]: https://github.com/julianhille/MuhammaraJS/compare/3.6.0...3.7.0
 [3.6.0]: https://github.com/julianhille/MuhammaraJS/compare/3.5.0...3.6.0
 [3.5.0]: https://github.com/julianhille/MuhammaraJS/compare/3.4.0...3.5.0
 [3.4.0]: https://github.com/julianhille/MuhammaraJS/compare/3.3.0...3.4.0

package/README.md CHANGED Viewed

@@ -68,7 +68,7 @@ Replace:
 With:
 ```
-const HummusRecipe = require('muhammara').Receipe;
+const HummusRecipe = require('muhammara').Recipe;
 ```
 # Documentation

package/lib/recipe/htmlToTextObjects.js CHANGED Viewed

@@ -1,10 +1,12 @@
-const DOMParser = require("xmldom").DOMParser;
+const DOMParser = require("@xmldom/xmldom").DOMParser;
 exports.htmlToTextObjects = function (htmlCodes) {
   htmlCodes = htmlCodes.replace(/<br\/?>/g, "<p>[@@DONOT_RENDER_THIS@@]</p>");
-  const nodes = new DOMParser().parseFromString(htmlCodes);
-  const textObjects = parseNode(nodes).childs;
+  const nodes = new DOMParser().parseFromString(
+    `<html>${htmlCodes}</html>`,
+    "text/html"
+  );
+  const textObjects = parseNode(nodes).childs[0].childs;
   return textObjects;
 };

package/node_modules/minipass/LICENSE CHANGED Viewed

@@ -1,6 +1,6 @@
 The ISC License
-Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+Copyright (c) 2017-2023 npm, Inc., Isaac Z. Schlueter, and Contributors
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/node_modules/minipass/README.md CHANGED Viewed

@@ -4,7 +4,7 @@ A _very_ minimal implementation of a [PassThrough
 stream](https://nodejs.org/api/stream.html#stream_class_stream_passthrough)
 [It's very
-fast](https://docs.google.com/spreadsheets/d/1oObKSrVwLX_7Ut4Z6g3fZW-AX1j1-k6w-cDsrkaSbHM/edit#gid=0)
+fast](https://docs.google.com/spreadsheets/d/1K_HR5oh3r80b8WVMWCPPjfuWXUgfkmhlX7FGI6JJ8tY/edit?usp=sharing)
 for objects, strings, and buffers.
 Supports `pipe()`ing (including multi-`pipe()` and backpressure transmission),
@@ -14,20 +14,20 @@ a good idea.
 There is a `read()` method, but it's much more efficient to consume data
 from this stream via `'data'` events or by calling `pipe()` into some other
-stream.  Calling `read()` requires the buffer to be flattened in some
+stream. Calling `read()` requires the buffer to be flattened in some
 cases, which requires copying memory.
 If you set `objectMode: true` in the options, then whatever is written will
-be emitted.  Otherwise, it'll do a minimal amount of Buffer copying to
+be emitted. Otherwise, it'll do a minimal amount of Buffer copying to
 ensure proper Streams semantics when `read(n)` is called.
 `objectMode` can also be set by doing `stream.objectMode = true`, or by
-writing any non-string/non-buffer data.  `objectMode` cannot be set to
+writing any non-string/non-buffer data. `objectMode` cannot be set to
 false once it is set.
-This is not a `through` or `through2` stream.  It doesn't transform the
-data, it just passes it right through.  If you want to transform the data,
-extend the class, and override the `write()` method.  Once you're done
+This is not a `through` or `through2` stream. It doesn't transform the
+data, it just passes it right through. If you want to transform the data,
+extend the class, and override the `write()` method. Once you're done
 transforming the data however you want, call `super.write()` with the
 transform output.
@@ -66,9 +66,9 @@ constructor options.
 ### Timing
-Minipass streams are designed to support synchronous use-cases.  Thus, data
-is emitted as soon as it is available, always.  It is buffered until read,
-but no longer.  Another way to look at it is that Minipass streams are
+Minipass streams are designed to support synchronous use-cases. Thus, data
+is emitted as soon as it is available, always. It is buffered until read,
+but no longer. Another way to look at it is that Minipass streams are
 exactly as synchronous as the logic that writes into them.
 This can be surprising if your code relies on `PassThrough.write()` always
@@ -77,7 +77,7 @@ to call `resume()` and not have the entire buffer disappear immediately.
 However, without this synchronicity guarantee, there would be no way for
 Minipass to achieve the speeds it does, or support the synchronous use
-cases that it does.  Simply put, waiting takes time.
+cases that it does. Simply put, waiting takes time.
 This non-deferring approach makes Minipass streams much easier to reason
 about, especially in the context of Promises and other flow-control
@@ -87,7 +87,7 @@ Example:
 ```js
 const Minipass = require('minipass')
-const stream = new Minipass({ async: true })
+const stream = new Minipass()
 stream.on('data', () => console.log('data event'))
 console.log('before write')
 stream.write('hello')
@@ -119,7 +119,7 @@ console.log('after write')
 ```
 Switching _out_ of async mode is unsafe, as it could cause data
-corruption, and so is not enabled.  Example:
+corruption, and so is not enabled. Example:
 ```js
 const Minipass = require('minipass')
@@ -166,7 +166,7 @@ on all writes until the limit is hit, even if the data has nowhere to go.
 Then, they will not attempt to draw more data in until the buffer size dips
 below a minimum value.
-Minipass streams are much simpler.  The `write()` method will return `true`
+Minipass streams are much simpler. The `write()` method will return `true`
 if the data has somewhere to go (which is to say, given the timing
 guarantees, that the data is already there by the time `write()` returns).
@@ -182,12 +182,12 @@ copying data, and less bookkeeping about buffer capacity levels.
 Since data written to a Minipass stream is immediately written all the way
 through the pipeline, and `write()` always returns true/false based on
 whether the data was fully flushed, backpressure is communicated
-immediately to the upstream caller.  This minimizes buffering.
+immediately to the upstream caller. This minimizes buffering.
 Consider this case:
 ```js
-const {PassThrough} = require('stream')
+const { PassThrough } = require('stream')
 const p1 = new PassThrough({ highWaterMark: 1024 })
 const p2 = new PassThrough({ highWaterMark: 1024 })
 const p3 = new PassThrough({ highWaterMark: 1024 })
@@ -216,7 +216,7 @@ perfectly safe to write all the way through!
 Furthermore, setting a `highWaterMark` of `1024` might lead someone reading
 the code to think an advisory maximum of 1KiB is being set for the
-pipeline.  However, the actual advisory buffering level is the _sum_ of
+pipeline. However, the actual advisory buffering level is the _sum_ of
 `highWaterMark` values, since each one has its own bucket.
 Consider the Minipass case:
@@ -243,7 +243,7 @@ m1.write(Buffer.alloc(2048)) // returns true
 ```
 It is extremely unlikely that you _don't_ want to buffer any data written,
-or _ever_ buffer data that can be flushed all the way through.  Neither
+or _ever_ buffer data that can be flushed all the way through. Neither
 node-core streams nor Minipass ever fail to buffer written data, but
 node-core streams do a lot of unnecessary buffering and pausing.
@@ -266,12 +266,12 @@ However, this is _usually_ not a problem because:
 ### Emit `end` When Asked
 One hazard of immediately emitting `'end'` is that you may not yet have had
-a chance to add a listener.  In order to avoid this hazard, Minipass
+a chance to add a listener. In order to avoid this hazard, Minipass
 streams safely re-emit the `'end'` event if a new listener is added after
 `'end'` has been emitted.
 Ie, if you do `stream.on('end', someFunction)`, and the stream has already
-emitted `end`, then it will call the handler right away.  (You can think of
+emitted `end`, then it will call the handler right away. (You can think of
 this somewhat like attaching a new `.then(fn)` to a previously-resolved
 Promise.)
@@ -282,7 +282,7 @@ is emitted.
 ### Emit `error` When Asked
 The most recent error object passed to the `'error'` event is
-stored on the stream.  If a new `'error'` event handler is added,
+stored on the stream. If a new `'error'` event handler is added,
 and an error was previously emitted, then the event handler will
 be called immediately (or on `process.nextTick` in the case of
 async streams).
@@ -328,7 +328,7 @@ tee.pipe(dest2)
 src.pipe(tee) // tee gets 'foo', pipes to both locations
 ```
-The same caveat applies to `on('data')` event listeners.  The first one
+The same caveat applies to `on('data')` event listeners. The first one
 added will _immediately_ receive all of the data, leaving nothing for the
 second:
@@ -354,14 +354,14 @@ src.pipe(tee)
 All of the hazards in this section are avoided by setting `{
 async: true }` in the Minipass constructor, or by setting
-`stream.async = true` afterwards.  Note that this does add some
+`stream.async = true` afterwards. Note that this does add some
 overhead, so should only be done in cases where you are willing
 to lose a bit of performance in order to avoid having to refactor
 program logic.
 ## USAGE
-It's a stream!  Use it like a stream and it'll most likely do what you
+It's a stream! Use it like a stream and it'll most likely do what you
 want.
 ```js
@@ -374,16 +374,16 @@ mp.end('bar')
 ### OPTIONS
-* `encoding` How would you like the data coming _out_ of the stream to be
-  encoded?  Accepts any values that can be passed to `Buffer.toString()`.
-* `objectMode` Emit data exactly as it comes in.  This will be flipped on
+- `encoding` How would you like the data coming _out_ of the stream to be
+  encoded? Accepts any values that can be passed to `Buffer.toString()`.
+- `objectMode` Emit data exactly as it comes in. This will be flipped on
   by default if you write() something other than a string or Buffer at any
-  point.  Setting `objectMode: true` will prevent setting any encoding
+  point. Setting `objectMode: true` will prevent setting any encoding
   value.
-* `async` Defaults to `false`.  Set to `true` to defer data
-  emission until next tick.  This reduces performance slightly,
+- `async` Defaults to `false`. Set to `true` to defer data
+  emission until next tick. This reduces performance slightly,
   but makes Minipass streams use timing behavior closer to Node
-  core streams.  See [Timing](#timing) for more details.
+  core streams. See [Timing](#timing) for more details.
 ### API
@@ -392,113 +392,113 @@ streams.
 ### Methods
-* `write(chunk, [encoding], [callback])` - Put data in.  (Note that, in the
-  base Minipass class, the same data will come out.)  Returns `false` if
+- `write(chunk, [encoding], [callback])` - Put data in. (Note that, in the
+  base Minipass class, the same data will come out.) Returns `false` if
   the stream will buffer the next write, or true if it's still in "flowing"
   mode.
-* `end([chunk, [encoding]], [callback])` - Signal that you have no more
-  data to write.  This will queue an `end` event to be fired when all the
+- `end([chunk, [encoding]], [callback])` - Signal that you have no more
+  data to write. This will queue an `end` event to be fired when all the
   data has been consumed.
-* `setEncoding(encoding)` - Set the encoding for data coming of the stream.
+- `setEncoding(encoding)` - Set the encoding for data coming of the stream.
   This can only be done once.
-* `pause()` - No more data for a while, please.  This also prevents `end`
+- `pause()` - No more data for a while, please. This also prevents `end`
   from being emitted for empty streams until the stream is resumed.
-* `resume()` - Resume the stream.  If there's data in the buffer, it is all
-  discarded.  Any buffered events are immediately emitted.
-* `pipe(dest)` - Send all output to the stream provided.  When
+- `resume()` - Resume the stream. If there's data in the buffer, it is all
+  discarded. Any buffered events are immediately emitted.
+- `pipe(dest)` - Send all output to the stream provided. When
   data is emitted, it is immediately written to any and all pipe
-  destinations.  (Or written on next tick in `async` mode.)
-* `unpipe(dest)` - Stop piping to the destination stream.  This
+  destinations. (Or written on next tick in `async` mode.)
+- `unpipe(dest)` - Stop piping to the destination stream. This
   is immediate, meaning that any asynchronously queued data will
   _not_ make it to the destination when running in `async` mode.
-    * `options.end` - Boolean, end the destination stream when
-      the source stream ends.  Default `true`.
-    * `options.proxyErrors` - Boolean, proxy `error` events from
-      the source stream to the destination stream.  Note that
-      errors are _not_ proxied after the pipeline terminates,
-      either due to the source emitting `'end'` or manually
-      unpiping with `src.unpipe(dest)`.  Default `false`.
-* `on(ev, fn)`, `emit(ev, fn)` - Minipass streams are EventEmitters.  Some
-  events are given special treatment, however.  (See below under "events".)
-* `promise()` - Returns a Promise that resolves when the stream emits
+  - `options.end` - Boolean, end the destination stream when
+    the source stream ends. Default `true`.
+  - `options.proxyErrors` - Boolean, proxy `error` events from
+    the source stream to the destination stream. Note that
+    errors are _not_ proxied after the pipeline terminates,
+    either due to the source emitting `'end'` or manually
+    unpiping with `src.unpipe(dest)`. Default `false`.
+- `on(ev, fn)`, `emit(ev, fn)` - Minipass streams are EventEmitters. Some
+  events are given special treatment, however. (See below under "events".)
+- `promise()` - Returns a Promise that resolves when the stream emits
   `end`, or rejects if the stream emits `error`.
-* `collect()` - Return a Promise that resolves on `end` with an array
+- `collect()` - Return a Promise that resolves on `end` with an array
   containing each chunk of data that was emitted, or rejects if the stream
-  emits `error`.  Note that this consumes the stream data.
-* `concat()` - Same as `collect()`, but concatenates the data into a single
-  Buffer object.  Will reject the returned promise if the stream is in
+  emits `error`. Note that this consumes the stream data.
+- `concat()` - Same as `collect()`, but concatenates the data into a single
+  Buffer object. Will reject the returned promise if the stream is in
   objectMode, or if it goes into objectMode by the end of the data.
-* `read(n)` - Consume `n` bytes of data out of the buffer.  If `n` is not
-  provided, then consume all of it.  If `n` bytes are not available, then
-  it returns null.  **Note** consuming streams in this way is less
+- `read(n)` - Consume `n` bytes of data out of the buffer. If `n` is not
+  provided, then consume all of it. If `n` bytes are not available, then
+  it returns null. **Note** consuming streams in this way is less
   efficient, and can lead to unnecessary Buffer copying.
-* `destroy([er])` - Destroy the stream.  If an error is provided, then an
-  `'error'` event is emitted.  If the stream has a `close()` method, and
+- `destroy([er])` - Destroy the stream. If an error is provided, then an
+  `'error'` event is emitted. If the stream has a `close()` method, and
   has not emitted a `'close'` event yet, then `stream.close()` will be
-  called.  Any Promises returned by `.promise()`, `.collect()` or
-  `.concat()` will be rejected.  After being destroyed, writing to the
-  stream will emit an error.  No more data will be emitted if the stream is
+  called. Any Promises returned by `.promise()`, `.collect()` or
+  `.concat()` will be rejected. After being destroyed, writing to the
+  stream will emit an error. No more data will be emitted if the stream is
   destroyed, even if it was previously buffered.
 ### Properties
-* `bufferLength` Read-only.  Total number of bytes buffered, or in the case
+- `bufferLength` Read-only. Total number of bytes buffered, or in the case
   of objectMode, the total number of objects.
-* `encoding` The encoding that has been set.  (Setting this is equivalent
+- `encoding` The encoding that has been set. (Setting this is equivalent
   to calling `setEncoding(enc)` and has the same prohibition against
   setting multiple times.)
-* `flowing` Read-only.  Boolean indicating whether a chunk written to the
+- `flowing` Read-only. Boolean indicating whether a chunk written to the
   stream will be immediately emitted.
-* `emittedEnd` Read-only.  Boolean indicating whether the end-ish events
-  (ie, `end`, `prefinish`, `finish`) have been emitted.  Note that
+- `emittedEnd` Read-only. Boolean indicating whether the end-ish events
+  (ie, `end`, `prefinish`, `finish`) have been emitted. Note that
   listening on any end-ish event will immediateyl re-emit it if it has
   already been emitted.
-* `writable` Whether the stream is writable.  Default `true`.  Set to
+- `writable` Whether the stream is writable. Default `true`. Set to
   `false` when `end()`
-* `readable` Whether the stream is readable.  Default `true`.
-* `buffer` A [yallist](http://npm.im/yallist) linked list of chunks written
-  to the stream that have not yet been emitted.  (It's probably a bad idea
+- `readable` Whether the stream is readable. Default `true`.
+- `buffer` A [yallist](http://npm.im/yallist) linked list of chunks written
+  to the stream that have not yet been emitted. (It's probably a bad idea
   to mess with this.)
-* `pipes` A [yallist](http://npm.im/yallist) linked list of streams that
-  this stream is piping into.  (It's probably a bad idea to mess with
+- `pipes` A [yallist](http://npm.im/yallist) linked list of streams that
+  this stream is piping into. (It's probably a bad idea to mess with
   this.)
-* `destroyed` A getter that indicates whether the stream was destroyed.
-* `paused` True if the stream has been explicitly paused, otherwise false.
-* `objectMode` Indicates whether the stream is in `objectMode`.  Once set
+- `destroyed` A getter that indicates whether the stream was destroyed.
+- `paused` True if the stream has been explicitly paused, otherwise false.
+- `objectMode` Indicates whether the stream is in `objectMode`. Once set
   to `true`, it cannot be set to `false`.
 ### Events
-* `data` Emitted when there's data to read.  Argument is the data to read.
-  This is never emitted while not flowing.  If a listener is attached, that
+- `data` Emitted when there's data to read. Argument is the data to read.
+  This is never emitted while not flowing. If a listener is attached, that
   will resume the stream.
-* `end` Emitted when there's no more data to read.  This will be emitted
-  immediately for empty streams when `end()` is called.  If a listener is
+- `end` Emitted when there's no more data to read. This will be emitted
+  immediately for empty streams when `end()` is called. If a listener is
   attached, and `end` was already emitted, then it will be emitted again.
   All listeners are removed when `end` is emitted.
-* `prefinish` An end-ish event that follows the same logic as `end` and is
-  emitted in the same conditions where `end` is emitted.  Emitted after
+- `prefinish` An end-ish event that follows the same logic as `end` and is
+  emitted in the same conditions where `end` is emitted. Emitted after
   `'end'`.
-* `finish` An end-ish event that follows the same logic as `end` and is
-  emitted in the same conditions where `end` is emitted.  Emitted after
+- `finish` An end-ish event that follows the same logic as `end` and is
+  emitted in the same conditions where `end` is emitted. Emitted after
   `'prefinish'`.
-* `close` An indication that an underlying resource has been released.
+- `close` An indication that an underlying resource has been released.
   Minipass does not emit this event, but will defer it until after `end`
   has been emitted, since it throws off some stream libraries otherwise.
-* `drain` Emitted when the internal buffer empties, and it is again
+- `drain` Emitted when the internal buffer empties, and it is again
   suitable to `write()` into the stream.
-* `readable` Emitted when data is buffered and ready to be read by a
+- `readable` Emitted when data is buffered and ready to be read by a
   consumer.
-* `resume` Emitted when stream changes state from buffering to flowing
-  mode.  (Ie, when `resume` is called, `pipe` is called, or a `data` event
+- `resume` Emitted when stream changes state from buffering to flowing
+  mode. (Ie, when `resume` is called, `pipe` is called, or a `data` event
   listener is added.)
 ### Static Methods
-* `Minipass.isStream(stream)` Returns `true` if the argument is a stream,
-  and false otherwise.  To be considered a stream, the object must be
+- `Minipass.isStream(stream)` Returns `true` if the argument is a stream,
+  and false otherwise. To be considered a stream, the object must be
   either an instance of Minipass, or an EventEmitter that has either a
-  `pipe()` method, or both `write()` and `end()` methods.  (Pretty much any
+  `pipe()` method, or both `write()` and `end()` methods. (Pretty much any
   stream in node-land will return `true` for this.)
 ## EXAMPLES
@@ -508,11 +508,14 @@ Here are some examples of things you can do with Minipass streams.
 ### simple "are you done yet" promise
 ```js
-mp.promise().then(() => {
-  // stream is finished
-}, er => {
-  // stream emitted an error
-})
+mp.promise().then(
+  () => {
+    // stream is finished
+  },
+  er => {
+    // stream emitted an error
+  }
+)
 ```
 ### collecting
@@ -548,7 +551,7 @@ You can iterate over streams synchronously or asynchronously in platforms
 that support it.
 Synchronous iteration will end when the currently available data is
-consumed, even if the `end` event has not been reached.  In string and
+consumed, even if the `end` event has not been reached. In string and
 buffer mode, the data is concatenated, so unless multiple writes are
 occurring in the same tick as the `read()`, sync iteration loops will
 generally only have a single iteration.
@@ -587,8 +590,7 @@ const mp = new Minipass({ encoding: 'utf8' })
 // some source of some data
 let i = 5
 const inter = setInterval(() => {
-  if (i-- > 0)
-    mp.write(Buffer.from('foo\n', 'utf8'))
+  if (i-- > 0) mp.write(Buffer.from('foo\n', 'utf8'))
   else {
     mp.end()
     clearInterval(inter)
@@ -596,7 +598,7 @@ const inter = setInterval(() => {
 }, 100)
 // consume the data with asynchronous iteration
-async function consume () {
+async function consume() {
   for await (let chunk of mp) {
     console.log(chunk)
   }
@@ -611,11 +613,11 @@ consume().then(res => console.log(res))
 ```js
 class Logger extends Minipass {
-  write (chunk, encoding, callback) {
+  write(chunk, encoding, callback) {
     console.log('WRITE', chunk, encoding)
     return super.write(chunk, encoding, callback)
   }
-  end (chunk, encoding, callback) {
+  end(chunk, encoding, callback) {
     console.log('END', chunk, encoding)
     return super.end(chunk, encoding, callback)
   }
@@ -629,21 +631,23 @@ someSource.pipe(new Logger()).pipe(someDest)
 ```js
 // js classes are fun
 someSource
-  .pipe(new (class extends Minipass {
-    emit (ev, ...data) {
-      // let's also log events, because debugging some weird thing
-      console.log('EMIT', ev)
-      return super.emit(ev, ...data)
-    }
-    write (chunk, encoding, callback) {
-      console.log('WRITE', chunk, encoding)
-      return super.write(chunk, encoding, callback)
-    }
-    end (chunk, encoding, callback) {
-      console.log('END', chunk, encoding)
-      return super.end(chunk, encoding, callback)
-    }
-  }))
+  .pipe(
+    new (class extends Minipass {
+      emit(ev, ...data) {
+        // let's also log events, because debugging some weird thing
+        console.log('EMIT', ev)
+        return super.emit(ev, ...data)
+      }
+      write(chunk, encoding, callback) {
+        console.log('WRITE', chunk, encoding)
+        return super.write(chunk, encoding, callback)
+      }
+      end(chunk, encoding, callback) {
+        console.log('END', chunk, encoding)
+        return super.end(chunk, encoding, callback)
+      }
+    })()
+  )
   .pipe(someDest)
 ```
@@ -651,7 +655,7 @@ someSource
 ```js
 class SlowEnd extends Minipass {
-  emit (ev, ...args) {
+  emit(ev, ...args) {
     if (ev === 'end') {
       console.log('going to end, hold on a sec')
       setTimeout(() => {
@@ -669,7 +673,7 @@ class SlowEnd extends Minipass {
 ```js
 class NDJSONEncode extends Minipass {
-  write (obj, cb) {
+  write(obj, cb) {
     try {
       // JSON.stringify can throw, emit an error on that
       return super.write(JSON.stringify(obj) + '\n', 'utf8', cb)
@@ -677,7 +681,7 @@ class NDJSONEncode extends Minipass {
       this.emit('error', er)
     }
   }
-  end (obj, cb) {
+  end(obj, cb) {
     if (typeof obj === 'function') {
       cb = obj
       obj = undefined

package/node_modules/minipass/index.d.ts CHANGED Viewed

@@ -140,8 +140,8 @@ declare class Minipass<
     listener: () => any
   ): this
-  [Symbol.iterator](): Iterator<RType>
-  [Symbol.asyncIterator](): AsyncIterator<RType>
+  [Symbol.iterator](): Generator<RType, void, void>
+  [Symbol.asyncIterator](): AsyncGenerator<RType, void, void>
 }
 export = Minipass