From e06ec920f7a5d784e674c4c4b4e6d1da3dc7391d Mon Sep 17 00:00:00 2001 From: Piotr Russ Date: Mon, 16 Nov 2020 00:10:28 +0100 Subject: api, login, auth --- node_modules/denque/LICENSE | 13 ++ node_modules/denque/README.md | 362 ++++++++++++++++++++++++++++++++ node_modules/denque/index.d.ts | 26 +++ node_modules/denque/index.js | 437 +++++++++++++++++++++++++++++++++++++++ node_modules/denque/package.json | 84 ++++++++ 5 files changed, 922 insertions(+) create mode 100644 node_modules/denque/LICENSE create mode 100644 node_modules/denque/README.md create mode 100644 node_modules/denque/index.d.ts create mode 100644 node_modules/denque/index.js create mode 100644 node_modules/denque/package.json (limited to 'node_modules/denque') diff --git a/node_modules/denque/LICENSE b/node_modules/denque/LICENSE new file mode 100644 index 0000000..fd22a2d --- /dev/null +++ b/node_modules/denque/LICENSE @@ -0,0 +1,13 @@ +Copyright (c) 2018 Mike Diarmid (Salakar) + +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. diff --git a/node_modules/denque/README.md b/node_modules/denque/README.md new file mode 100644 index 0000000..6821e0d --- /dev/null +++ b/node_modules/denque/README.md @@ -0,0 +1,362 @@ +

+ +
+ +

Denque

+

+ +

+ NPM downloads + NPM version + Build version + Build version + License + Chat + Follow on Twitter +

+ +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 +``` + +
+ +#### `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 +``` + +
+ + +#### `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 +``` + +
+ +#### `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" +``` + +
+ + +#### `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` + +
+ +#### `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 +``` + +
+ +#### `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] +``` + +
+ +#### `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 +``` + +
+ +#### `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 +``` + +
+ +#### `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` + +
+ +#### `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] +``` + +
+ +#### `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 +``` + +
+ +#### `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 ] +``` + +
+ +#### `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 +``` + +
+ +#### `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(); // "" +``` +
+ + +## 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) diff --git a/node_modules/denque/index.d.ts b/node_modules/denque/index.d.ts new file mode 100644 index 0000000..803450f --- /dev/null +++ b/node_modules/denque/index.d.ts @@ -0,0 +1,26 @@ +declare class Denque { + constructor(); + constructor(array: T[]); + + 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; +} + +export = Denque; diff --git a/node_modules/denque/index.js b/node_modules/denque/index.js new file mode 100644 index 0000000..2f03136 --- /dev/null +++ b/node_modules/denque/index.js @@ -0,0 +1,437 @@ +'use strict'; + +/** + * Custom implementation of a double ended queue. + */ +function Denque(array) { + this._head = 0; + this._tail = 0; + this._capacityMask = 0x3; + this._list = new Array(4); + if (Array.isArray(array)) { + this._fromArray(array); + } +} + +/** + * ------------- + * PUBLIC API + * ------------- + */ + +/** + * Returns the item at the specified index from the list. + * 0 is the first element, 1 is the second, and so on... + * Elements at negative values are that many from the end: -1 is one before the end + * (the last element), -2 is two before the end (one before last), etc. + * @param index + * @returns {*} + */ +Denque.prototype.peekAt = function peekAt(index) { + var i = index; + // expect a number or return undefined + if ((i !== (i | 0))) { + return void 0; + } + var len = this.size(); + if (i >= len || i < -len) return undefined; + if (i < 0) i += len; + i = (this._head + i) & this._capacityMask; + return this._list[i]; +}; + +/** + * Alias for peakAt() + * @param i + * @returns {*} + */ +Denque.prototype.get = function get(i) { + return this.peekAt(i); +}; + +/** + * Returns the first item in the list without removing it. + * @returns {*} + */ +Denque.prototype.peek = function peek() { + if (this._head === this._tail) return undefined; + return this._list[this._head]; +}; + +/** + * Alias for peek() + * @returns {*} + */ +Denque.prototype.peekFront = function peekFront() { + return this.peek(); +}; + +/** + * Returns the item that is at the back of the queue without removing it. + * Uses peekAt(-1) + */ +Denque.prototype.peekBack = function peekBack() { + return this.peekAt(-1); +}; + +/** + * Returns the current length of the queue + * @return {Number} + */ +Object.defineProperty(Denque.prototype, 'length', { + get: function length() { + return this.size(); + } +}); + +/** + * Return the number of items on the list, or 0 if empty. + * @returns {number} + */ +Denque.prototype.size = function size() { + if (this._head === this._tail) return 0; + if (this._head < this._tail) return this._tail - this._head; + else return this._capacityMask + 1 - (this._head - this._tail); +}; + +/** + * Add an item at the beginning of the list. + * @param item + */ +Denque.prototype.unshift = function unshift(item) { + if (item === undefined) return this.size(); + var len = this._list.length; + this._head = (this._head - 1 + len) & this._capacityMask; + this._list[this._head] = item; + if (this._tail === this._head) this._growArray(); + if (this._head < this._tail) return this._tail - this._head; + else return this._capacityMask + 1 - (this._head - this._tail); +}; + +/** + * Remove and return the first item on the list, + * Returns undefined if the list is empty. + * @returns {*} + */ +Denque.prototype.shift = function shift() { + var head = this._head; + if (head === this._tail) return undefined; + var item = this._list[head]; + this._list[head] = undefined; + this._head = (head + 1) & this._capacityMask; + if (head < 2 && this._tail > 10000 && this._tail <= this._list.length >>> 2) this._shrinkArray(); + return item; +}; + +/** + * Add an item to the bottom of the list. + * @param item + */ +Denque.prototype.push = function push(item) { + if (item === undefined) return this.size(); + var tail = this._tail; + this._list[tail] = item; + this._tail = (tail + 1) & this._capacityMask; + if (this._tail === this._head) { + this._growArray(); + } + + if (this._head < this._tail) return this._tail - this._head; + else return this._capacityMask + 1 - (this._head - this._tail); +}; + +/** + * Remove and return the last item on the list. + * Returns undefined if the list is empty. + * @returns {*} + */ +Denque.prototype.pop = function pop() { + var tail = this._tail; + if (tail === this._head) return undefined; + var len = this._list.length; + this._tail = (tail - 1 + len) & this._capacityMask; + var item = this._list[this._tail]; + this._list[this._tail] = undefined; + if (this._head < 2 && tail > 10000 && tail <= len >>> 2) this._shrinkArray(); + return item; +}; + +/** + * Remove and return the item at the specified index from the list. + * Returns undefined if the list is empty. + * @param index + * @returns {*} + */ +Denque.prototype.removeOne = function removeOne(index) { + var i = index; + // expect a number or return undefined + if ((i !== (i | 0))) { + return void 0; + } + if (this._head === this._tail) return void 0; + var size = this.size(); + var len = this._list.length; + if (i >= size || i < -size) return void 0; + if (i < 0) i += size; + i = (this._head + i) & this._capacityMask; + var item = this._list[i]; + var k; + if (index < size / 2) { + for (k = index; k > 0; k--) { + this._list[i] = this._list[i = (i - 1 + len) & this._capacityMask]; + } + this._list[i] = void 0; + this._head = (this._head + 1 + len) & this._capacityMask; + } else { + for (k = size - 1 - index; k > 0; k--) { + this._list[i] = this._list[i = ( i + 1 + len) & this._capacityMask]; + } + this._list[i] = void 0; + this._tail = (this._tail - 1 + len) & this._capacityMask; + } + return item; +}; + +/** + * Remove number of items from the specified index from the list. + * Returns array of removed items. + * Returns undefined if the list is empty. + * @param index + * @param count + * @returns {array} + */ +Denque.prototype.remove = function remove(index, count) { + var i = index; + var removed; + var del_count = count; + // expect a number or return undefined + if ((i !== (i | 0))) { + return void 0; + } + if (this._head === this._tail) return void 0; + var size = this.size(); + var len = this._list.length; + if (i >= size || i < -size || count < 1) return void 0; + if (i < 0) i += size; + if (count === 1 || !count) { + removed = new Array(1); + removed[0] = this.removeOne(i); + return removed; + } + if (i === 0 && i + count >= size) { + removed = this.toArray(); + this.clear(); + return removed; + } + if (i + count > size) count = size - i; + var k; + removed = new Array(count); + for (k = 0; k < count; k++) { + removed[k] = this._list[(this._head + i + k) & this._capacityMask]; + } + i = (this._head + i) & this._capacityMask; + if (index + count === size) { + this._tail = (this._tail - count + len) & this._capacityMask; + for (k = count; k > 0; k--) { + this._list[i = (i + 1 + len) & this._capacityMask] = void 0; + } + return removed; + } + if (index === 0) { + this._head = (this._head + count + len) & this._capacityMask; + for (k = count - 1; k > 0; k--) { + this._list[i = (i + 1 + len) & this._capacityMask] = void 0; + } + return removed; + } + if (i < size / 2) { + this._head = (this._head + index + count + len) & this._capacityMask; + for (k = index; k > 0; k--) { + this.unshift(this._list[i = (i - 1 + len) & this._capacityMask]); + } + i = (this._head - 1 + len) & this._capacityMask; + while (del_count > 0) { + this._list[i = (i - 1 + len) & this._capacityMask] = void 0; + del_count--; + } + if (index < 0) this._tail = i; + } else { + this._tail = i; + i = (i + count + len) & this._capacityMask; + for (k = size - (count + index); k > 0; k--) { + this.push(this._list[i++]); + } + i = this._tail; + while (del_count > 0) { + this._list[i = (i + 1 + len) & this._capacityMask] = void 0; + del_count--; + } + } + if (this._head < 2 && this._tail > 10000 && this._tail <= len >>> 2) this._shrinkArray(); + return removed; +}; + +/** + * 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. + * + * @param index + * @param count + * @param {...*} [elements] + * @returns {array} + */ +Denque.prototype.splice = function splice(index, count) { + var i = index; + // expect a number or return undefined + if ((i !== (i | 0))) { + return void 0; + } + var size = this.size(); + if (i < 0) i += size; + if (i > size) return void 0; + if (arguments.length > 2) { + var k; + var temp; + var removed; + var arg_len = arguments.length; + var len = this._list.length; + var arguments_index = 2; + if (!size || i < size / 2) { + temp = new Array(i); + for (k = 0; k < i; k++) { + temp[k] = this._list[(this._head + k) & this._capacityMask]; + } + if (count === 0) { + removed = []; + if (i > 0) { + this._head = (this._head + i + len) & this._capacityMask; + } + } else { + removed = this.remove(i, count); + this._head = (this._head + i + len) & this._capacityMask; + } + while (arg_len > arguments_index) { + this.unshift(arguments[--arg_len]); + } + for (k = i; k > 0; k--) { + this.unshift(temp[k - 1]); + } + } else { + temp = new Array(size - (i + count)); + var leng = temp.length; + for (k = 0; k < leng; k++) { + temp[k] = this._list[(this._head + i + count + k) & this._capacityMask]; + } + if (count === 0) { + removed = []; + if (i != size) { + this._tail = (this._head + i + len) & this._capacityMask; + } + } else { + removed = this.remove(i, count); + this._tail = (this._tail - leng + len) & this._capacityMask; + } + while (arguments_index < arg_len) { + this.push(arguments[arguments_index++]); + } + for (k = 0; k < leng; k++) { + this.push(temp[k]); + } + } + return removed; + } else { + return this.remove(i, count); + } +}; + +/** + * Soft clear - does not reset capacity. + */ +Denque.prototype.clear = function clear() { + this._head = 0; + this._tail = 0; +}; + +/** + * Returns true or false whether the list is empty. + * @returns {boolean} + */ +Denque.prototype.isEmpty = function isEmpty() { + return this._head === this._tail; +}; + +/** + * Returns an array of all queue items. + * @returns {Array} + */ +Denque.prototype.toArray = function toArray() { + return this._copyArray(false); +}; + +/** + * ------------- + * INTERNALS + * ------------- + */ + +/** + * Fills the queue with items from an array + * For use in the constructor + * @param array + * @private + */ +Denque.prototype._fromArray = function _fromArray(array) { + for (var i = 0; i < array.length; i++) this.push(array[i]); +}; + +/** + * + * @param fullCopy + * @returns {Array} + * @private + */ +Denque.prototype._copyArray = function _copyArray(fullCopy) { + var newArray = []; + var list = this._list; + var len = list.length; + var i; + if (fullCopy || this._head > this._tail) { + for (i = this._head; i < len; i++) newArray.push(list[i]); + for (i = 0; i < this._tail; i++) newArray.push(list[i]); + } else { + for (i = this._head; i < this._tail; i++) newArray.push(list[i]); + } + return newArray; +}; + +/** + * Grows the internal list array. + * @private + */ +Denque.prototype._growArray = function _growArray() { + if (this._head) { + // copy existing data, head to end, then beginning to tail. + this._list = this._copyArray(true); + this._head = 0; + } + + // head is at 0 and array is now full, safe to extend + this._tail = this._list.length; + + this._list.length *= 2; + this._capacityMask = (this._capacityMask << 1) | 1; +}; + +/** + * Shrinks the internal list array. + * @private + */ +Denque.prototype._shrinkArray = function _shrinkArray() { + this._list.length >>>= 1; + this._capacityMask >>>= 1; +}; + + +module.exports = Denque; diff --git a/node_modules/denque/package.json b/node_modules/denque/package.json new file mode 100644 index 0000000..a096ef3 --- /dev/null +++ b/node_modules/denque/package.json @@ -0,0 +1,84 @@ +{ + "_from": "denque@^1.4.1", + "_id": "denque@1.4.1", + "_inBundle": false, + "_integrity": "sha512-OfzPuSZKGcgr96rf1oODnfjqBFmr1DVoc/TrItj3Ohe0Ah1C5WX5Baquw/9U9KovnQ88EqmJbD66rKYUQYN1tQ==", + "_location": "/denque", + "_phantomChildren": {}, + "_requested": { + "type": "range", + "registry": true, + "raw": "denque@^1.4.1", + "name": "denque", + "escapedName": "denque", + "rawSpec": "^1.4.1", + "saveSpec": null, + "fetchSpec": "^1.4.1" + }, + "_requiredBy": [ + "/mongodb" + ], + "_resolved": "https://registry.npmjs.org/denque/-/denque-1.4.1.tgz", + "_shasum": "6744ff7641c148c3f8a69c307e51235c1f4a37cf", + "_spec": "denque@^1.4.1", + "_where": "/home/pruss/Dev/3-minute-website/node_modules/mongodb", + "author": { + "name": "Invertase", + "email": "oss@invertase.io", + "url": "http://github.com/invertase/" + }, + "bugs": { + "url": "https://github.com/invertase/denque/issues" + }, + "bundleDependencies": false, + "contributors": [ + { + "name": "Mike Diarmid", + "email": "mike@invertase.io", + "url": "Salakar" + } + ], + "deprecated": false, + "description": "The fastest javascript implementation of a double-ended queue. Maintains compatability with deque.", + "devDependencies": { + "benchmark": "^2.1.4", + "coveralls": "^2.13.3", + "double-ended-queue": "^2.1.0-0", + "istanbul": "^0.4.5", + "mocha": "^3.5.3", + "typescript": "^3.4.1" + }, + "engines": { + "node": ">=0.10" + }, + "homepage": "https://github.com/invertase/denque#readme", + "keywords": [ + "data-structure", + "data-structures", + "queue", + "double", + "end", + "ended", + "deque", + "denque", + "double-ended-queue" + ], + "license": "Apache-2.0", + "main": "index.js", + "name": "denque", + "repository": { + "type": "git", + "url": "git+https://github.com/invertase/denque.git" + }, + "scripts": { + "benchmark_2mil": "node benchmark/two_million", + "benchmark_remove": "node benchmark/remove", + "benchmark_removeOne": "node benchmark/removeOne", + "benchmark_splice": "node benchmark/splice", + "benchmark_thousand": "node benchmark/thousand", + "coveralls": "cat ./coverage/lcov.info | coveralls", + "test": "istanbul cover --report lcov _mocha && npm run typescript", + "typescript": "tsc --project ./test/type/tsconfig.json" + }, + "version": "1.4.1" +} -- cgit v1.2.3