@meteora-ag/cp-amm-sdk 1.0.2 → 1.0.4

package/node_modules/safe-buffer/index.d.ts

@@ -0,0 +1,187 @@
+declare module "safe-buffer" {
+  export class Buffer {
+    length: number
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
+    toString(encoding?: string, start?: number, end?: number): string;
+    toJSON(): { type: 'Buffer', data: any[] };
+    equals(otherBuffer: Buffer): boolean;
+    compare(otherBuffer: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+    copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+    slice(start?: number, end?: number): Buffer;
+    writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readUInt8(offset: number, noAssert?: boolean): number;
+    readUInt16LE(offset: number, noAssert?: boolean): number;
+    readUInt16BE(offset: number, noAssert?: boolean): number;
+    readUInt32LE(offset: number, noAssert?: boolean): number;
+    readUInt32BE(offset: number, noAssert?: boolean): number;
+    readInt8(offset: number, noAssert?: boolean): number;
+    readInt16LE(offset: number, noAssert?: boolean): number;
+    readInt16BE(offset: number, noAssert?: boolean): number;
+    readInt32LE(offset: number, noAssert?: boolean): number;
+    readInt32BE(offset: number, noAssert?: boolean): number;
+    readFloatLE(offset: number, noAssert?: boolean): number;
+    readFloatBE(offset: number, noAssert?: boolean): number;
+    readDoubleLE(offset: number, noAssert?: boolean): number;
+    readDoubleBE(offset: number, noAssert?: boolean): number;
+    swap16(): Buffer;
+    swap32(): Buffer;
+    swap64(): Buffer;
+    writeUInt8(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt16LE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt16BE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt32LE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt32BE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt8(value: number, offset: number, noAssert?: boolean): number;
+    writeInt16LE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt16BE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt32LE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt32BE(value: number, offset: number, noAssert?: boolean): number;
+    writeFloatLE(value: number, offset: number, noAssert?: boolean): number;
+    writeFloatBE(value: number, offset: number, noAssert?: boolean): number;
+    writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;
+    writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;
+    fill(value: any, offset?: number, end?: number): this;
+    indexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
+    lastIndexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
+    includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;
+
+    /**
+     * Allocates a new buffer containing the given {str}.
+     *
+     * @param str String to store in buffer.
+     * @param encoding encoding to use, optional.  Default is 'utf8'
+     */
+     constructor (str: string, encoding?: string);
+    /**
+     * Allocates a new buffer of {size} octets.
+     *
+     * @param size count of octets to allocate.
+     */
+    constructor (size: number);
+    /**
+     * Allocates a new buffer containing the given {array} of octets.
+     *
+     * @param array The octets to store.
+     */
+    constructor (array: Uint8Array);
+    /**
+     * Produces a Buffer backed by the same allocated memory as
+     * the given {ArrayBuffer}.
+     *
+     *
+     * @param arrayBuffer The ArrayBuffer with which to share memory.
+     */
+    constructor (arrayBuffer: ArrayBuffer);
+    /**
+     * Allocates a new buffer containing the given {array} of octets.
+     *
+     * @param array The octets to store.
+     */
+    constructor (array: any[]);
+    /**
+     * Copies the passed {buffer} data onto a new {Buffer} instance.
+     *
+     * @param buffer The buffer to copy.
+     */
+    constructor (buffer: Buffer);
+    prototype: Buffer;
+    /**
+     * Allocates a new Buffer using an {array} of octets.
+     *
+     * @param array
+     */
+    static from(array: any[]): Buffer;
+    /**
+     * When passed a reference to the .buffer property of a TypedArray instance,
+     * the newly created Buffer will share the same allocated memory as the TypedArray.
+     * The optional {byteOffset} and {length} arguments specify a memory range
+     * within the {arrayBuffer} that will be shared by the Buffer.
+     *
+     * @param arrayBuffer The .buffer property of a TypedArray or a new ArrayBuffer()
+     * @param byteOffset
+     * @param length
+     */
+    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer;
+    /**
+     * Copies the passed {buffer} data onto a new Buffer instance.
+     *
+     * @param buffer
+     */
+    static from(buffer: Buffer): Buffer;
+    /**
+     * Creates a new Buffer containing the given JavaScript string {str}.
+     * If provided, the {encoding} parameter identifies the character encoding.
+     * If not provided, {encoding} defaults to 'utf8'.
+     *
+     * @param str
+     */
+    static from(str: string, encoding?: string): Buffer;
+    /**
+     * Returns true if {obj} is a Buffer
+     *
+     * @param obj object to test.
+     */
+    static isBuffer(obj: any): obj is Buffer;
+    /**
+     * Returns true if {encoding} is a valid encoding argument.
+     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
+     *
+     * @param encoding string to test.
+     */
+    static isEncoding(encoding: string): boolean;
+    /**
+     * Gives the actual byte length of a string. encoding defaults to 'utf8'.
+     * This is not the same as String.prototype.length since that returns the number of characters in a string.
+     *
+     * @param string string to test.
+     * @param encoding encoding used to evaluate (defaults to 'utf8')
+     */
+    static byteLength(string: string, encoding?: string): number;
+    /**
+     * Returns a buffer which is the result of concatenating all the buffers in the list together.
+     *
+     * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
+     * If the list has exactly one item, then the first item of the list is returned.
+     * If the list has more than one item, then a new Buffer is created.
+     *
+     * @param list An array of Buffer objects to concatenate
+     * @param totalLength Total length of the buffers when concatenated.
+     *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
+     */
+    static concat(list: Buffer[], totalLength?: number): Buffer;
+    /**
+     * The same as buf1.compare(buf2).
+     */
+    static compare(buf1: Buffer, buf2: Buffer): number;
+    /**
+     * Allocates a new buffer of {size} octets.
+     *
+     * @param size count of octets to allocate.
+     * @param fill if specified, buffer will be initialized by calling buf.fill(fill).
+     *    If parameter is omitted, buffer will be filled with zeros.
+     * @param encoding encoding used for call to buf.fill while initalizing
+     */
+    static alloc(size: number, fill?: string | Buffer | number, encoding?: string): Buffer;
+    /**
+     * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
+     * of the newly created Buffer are unknown and may contain sensitive data.
+     *
+     * @param size count of octets to allocate
+     */
+    static allocUnsafe(size: number): Buffer;
+    /**
+     * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
+     * of the newly created Buffer are unknown and may contain sensitive data.
+     *
+     * @param size count of octets to allocate
+     */
+    static allocUnsafeSlow(size: number): Buffer;
+  }
+}

package/node_modules/safe-buffer/index.js

@@ -0,0 +1,65 @@
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+/* eslint-disable node/no-deprecated-api */
+var buffer = require('buffer')
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+  for (var key in src) {
+    dst[key] = src[key]
+  }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+  module.exports = buffer
+} else {
+  // Copy properties from require('buffer')
+  copyProps(buffer, exports)
+  exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.prototype = Object.create(Buffer.prototype)
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+  if (typeof arg === 'number') {
+    throw new TypeError('Argument must not be a number')
+  }
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  var buf = Buffer(size)
+  if (fill !== undefined) {
+    if (typeof encoding === 'string') {
+      buf.fill(fill, encoding)
+    } else {
+      buf.fill(fill)
+    }
+  } else {
+    buf.fill(0)
+  }
+  return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return buffer.SlowBuffer(size)
+}

package/node_modules/safe-buffer/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "safe-buffer",
+  "description": "Safer Node.js Buffer API",
+  "version": "5.2.1",
+  "author": {
+    "name": "Feross Aboukhadijeh",
+    "email": "feross@feross.org",
+    "url": "https://feross.org"
+  },
+  "bugs": {
+    "url": "https://github.com/feross/safe-buffer/issues"
+  },
+  "devDependencies": {
+    "standard": "*",
+    "tape": "^5.0.0"
+  },
+  "homepage": "https://github.com/feross/safe-buffer",
+  "keywords": [
+    "buffer",
+    "buffer allocate",
+    "node security",
+    "safe",
+    "safe-buffer",
+    "security",
+    "uninitialized"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/feross/safe-buffer.git"
+  },
+  "scripts": {
+    "test": "standard && tape test/*.js"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/feross"
+    },
+    {
+      "type": "patreon",
+      "url": "https://www.patreon.com/feross"
+    },
+    {
+      "type": "consulting",
+      "url": "https://feross.org/support"
+    }
+  ]
+}

package/node_modules/stream-chain/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2019 Eugene Lazutkin
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/stream-chain/README.md

@@ -0,0 +1,334 @@
+# stream-chain [![NPM version][npm-img]][npm-url]
+
+[npm-img]:      https://img.shields.io/npm/v/stream-chain.svg
+[npm-url]:      https://npmjs.org/package/stream-chain
+
+`stream-chain` creates a chain of streams out of regular functions, asynchronous functions, generator functions, and existing streams, while properly handling [backpressure](https://nodejs.org/en/docs/guides/backpressuring-in-streams/). The resulting chain is represented as a [Duplex](https://nodejs.org/api/stream.html#stream_class_stream_duplex) stream, which can be combined with other streams the usual way. It eliminates a boilerplate helping to concentrate on functionality without losing the performance especially make it easy to build object mode data processing pipelines.
+
+Originally `stream-chain` was used internally with [stream-fork](https://www.npmjs.com/package/stream-fork) and [stream-json](https://www.npmjs.com/package/stream-json) to create flexible data processing pipelines.
+
+`stream-chain` is a lightweight, no-dependencies micro-package. It is distributed under New BSD license.
+
+## Intro
+
+```js
+const Chain = require('stream-chain');
+
+const fs = require('fs');
+const zlib = require('zlib');
+const {Transform} = require('stream');
+
+// the chain will work on a stream of number objects
+const chain = new Chain([
+  // transforms a value
+  x => x * x,
+  // returns several values
+  x => [x - 1, x, x + 1],
+  // waits for an asynchronous operation
+  async x => await getTotalFromDatabaseByKey(x),
+  // returns multiple values with a generator
+  function* (x) {
+    for (let i = x; i > 0; --i) {
+      yield i;
+    }
+    return 0;
+  },
+  // filters out even values
+  x => x % 2 ? x : null,
+  // uses an arbitrary transform stream
+  new Transform({
+    writableObjectMode: true,
+    transform(x, _, callback) {
+      // transform to text
+      callback(null, x.toString());
+    }
+  }),
+  // compress
+  zlib.createGzip()
+]);
+// log errors
+chain.on('error', error => console.log(error));
+// use the chain, and save the result to a file
+dataSource.pipe(chain).pipe(fs.createWriteStream('output.txt.gz'));
+```
+
+Making processing pipelines appears to be easy: just chain functions one after another, and we are done. Real life pipelines filter objects out and/or produce more objects out of a few ones. On top of that we have to deal with asynchronous operations, while processing or producing data: networking, databases, files, user responses, and so on. Unequal number of values per stage, and unequal throughput of stages introduced problems like [backpressure](https://nodejs.org/en/docs/guides/backpressuring-in-streams/), which requires algorithms implemented by [streams](https://nodejs.org/api/stream.html).
+
+While a lot of API improvements were made to make streams easy to use, in reality, a lot of boilerplate is required when creating a pipeline. `stream-chain` eliminates most of it.
+
+## Installation
+
+```bash
+npm i --save stream-chain
+# or: yarn add stream-chain
+```
+
+## Documentation
+
+`Chain`, which is returned by `require('stream-chain')`, is based on [Duplex](https://nodejs.org/api/stream.html#stream_class_stream_duplex). It chains its dependents in a single pipeline optionally binding `error` events.
+
+Many details about this package can be discovered by looking at test files located in `tests/` and in the source code (`index.js`).
+
+### Constructor: `new Chain(fns[, options])`
+
+The constructor accepts the following arguments:
+
+* `fns` is an array of functions arrays or stream instances.
+  * If a value is a function, a [Transform](https://nodejs.org/api/stream.html#stream_class_stream_transform) stream is created, which calls this function with two parameters: `chunk` (an object), and an optional `encoding`. See [Node's documentation](https://nodejs.org/api/stream.html#stream_transform_transform_chunk_encoding_callback) for more details on those parameters. The function will be called in the context of the created stream.
+    * If it is a regular function, it can return:
+      * Regular value:
+        * *(deprecated since 2.1.0)* Array of values to pass several or zero values to the next stream as they are.
+          ```js
+          // produces no values:
+          x => []
+          // produces two values:
+          x => [x, x + 1]
+          // produces one array value:
+          x => [[x, x + 1]]
+          ```
+        * Single value.
+          * If it is `undefined` or `null`, no value shall be passed.
+          * Otherwise, the value will be passed to the next stream.
+          ```js
+          // produces no values:
+          x => null
+          x => undefined
+          // produces one value:
+          x => x
+          ```
+      * Special value:
+        * If it is an instance of [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or "thenable" (an object with a method called `then()`), it will be waited for. Its result should be a regular value.
+          ```js
+          // delays by 0.5s:
+          x => new Promise(
+            resolve => setTimeout(() => resolve(x), 500))
+          ```
+        * If it is an instance of a generator or "nextable" (an object with a method called `next()`), it will be iterated according to the [generator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator) protocol. The results should be regular values.
+          ```js
+          // produces multiple values:
+          class Nextable {
+            constructor(x) {
+              this.x = x;
+              this.i = -1;
+            }
+            next() {
+              return {
+                done:  this.i <= 1,
+                value: this.x + this.i++
+              };
+            }
+          }
+          x => new Nextable(x)
+          ```
+          `next()` can return a `Promise` according to the [asynchronous generator](https://zaiste.net/nodejs_10_asynchronous_iteration_async_generators/) protocol.
+      * Any thrown exception will be caught and passed to a callback function effectively generating an error event.
+        ```js
+        // fails
+        x => { throw new Error('Bad!'); }
+        ```
+  * If it is an asynchronous function, it can return a regular value.
+    * In essence, it is covered under "special values" as a function that returns a promise.
+    ```js
+    // delays by 0.5s:
+    async x => {
+      await new Promise(resolve => setTimeout(() => resolve(), 500));
+      return x;
+    }
+    ```
+  * If it is a generator function, each yield should produce a regular value.
+    * In essence, it is covered under "special values" as a function that returns a generator object.
+    ```js
+    // produces multiple values:
+    function* (x) {
+      for (let i = -1; i <= 1; ++i) {
+        if (i) yield x + i;
+      }
+      return x;
+    }
+    ```
+  * *(since 2.2.0)* If it is an asynchronous generator function, each yield should produce a regular value.
+    * In essence, it is covered under "special values" as a function that returns a generator object.
+    ```js
+    // produces multiple values:
+    async function* (x) {
+      for (let i = -1; i <= 1; ++i) {
+        if (i) {
+          await new Promise(resolve => setTimeout(() => resolve(), 50));
+          yield x + i;
+        }
+      }
+      return x;
+    }
+    ```
+  * *(since 2.1.0)* If a value is an array, it is assumed to be an array of regular functions.
+    Their values are passed in a chain. All values (including `null`, `undefined`, and arrays) are allowed
+    and passed without modifications. The last value is a subject to processing defined above for regular functions.
+    * Empty arrays are ignored.
+    * If any function returns a value produced by `Chain.final(value)` (see below), it terminates the chain using
+      `value` as the final value of the chain.
+    * This feature bypasses streams. It is implemented for performance reasons.
+  * If a value is a valid stream, it is included as is in the pipeline.
+    * [Transform](https://nodejs.org/api/stream.html#stream_class_stream_transform).
+    * [Duplex](https://nodejs.org/api/stream.html#stream_class_stream_duplex).
+    * The very first stream can be [Readable](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+      * In this case a `Chain` instance ignores all possible writes to the front, and ends when the first stream ends.
+    * The very last stream can be [Writable](https://nodejs.org/api/stream.html#stream_class_stream_writable).
+      * In this case a `Chain` instance does not produce any output, and finishes when the last stream finishes.
+      * Because `'data'` event is not used in this case, the instance resumes itself automatically. Read about it in Node's documentation:
+        * [Two modes](https://nodejs.org/api/stream.html#stream_two_modes).
+        * [readable.resume()](https://nodejs.org/api/stream.html#stream_readable_resume).
+* `options` is an optional object detailed in the [Node's documentation](https://nodejs.org/api/stream.html#stream_new_stream_duplex_options).
+  * If `options` is not specified, or falsy, it is assumed to be:
+    ```js
+    {writableObjectMode: true, readableObjectMode: true}
+    ```
+  * Always make sure that `writableObjectMode` is the same as the corresponding object mode of the first stream, and `readableObjectMode` is the same as the corresponding object mode of the last stream.
+    * Eventually both these modes can be deduced, but Node does not define the standard way to determine it, so currently it cannot be done reliably.
+  * Additionally the following custom properties are recognized:
+    * `skipEvents` is an optional flag. If it is falsy (the default), `'error'` events from all streams are forwarded to the created instance. If it is truthy, no event forwarding is made. A user can always do so externally or in a constructor of derived classes.
+
+An instance can be used to attach handlers for stream events.
+
+```js
+const chain = new Chain([x => x * x, x => [x - 1, x, x + 1]]);
+chain.on('error', error => console.error(error));
+dataSource.pipe(chain);
+```
+
+### Properties
+
+Following public properties are available:
+
+* `streams` is an array of streams created by a constructor. Its values either [Transform](https://nodejs.org/api/stream.html#stream_class_stream_transform) streams that use corresponding functions from a constructor parameter, or user-provided streams. All streams are piped sequentially starting from the beginning.
+* `input` is the beginning of the pipeline. Effectively it is the first item of `streams`.
+* `output` is the end of the pipeline. Effectively it is the last item of `streams`.
+
+Generally, a `Chain` instance should be used to represent a chain:
+
+```js
+const chain = new Chain([
+  x => x * x,
+  x => [x - 1, x, x + 1],
+  new Transform({
+    writableObjectMode: true,
+    transform(chunk, _, callback) {
+      callback(null, chunk.toString());
+    }
+  })
+]);
+dataSource
+  .pipe(chain);
+  .pipe(zlib.createGzip())
+  .pipe(fs.createWriteStream('output.txt.gz'));
+```
+
+But in some cases `input` and `output` provide a better control over how a data processing pipeline should be organized:
+
+```js
+chain.output
+  .pipe(zlib.createGzip())
+  .pipe(fs.createWriteStream('output.txt.gz'));
+dataSource.pipe(chain.input);
+```
+
+Please select what style you want to use, and never mix them together with the same object.
+
+### Static methods
+
+Following static methods are available:
+
+* `chain(fns[, options)` is a helper factory function, which has the same arguments as the constructor and returns a `Chain` instance.
+  ```js
+  const {chain} = require('stream-chain');
+
+  // simple
+  dataSource
+    .pipe(chain([x => x * x, x => [x - 1, x, x + 1]]));
+
+  // all inclusive
+  chain([
+    dataSource,
+    x => x * x,
+    x => [x - 1, x, x + 1],
+    zlib.createGzip(),
+    fs.createWriteStream('output.txt.gz')
+  ])
+  ```
+* *(since 2.1.0)* `final(value)` is a helper factory function, which can be used in by chained functions (see above the array of functions).
+  It returns a special value, which terminates the chain and uses the passed value as the result of the chain.
+  ```js
+  const {chain, final} = require('stream-chain');
+
+  // simple
+  dataSource
+    .pipe(chain([[x => x * x, x => 2 * x + 1]]));
+  // faster than [x => x * x, x => 2 * x + 1]
+
+  // final
+  dataSource
+    .pipe(chain([[
+      x => x * x,
+      x => final(x),
+      x => 2 * x + 1
+    ]]));
+  // the same as [[x => x * x, x => x]]
+  // the same as [[x => x * x]]
+  // the same as [x => x * x]
+
+  // final as a terminator
+  dataSource
+    .pipe(chain([[
+      x => x * x,
+      x => final(),
+      x => 2 * x + 1
+    ]]));
+  // produces no values, because the final value is undefined,
+  // which is interpreted as "no value shall be passed"
+  // see the doc above
+
+  // final() as a filter
+  dataSource
+    .pipe(chain([[
+      x => x * x,
+      x => x % 2 ? final() : x,
+      x => 2 * x + 1
+    ]]));
+  // only even values are passed, odd values are ignored
+
+  // if you want to be really performant...
+  const none = final();
+  dataSource
+    .pipe(chain([[
+      x => x * x,
+      x => x % 2 ? none : x,
+      x => 2 * x + 1
+    ]]));
+  ```
+* *(since 2.1.0)* `many(array)` is a helper factory function, which is used to wrap arrays to be interpreted as multiple values returned from a function.
+  At the moment it is redundant: you can use a simple array to indicate that, but a naked array is being deprecated and in future versions it will be passed as is.
+  The thinking is that using `many()` is better indicates the intention. Additionally, in the future versions it will be used by array of functions (see above).
+  ```js
+  const {chain, many} = require('stream-chain');
+
+  dataSource
+    .pipe(chain([x => many([x, x + 1, x + 2])]));
+  // currently the same as [x => [x, x + 1, x + 2]]
+  ```
+
+## Release History
+
+- 2.2.5 *Relaxed the definition of a stream (thx [Rich Hodgkins](https://github.com/rhodgkins)).*
+- 2.2.4 *Bugfix: wrong `const`-ness in the async generator branch (thx [Patrick Pang](https://github.com/patrickpang)).*
+- 2.2.3 *Technical release. No need to upgrade.*
+- 2.2.2 *Technical release. No need to upgrade.*
+- 2.2.1 *Technical release: new symbols namespace, explicit license (thx [Keen Yee Liau](https://github.com/kyliau)), added Greenkeeper.*
+- 2.2.0 *Added utilities: `take`, `takeWhile`, `skip`, `skipWhile`, `fold`, `scan`, `Reduce`, `comp`.*
+- 2.1.0 *Added simple transducers, dropped Node 6.*
+- 2.0.3 *Added TypeScript typings and the badge.*
+- 2.0.2 *Workaround for Node 6: use `'finish'` event instead of `_final()`.*
+- 2.0.1 *Improved documentation.*
+- 2.0.0 *Upgraded to use Duplex instead of EventEmitter as the base.*
+- 1.0.3 *Improved documentation.*
+- 1.0.2 *Better README.*
+- 1.0.1 *Fixed the README.*
+- 1.0.0 *The initial release.*

package/node_modules/stream-chain/defs.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const none = Symbol.for('object-stream.none');
+const finalSymbol = Symbol.for('object-stream.final');
+const manySymbol = Symbol.for('object-stream.many');
+
+const final = value => ({[finalSymbol]: value});
+const many = values => ({[manySymbol]: values});
+
+const isFinal = o => o && typeof o == 'object' && finalSymbol in o;
+const isMany = o => o && typeof o == 'object' && manySymbol in o;
+
+const getFinalValue = o => o[finalSymbol];
+const getManyValues = o => o[manySymbol];
+
+module.exports.none = none;
+module.exports.final = final;
+module.exports.isFinal = isFinal;
+module.exports.getFinalValue = getFinalValue;
+module.exports.many = many;
+module.exports.isMany = isMany;
+module.exports.getManyValues = getManyValues;