@jesec/flood 0.0.0-master.fe01c07 → 0.0.0-master.ff6e43c

package/node_modules/jsbn/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "jsbn",
+  "version": "1.1.0",
+  "description": "The jsbn library is a fast, portable implementation of large-number math in pure JavaScript, enabling public-key crypto and other applications on desktop and mobile browsers.",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andyperlitch/jsbn.git"
+  },
+  "keywords": [
+    "biginteger",
+    "bignumber",
+    "big",
+    "integer"
+  ],
+  "author": "Tom Wu",
+  "license": "MIT"
+}

package/node_modules/jsbn/test/es6-import.js

@@ -0,0 +1,3 @@
+import {BigInteger} from '../';
+
+console.log(typeof BigInteger)

package/node_modules/lazy/.npmignore

@@ -0,0 +1 @@
+*.swp

package/node_modules/lazy/README.md

@@ -0,0 +1,185 @@
+Lazy lists for node
+===================
+
+
+# Table of contents:
+
+[Introduction](#Introduction)
+  
+[Documentation](#Documentation)
+
+<a name="Introduction" />
+# Introduction
+Lazy comes really handy when you need to treat a stream of events like a list.
+The best use case currently is returning a lazy list from an asynchronous
+function, and having data pumped into it via events. In asynchronous
+programming you can't just return a regular list because you don't yet have
+data for it. The usual solution so far has been to provide a callback that gets
+called when the data is available. But doing it this way you lose the power of
+chaining functions and creating pipes, which leads to not that nice interfaces.
+(See the 2nd example below to see how it improved the interface in one of my
+modules.)
+
+Check out this toy example, first you create a Lazy object:
+```javascript
+    var Lazy = require('lazy');
+
+    var lazy = new Lazy;
+    lazy
+      .filter(function (item) {
+        return item % 2 == 0
+      })
+      .take(5)
+      .map(function (item) {
+        return item*2;
+      })
+      .join(function (xs) {
+        console.log(xs);
+      });
+```
+
+This code says that 'lazy' is going to be a lazy list that filters even
+numbers, takes first five of them, then multiplies all of them by 2, and then
+calls the join function (think of join as in threads) on the final list.
+
+And now you can emit 'data' events with data in them at some point later,
+```javascript
+    [0,1,2,3,4,5,6,7,8,9,10].forEach(function (x) {
+      lazy.emit('data', x);
+    });
+```
+
+The output will be produced by the 'join' function, which will output the
+expected [0, 4, 8, 12, 16].
+
+And here is a real-world example. Some time ago I wrote a hash database for
+node.js called node-supermarket (think of key-value store except greater). Now
+it had a similar interface as a list, you could .forEach on the stored
+elements, .filter them, etc. But being asynchronous in nature it lead to the
+following code, littered with callbacks and temporary lists:
+```javascript
+    var Store = require('supermarket');
+
+    var db = new Store({ filename : 'users.db', json : true });
+
+    var users_over_20 = [];
+    db.filter(
+      function (user, meta) {
+        // predicate function
+        return meta.age > 20;
+      },
+      function (err, user, meta) {
+        // function that gets executed when predicate is true
+        if (users_over_20.length < 5)
+          users_over_20.push(meta);
+      },
+      function () {
+        // done function, called when all records have been filtered
+
+        // now do something with users_over_20
+      }
+    )
+```
+This code selects first five users who are over 20 years old and stores them
+in users_over_20.
+
+But now we changed the node-supermarket interface to return lazy lists, and
+the code became:
+```javascript
+    var Store = require('supermarket');
+
+    var db = new Store({ filename : 'users.db', json : true });
+
+    db.filter(function (user, meta) {
+        return meta.age > 20;
+      })
+      .take(5)
+      .join(function (xs) {
+        // xs contains the first 5 users who are over 20!
+      });
+```
+This is so much nicer!
+
+Here is the latest feature: .lines. Given a stream of data that has \n's in it,
+.lines converts that into a list of lines.
+
+Here is an example from node-iptables that I wrote the other week,
+```javascript
+    var Lazy = require('lazy');
+    var spawn = require('child_process').spawn;
+    var iptables = spawn('iptables', ['-L', '-n', '-v']);
+
+    Lazy(iptables.stdout)
+        .lines
+        .map(String)
+        .skip(2) // skips the two lines that are iptables header
+        .map(function (line) {
+            // packets, bytes, target, pro, opt, in, out, src, dst, opts
+            var fields = line.trim().split(/\s+/, 9);
+            return {
+                parsed : {
+                    packets : fields[0],
+                    bytes : fields[1],
+                    target : fields[2],
+                    protocol : fields[3],
+                    opt : fields[4],
+                    in : fields[5],
+                    out : fields[6],
+                    src : fields[7],
+                    dst : fields[8]
+                },
+                raw : line.trim()
+            };
+        });
+```
+This example takes the `iptables -L -n -v` command and uses .lines on its output.
+Then it .skip's two lines from input and maps a function on all other lines that
+creates a data structure from the output.
+
+<a name="Documentation" />
+# Documentation
+
+Supports the following operations:
+
+* lazy.filter(f)
+* lazy.forEach(f)
+* lazy.map(f)
+* lazy.take(n)
+* lazy.takeWhile(f)
+* lazy.bucket(init, f)
+* lazy.lines
+* lazy.sum(f)
+* lazy.product(f)
+* lazy.foldr(op, i, f)
+* lazy.skip(n)
+* lazy.head(f)
+* lazy.tail(f)
+* lazy.join(f)
+
+The Lazy object itself has a .range property for generating all the possible ranges.
+
+Here are several examples:
+
+* Lazy.range('10..') - infinite range starting from 10
+* Lazy.range('(10..') - infinite range starting from 11
+* Lazy.range(10) - range from 0 to 9
+* Lazy.range(-10, 10) - range from -10 to 9 (-10, -9, ... 0, 1, ... 9)
+* Lazy.range(-10, 10, 2) - range from -10 to 8, skipping every 2nd element (-10, -8, ... 0, 2, 4, 6, 8)
+* Lazy.range(10, 0, 2) - reverse range from 10 to 1, skipping every 2nd element (10, 8, 6, 4, 2)
+* Lazy.range(10, 0) - reverse range from 10 to 1
+* Lazy.range('5..50') - range from 5 to 49
+* Lazy.range('50..44') - range from 50 to 45
+* Lazy.range('1,1.1..4') - range from 1 to 4 with increment of 0.1 (1, 1.1, 1.2, ... 3.9)
+* Lazy.range('4,3.9..1') - reverse range from 4 to 1 with decerement of 0.1
+* Lazy.range('[1..10]') - range from 1 to 10 (all inclusive)
+* Lazy.range('[10..1]') - range from 10 to 1 (all inclusive)
+* Lazy.range('[1..10)') - range grom 1 to 9
+* Lazy.range('[10..1)') - range from 10 to 2
+* Lazy.range('(1..10]') - range from 2 to 10
+* Lazy.range('(10..1]') - range from 9 to 1
+* Lazy.range('(1..10)') - range from 2 to 9
+* Lazy.range('[5,10..50]') - range from 5 to 50 with a step of 5 (all inclusive)
+
+Then you can use other lazy functions on these ranges.
+
+

package/node_modules/lazy/lazy.js

@@ -0,0 +1,349 @@
+var EventEmitter = require('events').EventEmitter;
+var util = require('util');
+var stream = require('stream');
+
+function Lazy(em, opts) {
+    if (!(this instanceof Lazy)) return new Lazy(em, opts);
+    EventEmitter.call(this);
+    var self = this;
+
+
+    self.once = function (name, f) {
+        self.on(name, function g () {
+            self.removeListener(name, g);
+            f.apply(this, arguments);
+        });
+    }
+
+    if (!opts) opts = {};
+    var dataName = opts.data || 'data';
+    var pipeName = opts.pipe || 'pipe';
+    var endName = opts.pipe || 'end';
+
+    if (pipeName != endName) {
+        var piped = false;
+        self.once(pipeName, function () { piped = true });
+        self.once(endName, function () {
+            if (!piped) self.emit(pipeName);
+        });
+    }
+
+    self.push = function (x) {
+        self.emit(dataName, x);
+    }
+
+    self.end = function () {
+        self.emit(endName);
+    }
+
+    if (em && em.on) {
+        em.on(endName, function () {
+            self.emit(endName);
+        });
+        self.on(pipeName, function () {
+            em.emit(pipeName);
+        });
+        // Check for v0.10 or Greater (Stream2 has Duplex type)
+        if (stream.Duplex && em instanceof(stream)) {
+            em.on('readable', function () {
+                var x = em.read();
+                self.emit(dataName, x);
+            });
+        } else {
+            // Old Stream1 or Event support
+            em.on(dataName, function (x) {
+                self.emit(dataName, x);
+            });
+        }
+    }
+
+    function newLazy (g, h, l) {
+        if (!g) {
+            g = function () {
+                return true;
+            };
+        }
+        if (!h) {
+            h = function (x) {
+                return x;
+            };
+        }
+        var lazy = new Lazy(null, opts, l);
+        self.on(dataName, function (x, y) {
+            if (g.call(lazy, x)) {
+                lazy.emit(dataName, h(x), y);
+            }
+        });
+        self.once(pipeName, function () {
+            lazy.emit(pipeName);
+        });
+        return lazy;
+    }
+
+    self.filter = function (f) {
+        return newLazy(function (x) {
+            return f(x);
+        });
+    }
+
+    self.forEach = function (f) {
+        return newLazy(function (x) {
+            f(x);
+            return true;
+        });
+    }
+
+    self.map = function (f) {
+        return newLazy(
+            function () { return true },
+            function (x) { return f(x) }
+        );
+    }
+
+    self.head = function (f) {
+        var lazy = newLazy();
+        lazy.on(dataName, function g (x) {
+            f(x)
+            lazy.removeListener(dataName, g)
+        })
+    }
+
+    self.tail = function () {
+        var skip = true;
+        return newLazy(function () {
+            if (skip) {
+                skip = false;
+                return false;
+            }
+            return true;
+        });
+    }
+
+    self.skip = function (n) {
+        return newLazy(function () {
+            if (n > 0) {
+                n--;
+                return false;
+            }
+            return true;
+        });
+    }
+
+    self.take = function (n) {
+        return newLazy(function () {
+            if (n == 0) self.emit(pipeName);
+            return n-- > 0;
+        });
+    }
+
+    self.takeWhile = function (f) {
+        var cond = true;
+        return newLazy(function (x) {
+            if (cond && f(x)) return true;
+            cond = false;
+            self.emit(pipeName);
+            return false;
+        });
+    }
+
+    self.foldr = function (op, i, f) {
+        var acc = i;
+        var lazy = newLazy();
+        lazy.on(dataName, function g (x) {
+            acc = op(x, acc);
+        });
+        lazy.once(pipeName, function () {
+            f(acc);
+        });
+    }
+
+    self.sum = function (f) {
+        return self.foldr(function (x, acc) { return x + acc }, 0, f);
+    }
+
+    self.product = function (f) {
+        return self.foldr(function (x, acc) { return x*acc }, 1, f);
+    }
+
+    self.join = function (f) {
+        var data = []
+        var lazy = newLazy(function (x) {
+            data.push(x);
+            return true;
+        });
+        lazy.once(pipeName, function () { f(data) });
+        return self;
+    }
+
+    self.bucket = function (init, f) {
+        var lazy = new Lazy(null, opts);
+        var yieldTo = function (x) {
+            lazy.emit(dataName, x);
+        };
+
+        var acc = init;
+
+        self.on(dataName, function (x) {
+            acc = f.call(yieldTo, acc, x);
+        });
+
+        self.once(pipeName, function () {
+            lazy.emit(pipeName);
+        });
+
+        // flush on end event
+        self.once(endName, function () {
+            var finalBuffer = mergeBuffers(acc);
+            if (finalBuffer) {
+                yieldTo(finalBuffer);
+            }
+        });
+
+        return lazy;
+    }
+
+    // Streams that use this should emit strings or buffers only
+    self.__defineGetter__('lines', function () {
+        return self.bucket([], function (chunkArray, chunk) {
+            var newline = '\n'.charCodeAt(0), lastNewLineIndex = 0;
+            if (typeof chunk === 'string') chunk = new Buffer(chunk);
+        if (chunk){
+            	for (var i = 0; i < chunk.length; i++) {
+                	if (chunk[i] === newline) {
+                    	// If we have content from the current chunk to append to our buffers, do it.
+                    		if (i > 0) {
+                        		chunkArray.push(chunk.slice(lastNewLineIndex, i));
+                    		}
+
+                    		// Wrap all our buffers and emit it.
+                    		this(mergeBuffers(chunkArray));
+                    		lastNewLineIndex = i + 1;
+                	}
+            }
+	    }
+
+            if (lastNewLineIndex > 0) {
+                // New line found in the chunk, push the remaining part of the buffer.
+                if (lastNewLineIndex < chunk.length) {
+                    chunkArray.push(chunk.slice(lastNewLineIndex));
+                }
+            } else {
+                // No new line found, push the whole buffer.
+                if (chunk && chunk.length) {
+                    chunkArray.push(chunk);
+                }
+            }
+            return chunkArray;
+        });
+    });
+}
+
+Lazy.range = function () {
+    var args = arguments;
+    var step = 1;
+    var infinite = false;
+
+    if (args.length == 1 && typeof args[0] == 'number') {
+        var i = 0, j = args[0];
+    }
+    else if (args.length == 1 && typeof args[0] == 'string') { // 'start[,next]..[end]'
+        var arg = args[0];
+        var startOpen = false, endClosed = false;
+        if (arg[0] == '(' || arg[0] == '[') {
+            if (arg[0] == '(') startOpen = true;
+            arg = arg.slice(1);
+        }
+        if (arg.slice(-1) == ']') endClosed = true;
+
+        var parts = arg.split('..');
+        if (parts.length != 2)
+            throw new Error("single argument range takes 'start..' or 'start..end' or 'start,next..end'");
+
+        if (parts[1] == '') { // 'start..'
+            var i = parts[0];
+            infinite = true;
+        }
+        else { // 'start[,next]..end'
+            var progression = parts[0].split(',');
+            if (progression.length == 1) { // start..end
+                var i = parts[0], j = parts[1];
+            }
+            else { // 'start,next..end'
+                var i = progression[0], j = parts[1];
+                step = Math.abs(progression[1]-i);
+            }
+        }
+
+        i = parseInt(i, 10);
+        j = parseInt(j, 10);
+
+        if (startOpen) {
+            if (infinite || i < j) i++;
+            else i--;
+        }
+
+        if (endClosed) {
+            if (i < j) j++;
+            else j--;
+        }
+    }
+    else if (args.length == 2 || args.length == 3) { // start, end[, step]
+        var i = args[0], j = args[1];
+        if (args.length == 3) {
+            var step = args[2];
+        }
+    }
+    else {
+        throw new Error("range takes 1, 2 or 3 arguments");
+    }
+    var lazy = new Lazy;
+    var stopInfinite = false;
+    lazy.on('pipe', function () {
+        stopInfinite = true;
+    });
+    if (infinite) {
+        process.nextTick(function g () {
+            if (stopInfinite) return;
+            lazy.emit('data', i++);
+            process.nextTick(g);
+        });
+    }
+    else {
+        process.nextTick(function () {
+            if (i < j) {
+                for (; i<j; i+=step) {
+                    lazy.emit('data', i)
+                }
+            }
+            else {
+                for (; i>j; i-=step) {
+                    lazy.emit('data', i)
+                }
+            }
+            lazy.emit('end');
+        });
+    }
+    return lazy;
+}
+
+var mergeBuffers = function mergeBuffers(buffers) {
+  // We expect buffers to be a non-empty Array
+  if (!buffers || !Array.isArray(buffers) || !buffers.length) return;
+
+  var finalBufferLength, finalBuffer, currentBuffer, currentSize = 0;
+
+  // Sum all the buffers lengths
+  finalBufferLength = buffers.reduce(function(left, right) { return (left.length||left) + (right.length||right); }, 0);
+  finalBuffer = new Buffer(finalBufferLength);
+  while(buffers.length) {
+    currentBuffer = buffers.shift();
+    currentBuffer.copy(finalBuffer, currentSize);
+    currentSize += currentBuffer.length;
+  }
+
+  return finalBuffer;
+}
+
+
+util.inherits(Lazy, EventEmitter);
+module.exports = Lazy;