redis 3.0.0 → 3.1.1

package/.deepsource.toml

@@ -0,0 +1,9 @@
+version = 1
+exclude_patterns = ["examples/**"]
+
+[[analyzers]]
+name = "javascript"
+enabled = true
+
+  [analyzers.meta]
+  environment = ["nodejs"]

package/CHANGELOG.md

@@ -28,6 +28,7 @@ a lot of old deprecated features and old internals in preparation for an upcomin
 - Replaced `double-ended-queue` with `denque`, which brings performance improvements
 - Add timestamps to debug traces
 - Add `socket_initial_delay` option for `socket.setKeepAlive` (#1396)
+- Add support for `rediss` protocol in url (#1282)
 
 ## v2.8.0 - 31 Jul, 2017
 

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) Node Redis contributors.
+Copyright (c) 2016-present Node Redis contributors.
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

package/README.md

@@ -9,12 +9,14 @@
 ---
 
 <p align="center">
-    <a href="https://www.npmjs.com/package/redis"><img src="https://img.shields.io/npm/dm/redis.svg?style=flat-square" alt="NPM downloads"></a>
-    <a href="https://www.npmjs.com/package/redis"><img src="https://img.shields.io/npm/v/redis.svg?style=flat-square" alt="NPM version"></a>
-    <a href="https://travis-ci.org/NodeRedis/node-redis"><img src="https://travis-ci.org/NodeRedis/node-redis.svg?style=flat-square&branch=master" alt="Build Status" /></a>
-    <a href="https://ci.appveyor.com/project/BridgeAR/node-redis/branch/master"><img src="https://img.shields.io/appveyor/ci/BridgeAR/node-redis/master.svg?style=flat-square&label=Windows%20Tests" alt="Windows Tests" /></a>
-    <a href="https://coveralls.io/r/NodeRedis/node-redis?branch="><img src="https://coveralls.io/repos/NodeRedis/node-redis/badge.svg?style=flat-square&branch=" alt="Coverage Status" /></a>
-    <a href="https://twitter.com/NodeRedis"><img src="https://img.shields.io/twitter/follow/NodeRedis.svg?style=flat-square&colorA=1da1f2&colorB=&label=Follow%20on%20Twitter" alt="Follow on Twitter"></a>
+    <a href="https://www.npmjs.com/package/redis"><img src="https://img.shields.io/npm/dm/redis.svg" alt="NPM downloads"></a>
+    <a href="https://www.npmjs.com/package/redis"><img src="https://img.shields.io/npm/v/redis.svg" alt="NPM version"></a>
+    <a href="https://github.com/NodeRedis/node-redis/actions?query=workflow%3ATests"><img src="https://github.com/NodeRedis/node-redis/workflows/Tests/badge.svg" alt="Build Status" /></a>
+    <a href="https://github.com/NodeRedis/node-redis/actions?query=workflow%3A%22Tests+Windows%22"><img src="https://github.com/NodeRedis/node-redis/workflows/Tests%20Windows/badge.svg" alt="Windows Build Status" /></a>
+    <a href="https://coveralls.io/r/NodeRedis/node-redis?branch="><img src="https://coveralls.io/repos/NodeRedis/node-redis/badge.svg?branch=master" alt="Coverage Status" /></a>
+    <a href="https://codeclimate.com/github/NodeRedis/node-redis/maintainability"><img src="https://api.codeclimate.com/v1/badges/f6d7063243c234237e73/maintainability" /></a>
+    <a href="https://lgtm.com/projects/g/NodeRedis/node-redis/context:javascript"><img src="https://img.shields.io/lgtm/grade/javascript/g/NodeRedis/node-redis.svg?logo=lgtm&logoWidth=18" alt="Coverage Status" /></a>
+    <a href="https://discord.gg/XMMVgxUm"><img src="https://img.shields.io/discord/697882427875393627?style=flat-square" /></a>
 </p>
 
 ---
@@ -171,15 +173,16 @@ using unix sockets if possible to increase throughput.
 | port                       | 6379      | Port of the Redis server                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | path                       | null      | The UNIX socket string of the Redis server                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | url                        | null      | The URL of the Redis server. Format: `[redis[s]:]//[[user][:password@]][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]` (More info avaliable at [IANA](http://www.iana.org/assignments/uri-schemes/prov/redis)).                                                                                                                                                                                                                                                                                                                                       |
-| string_numbers             | null      | Set to `true`, Node Redis will return Redis number values as Strings instead of javascript Numbers. Useful if you need to handle big numbers (above `Number.MAX_SAFE_INTEGER === 2^53`). Hiredis is incapable of this behavior, so setting this option to `true` will result in the built-in javascript parser being used no matter the value of the `parser` option.                                                                                                                                                                                                       |
+| string_numbers             | null      | Set to `true`, Node Redis will return Redis number values as Strings instead of javascript Numbers. Useful if you need to handle big numbers (above `Number.MAX_SAFE_INTEGER === 2^53`). Hiredis is incapable of this behavior, so setting this option to `true` will result in the built-in javascript parser being used no matter the value of the `parser` option.                                                                                                                                                                                                         |
 | return_buffers             | false     | If set to `true`, then all replies will be sent to callbacks as Buffers instead of Strings.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | detect_buffers             | false     | If set to `true`, then replies will be sent to callbacks as Buffers. This option lets you switch between Buffers and Strings on a per-command basis, whereas `return_buffers` applies to every command on a client. **Note**: This doesn't work properly with the pubsub mode. A subscriber has to either always return Strings or Buffers.                                                                                                                                                                                                                                   |
 | socket_keepalive           | true      | If set to `true`, the keep-alive functionality is enabled on the underlying socket.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | socket_initial_delay       | 0         | Initial Delay in milliseconds, and this will also behave the interval keep alive message sending to Redis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| no_ready_check             | false     | When a connection is established to the Redis server, the server might still be loading the database from disk. While loading, the server will not respond to any commands. To work around this, Node Redis has a "ready check" which sends the `INFO` command to the server. The response from the `INFO` command indicates whether the server is ready for more commands. When ready, `node_redis` emits a `ready` event. Setting `no_ready_check` to `true` will inhibit this check.                                                                                     |
+| no_ready_check             | false     | When a connection is established to the Redis server, the server might still be loading the database from disk. While loading, the server will not respond to any commands. To work around this, Node Redis has a "ready check" which sends the `INFO` command to the server. The response from the `INFO` command indicates whether the server is ready for more commands. When ready, `node_redis` emits a `ready` event. Setting `no_ready_check` to `true` will inhibit this check.                                                                                       |
 | enable_offline_queue       | true      | By default, if there is no active connection to the Redis server, commands are added to a queue and are executed once the connection has been established. Setting `enable_offline_queue` to `false` will disable this feature and the callback will be executed immediately with an error, or an error will be emitted if no callback is specified.                                                                                                                                                                                                                          |
 | retry_unfulfilled_commands | false     | If set to `true`, all commands that were unfulfilled while the connection is lost will be retried after the connection has been reestablished. Use this with caution if you use state altering commands (e.g. `incr`). This is especially useful if you use blocking commands.                                                                                                                                                                                                                                                                                                |
-| password                   | null      | If set, client will run Redis auth command on connect. Alias `auth_pass` **Note** Node Redis < 2.5 must use `auth_pass`                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| password                   | null      | If set, client will run Redis auth command on connect. Alias `auth_pass` **Note** Node Redis < 2.5 must use `auth_pass`                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| user                       | null      | The ACL user (only valid when `password` is set)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | db                         | null      | If set, client will run Redis `select` command on connect.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | family                     | IPv4      | You can force using IPv6 if you set the family to 'IPv6'. See Node.js [net](https://nodejs.org/api/net.html) or [dns](https://nodejs.org/api/dns.html) modules on how to use the family type.                                                                                                                                                                                                                                                                                                                                                                                 |
 | disable_resubscribing      | false     | If set to `true`, a client won't resubscribe after disconnecting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
@@ -187,6 +190,7 @@ using unix sockets if possible to increase throughput.
 | tls                        | null      | An object containing options to pass to [tls.connect](http://nodejs.org/api/tls.html#tls_tls_connect_port_host_options_callback) to set up a TLS connection to Redis (if, for example, it is set up to be accessible via a tunnel).                                                                                                                                                                                                                                                                                                                                           |
 | prefix                     | null      | A string used to prefix all used keys (e.g. `namespace:test`). Please be aware that the `keys` command will not be prefixed. The `keys` command has a "pattern" as argument and no key and it would be impossible to determine the existing keys in Redis if this would be prefixed.                                                                                                                                                                                                                                                                                          |
 | retry_strategy             | function  | A function that receives an options object as parameter including the retry `attempt`, the `total_retry_time` indicating how much time passed since the last time connected, the `error` why the connection was lost and the number of `times_connected` in total. If you return a number from this function, the retry will happen exactly after that time in milliseconds. If you return a non-number, no further retry will happen and all offline commands are flushed with errors. Return an error to return that specific error to all offline commands. Example below. |
+| connect_timeout            | 3600000   | In milliseconds. This should only be the timeout for connecting to redis, but for now it interferes with `retry_strategy` and stops it from reconnecting after this timeout.                                                                                                                                                                                                                                                                                                                                                                                                  |
 
 **`detect_buffers` example:**
 
@@ -210,7 +214,7 @@ client.get(new Buffer("foo_rand000000000000"), function(err, reply) {
 **`retry_strategy` example:**
 
 ```js
-var client = redis.createClient({
+const client = redis.createClient({
   retry_strategy: function(options) {
     if (options.error && options.error.code === "ECONNREFUSED") {
       // End reconnecting on a specific error and flush all commands with
@@ -394,7 +398,7 @@ responses using JavaScript syntax.
 ```js
 client.hmset("key", "foo", "bar", "hello", "world");
 
-client.hgetall("hosts", function(err, value) {
+client.hgetall("key", function(err, value) {
   console.log(value.foo); // > "bar"
   console.log(value.hello); // > "world"
 });
@@ -638,7 +642,7 @@ client.watch("foo", function(watchError) {
          * If err is null, it means Redis successfully attempted
          * the operation.
          */
-        if (execError) throw err;
+        if (execError) throw execError;
 
         /**
          * If results === null, it means that a concurrent client
@@ -675,12 +679,12 @@ clients.watcher.watch("foo", function(watchError) {
 
   // if you comment out the next line, the transaction will work
   clients.modifier.set("foo", Math.random(), setError => {
-    if (setError) throw err;
+    if (setError) throw setError;
   });
 
-  //using a setTimeout here to ensure that the MULTI/EXEC will come after the SET.
-  //Normally, you would use a callback to ensure order, but I want the above SET command
-  //to be easily comment-out-able.
+  // using a setTimeout here to ensure that the MULTI/EXEC will come after the SET.
+  // Normally, you would use a callback to ensure order, but I want the above SET command
+  // to be easily comment-out-able.
   setTimeout(function() {
     clients.watcher
       .multi()
@@ -840,26 +844,26 @@ returns it in the callback. If an error occurs in the meanwhile, that is going
 to return an error instead in the callback.
 
 One example of when to use duplicate() would be to accommodate the connection-
-blocking redis commands BRPOP, BLPOP, and BRPOPLPUSH. If these commands
+blocking redis commands `BRPOP`, `BLPOP`, and `BRPOPLPUSH`. If these commands
 are used on the same Redis client instance as non-blocking commands, the
 non-blocking ones may be queued up until after the blocking ones finish.
 
 Another reason to use duplicate() is when multiple DBs on the same server are
 accessed via the redis SELECT command. Each DB could use its own connection.
 
-### `client.send_command(command_name[, [args][, callback]])`
+### `client.sendCommand(command_name[, [args][, callback]])`
 
 All Redis commands have been added to the `client` object. However, if new
 commands are introduced before this library is updated or if you want to add
-individual commands you can use `send_command()` to send arbitrary commands to
+individual commands you can use `sendCommand()` to send arbitrary commands to
 Redis.
 
 All commands are sent as multi-bulk commands. `args` can either be an Array of
 arguments, or omitted / set to undefined.
 
-### `redis.add_command(command_name)`
+### `redis.addCommand(command_name)`
 
-Calling add_command will add a new command to the prototype. The exact command
+Calling addCommand will add a new command to the prototype. The exact command
 name will be used when calling using this new command. Using arbitrary arguments
 is possible as with any other command.
 

package/heroku/index.js

@@ -0,0 +1,14 @@
+const redis = require("redis");
+const client = redis.createClient(process.env.REDISCLOUD_URL);
+
+console.log(process.env.REDISCLOUD_URL);
+
+setInterval(() => {
+  client.get('a', (err, result) => {
+    if (err) {
+      return console.error(err);
+    }
+
+    console.log(result);
+  })
+}, 3000);

package/heroku/node_modules/.package-lock.json

@@ -0,0 +1,57 @@
+{
+  "name": "heroku",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "node_modules/denque": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/denque/-/denque-1.5.0.tgz",
+      "integrity": "sha512-CYiCSgIF1p6EUByQPlGkKnP1M9g0ZV3qMIrqMqZqdwazygIA/YP2vrbcyl1h/WppKJTdl1F85cXIle+394iDAQ==",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/redis": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/redis/-/redis-3.1.0.tgz",
+      "integrity": "sha512-//lAOcEtNIKk2ekZibes5oyWKYUVWMvMB71lyD/hS9KRePNkB7AU3nXGkArX6uDKEb2N23EyJBthAv6pagD0uw==",
+      "dependencies": {
+        "denque": "^1.5.0",
+        "redis-commands": "^1.7.0",
+        "redis-errors": "^1.2.0",
+        "redis-parser": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-redis"
+      }
+    },
+    "node_modules/redis-commands": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/redis-commands/-/redis-commands-1.7.0.tgz",
+      "integrity": "sha512-nJWqw3bTFy21hX/CPKHth6sfhZbdiHP6bTawSgQBlKOVRG7EZkfHbbHwQJnrE4vsQf0CMNE+3gJ4Fmm16vdVlQ=="
+    },
+    "node_modules/redis-errors": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/redis-errors/-/redis-errors-1.2.0.tgz",
+      "integrity": "sha1-62LSrbFeTq9GEMBK/hUpOEJQq60=",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/redis-parser": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redis-parser/-/redis-parser-3.0.0.tgz",
+      "integrity": "sha1-tm2CjNyv5rS4pCin3vTGvKwxyLQ=",
+      "dependencies": {
+        "redis-errors": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    }
+  }
+}

package/heroku/node_modules/denque/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 1.5.0
+
+ - feat: adds capacity option for circular buffers (#27)
+

package/heroku/node_modules/denque/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2018 Mike Diarmid (Salakar) <mike.diarmid@gmail.com>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this library except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/heroku/node_modules/denque/README.md

@@ -0,0 +1,362 @@
+<p align="center">
+  <a href="https://invertase.io">
+    <img src="https://static.invertase.io/assets/invertase-logo-small.png"><br/>
+  </a>
+  <h2 align="center">Denque</h2>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/denque"><img src="https://img.shields.io/npm/dm/denque.svg?style=flat-square" alt="NPM downloads"></a>
+  <a href="https://www.npmjs.com/package/denque"><img src="https://img.shields.io/npm/v/denque.svg?style=flat-square" alt="NPM version"></a>
+  <a href="https://travis-ci.org/Salakar/denque"><img src="https://travis-ci.org/invertase/denque.svg" alt="Build version"></a>
+  <a href="https://coveralls.io/github/invertase/denque?branch=master"><img src="https://coveralls.io/repos/github/invertase/denque/badge.svg?branch=master" alt="Build version"></a>  
+  <a href="/LICENSE"><img src="https://img.shields.io/npm/l/denque.svg?style=flat-square" alt="License"></a>
+  <a href="https://discord.gg/C9aK28N"><img src="https://img.shields.io/discord/295953187817521152.svg?logo=discord&style=flat-square&colorA=7289da&label=discord" alt="Chat"></a>
+  <a href="https://twitter.com/invertaseio"><img src="https://img.shields.io/twitter/follow/invertaseio.svg?style=social&label=Follow" alt="Follow on Twitter"></a>
+</p>
+
+Extremely fast and lightweight [double-ended queue](http://en.wikipedia.org/wiki/Double-ended_queue) implementation with zero dependencies.
+
+Double-ended queues can also be used as a:
+
+- [Stack](http://en.wikipedia.org/wiki/Stack_\(abstract_data_type\))
+- [Queue](http://en.wikipedia.org/wiki/Queue_\(data_structure\))
+
+This implementation is currently the fastest available, even faster than `double-ended-queue`, see the [benchmarks](#benchmarks)
+
+Every queue operation is done at a constant `O(1)` - including random access from `.peekAt(index)`.
+
+**Works on all node versions >= v0.10**
+
+# Quick Start
+
+    npm install denque
+
+```js
+const Denque = require("denque");
+
+const denque = new Denque([1,2,3,4]);
+denque.shift(); // 1
+denque.pop(); // 4
+```
+
+
+# API
+
+- [`new Denque()`](#new-denque---denque)
+- [`new Denque(Array items)`](#new-denquearray-items---denque)
+- [`push(item)`](#pushitem---int)
+- [`unshift(item)`](#unshiftitem---int)
+- [`pop()`](#pop---dynamic)
+- [`shift()`](#shift---dynamic)
+- [`toArray()`](#toarray---array)
+- [`peekBack()`](#peekback---dynamic)
+- [`peekFront()`](#peekfront---dynamic)
+- [`peekAt(int index)`](#peekAtint-index---dynamic)
+- [`remove(int index, int count)`](#remove)
+- [`removeOne(int index)`](#removeOne)
+- [`splice(int index, int count, item1, item2, ...)`](#splice)
+- [`isEmpty()`](#isempty---boolean)
+- [`clear()`](#clear---void)
+
+#### `new Denque()` -> `Denque`
+
+Creates an empty double-ended queue with initial capacity of 4.
+
+```js
+var denque = new Denque();
+denque.push(1);
+denque.push(2);
+denque.push(3);
+denque.shift(); //1
+denque.pop(); //3
+```
+
+<hr>
+
+#### `new Denque(Array items)` -> `Denque`
+
+Creates a double-ended queue from `items`.
+
+```js
+var denque = new Denque([1,2,3,4]);
+denque.shift(); // 1
+denque.pop(); // 4
+```
+
+<hr>
+
+
+#### `push(item)` -> `int`
+
+Push an item to the back of this queue. Returns the amount of items currently in the queue after the operation.
+
+```js
+var denque = new Denque();
+denque.push(1);
+denque.pop(); // 1
+denque.push(2);
+denque.push(3);
+denque.shift(); // 2
+denque.shift(); // 3
+```
+
+<hr>
+
+#### `unshift(item)` -> `int`
+
+Unshift an item to the front of this queue. Returns the amount of items currently in the queue after the operation.
+
+```js
+var denque = new Denque([2,3]);
+denque.unshift(1);
+denque.toString(); // "1,2,3"
+denque.unshift(-2);
+denque.toString(); // "-2,-1,0,1,2,3"
+```
+
+<hr>
+
+
+#### `pop()` -> `dynamic`
+
+Pop off the item at the back of this queue.
+
+Note: The item will be removed from the queue. If you simply want to see what's at the back of the queue use [`peekBack()`](#peekback---dynamic) or [`.peekAt(-1)`](#peekAtint-index---dynamic).
+
+If the queue is empty, `undefined` is returned. If you need to differentiate between `undefined` values in the queue and `pop()` return value -
+check the queue `.length` before popping.
+
+```js
+var denque = new Denque([1,2,3]);
+denque.pop(); // 3
+denque.pop(); // 2
+denque.pop(); // 1
+denque.pop(); // undefined
+```
+
+**Aliases:** `removeBack`
+
+<hr>
+
+#### `shift()` -> `dynamic`
+
+Shifts off the item at the front of this queue.
+
+Note: The item will be removed from the queue. If you simply want to see what's at the front of the queue use [`peekFront()`](#peekfront---dynamic) or [`.peekAt(0)`](#peekAtint-index---dynamic).
+
+If the queue is empty, `undefined` is returned. If you need to differentiate between `undefined` values in the queue and `shift()` return value -
+check the queue `.length` before shifting.
+
+```js
+var denque = new Denque([1,2,3]);
+denque.shift(); // 1
+denque.shift(); // 2
+denque.shift(); // 3
+denque.shift(); // undefined
+```
+
+<hr>
+
+#### `toArray()` -> `Array`
+
+Returns the items in the queue as an array. Starting from the item in the front of the queue and ending to the item at the back of the queue.
+
+```js
+var denque = new Denque([1,2,3]);
+denque.push(4);
+denque.unshift(0);
+denque.toArray(); // [0,1,2,3,4]
+```
+
+<hr>
+
+#### `peekBack()` -> `dynamic`
+
+Returns the item that is at the back of this queue without removing it.
+
+If the queue is empty, `undefined` is returned.
+
+```js
+var denque = new Denque([1,2,3]);
+denque.push(4);
+denque.peekBack(); // 4
+```
+
+<hr>
+
+#### `peekFront()` -> `dynamic`
+
+Returns the item that is at the front of this queue without removing it.
+
+If the queue is empty, `undefined` is returned.
+
+```js
+var denque = new Denque([1,2,3]);
+denque.push(4);
+denque.peekFront(); // 1
+```
+
+<hr>
+
+#### `peekAt(int index)` -> `dynamic`
+
+Returns the item that is at the given `index` of this queue without removing it.
+
+The index is zero-based, so `.peekAt(0)` will return the item that is at the front, `.peekAt(1)` will return
+the item that comes after and so on.
+
+The index can be negative to read items at the back of the queue. `.peekAt(-1)` returns the item that is at the back of the queue,
+`.peekAt(-2)` will return the item that comes before and so on.
+
+Returns `undefined` if `index` is not a valid index into the queue.
+
+```js
+var denque = new Denque([1,2,3]);
+denque.peekAt(0); //1
+denque.peekAt(1); //2
+denque.peekAt(2); //3
+
+denque.peekAt(-1); // 3
+denque.peekAt(-2); // 2
+denque.peekAt(-3); // 1
+```
+
+**Note**: The implementation has O(1) random access using `.peekAt()`.
+
+**Aliases:** `get`
+
+<hr>
+
+#### `remove(int index, int count)` -> `array`
+
+Remove number of items from the specified index from the list.
+
+Returns array of removed items.
+
+Returns undefined if the list is empty.
+
+```js
+var denque = new Denque([1,2,3,4,5,6,7]);
+denque.remove(0,3); //[1,2,3]
+denque.remove(1,2); //[5,6]
+var denque1 = new Denque([1,2,3,4,5,6,7]);
+denque1.remove(4, 100); //[5,6,7]
+```
+
+<hr>
+
+#### `removeOne(int index)` -> `dynamic`
+
+Remove and return the item at the specified index from the list.
+
+Returns undefined if the list is empty.
+
+```js
+var denque = new Denque([1,2,3,4,5,6,7]);
+denque.removeOne(4); // 5
+denque.removeOne(3); // 4
+denque1.removeOne(1); // 2
+```
+
+<hr>
+
+#### `splice(int index, int count, item1, item2, ...)` -> `array`
+
+Native splice implementation.
+
+Remove number of items from the specified index from the list and/or add new elements.
+
+Returns array of removed items or empty array if count == 0.
+
+Returns undefined if the list is empty.
+
+```js
+var denque = new Denque([1,2,3,4,5,6,7]);
+denque.splice(denque.length, 0, 8, 9, 10); // []
+denque.toArray() // [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
+denque.splice(3, 3, 44, 55, 66); // [4,5,6]
+denque.splice(5,4, 666,667,668,669); // [ 66, 7, 8, 9 ]
+denque.toArray() // [ 1, 2, 3, 44, 55, 666, 667, 668, 669, 10 ]
+```
+
+<hr>
+
+#### `isEmpty()` -> `boolean`
+
+Return `true` if this queue is empty, `false` otherwise.
+
+```js
+var denque = new Denque();
+denque.isEmpty(); // true
+denque.push(1);
+denque.isEmpty(); // false
+```
+
+<hr>
+
+#### `clear()` -> `void`
+
+Remove all items from this queue. Does not change the queue's capacity.
+
+```js
+var denque = new Denque([1,2,3]);
+denque.toString(); // "1,2,3"
+denque.clear();
+denque.toString(); // ""
+```
+<hr>
+
+
+## Benchmarks
+
+#### Platform info:
+```
+Darwin 17.0.0 x64
+Node.JS 9.4.0
+V8 6.2.414.46-node.17
+Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz × 8
+```
+
+#### 1000 items in queue
+
+ (3 x shift + 3 x push ops per 'op')
+
+    denque x 64,365,425 ops/sec ±0.69% (92 runs sampled)
+    double-ended-queue x 26,646,882 ops/sec ±0.47% (94 runs sampled)
+
+#### 2 million items in queue
+
+ (3 x shift + 3 x push ops per 'op')
+
+    denque x 61,994,249 ops/sec ±0.26% (95 runs sampled)
+    double-ended-queue x 26,363,500 ops/sec ±0.42% (91 runs sampled)
+
+#### Splice
+
+ (1 x splice per 'op') - initial size of 100,000 items
+
+    denque.splice x 925,749 ops/sec ±22.29% (77 runs sampled)
+    native array splice x 7,777 ops/sec ±8.35% (50 runs sampled)
+
+#### Remove
+
+ (1 x remove + 10 x push per 'op') - initial size of 100,000 items
+
+    denque.remove x 2,635,275 ops/sec ±0.37% (95 runs sampled)
+    native array splice - Fails to complete: "JavaScript heap out of memory"
+
+#### Remove One
+
+ (1 x removeOne + 10 x push per 'op') - initial size of 100,000 items
+
+    denque.removeOne x 1,088,240 ops/sec ±0.21% (93 runs sampled)
+    native array splice x 5,300 ops/sec ±0.41% (96 runs sampled)
+    
+---
+
+Built and maintained with 💛 by [Invertase](https://invertase.io).
+
+- [💼 Hire Us](https://invertase.io/hire-us)
+- [☕️ Sponsor Us](https://opencollective.com/react-native-firebase)
+- [👩‍💻 Work With Us](https://invertase.io/jobs)

package/heroku/node_modules/denque/index.d.ts

@@ -0,0 +1,31 @@
+declare class Denque<T = any> {
+  constructor();
+  constructor(array: T[]);
+  constructor(array: T[], options: IDenqueOptions);
+
+  push(item: T): number;
+  unshift(item: T): number;
+  pop(): T | undefined;
+  removeBack(): T | undefined;
+  shift(): T | undefined;
+  peekBack(): T | undefined;
+  peekFront(): T | undefined;
+  peekAt(index: number): T | undefined;
+  get(index: number): T | undefined;
+  remove(index: number, count: number): T[];
+  removeOne(index: number): T | undefined;
+  splice(index: number, count: number, ...item: T[]): T[] | undefined;
+  isEmpty(): boolean;
+  clear(): void;
+
+  toString(): string;
+  toArray(): T[];
+
+  length: number;
+}
+
+interface IDenqueOptions {
+  capacity?: number
+}
+
+export = Denque;