eoapi-cdk 5.4.1 → 6.0.1

package/node_modules/typedarray/readme.markdown

@@ -0,0 +1,61 @@
+# typedarray
+
+TypedArray polyfill ripped from [this
+module](https://raw.github.com/inexorabletash/polyfill).
+
+[![build status](https://secure.travis-ci.org/substack/typedarray.png)](http://travis-ci.org/substack/typedarray)
+
+[![testling badge](https://ci.testling.com/substack/typedarray.png)](https://ci.testling.com/substack/typedarray)
+
+# example
+
+``` js
+var Uint8Array = require('typedarray').Uint8Array;
+var ua = new Uint8Array(5);
+ua[1] = 256 + 55;
+console.log(ua[1]);
+```
+
+output:
+
+```
+55
+```
+
+# methods
+
+``` js
+var TA = require('typedarray')
+```
+
+The `TA` object has the following constructors:
+
+* TA.ArrayBuffer
+* TA.DataView
+* TA.Float32Array
+* TA.Float64Array
+* TA.Int8Array
+* TA.Int16Array
+* TA.Int32Array
+* TA.Uint8Array
+* TA.Uint8ClampedArray
+* TA.Uint16Array
+* TA.Uint32Array
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install typedarray
+```
+
+To use this module in the browser, compile with
+[browserify](http://browserify.org)
+or download a UMD build from browserify CDN:
+
+http://wzrd.in/standalone/typedarray@latest
+
+# license
+
+MIT

package/node_modules/typedarray/test/server/undef_globals.js

@@ -0,0 +1,19 @@
+var test = require('tape');
+var vm = require('vm');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/../../index.js', 'utf8');
+
+test('u8a without globals', function (t) {
+    var c = {
+        module: { exports: {} },
+    };
+    c.exports = c.module.exports;
+    vm.runInNewContext(src, c);
+    var TA = c.module.exports;
+    var ua = new(TA.Uint8Array)(5);
+    
+    t.equal(ua.length, 5);
+    ua[1] = 256 + 55;
+    t.equal(ua[1], 55);
+    t.end();
+});

package/node_modules/typedarray/test/tarray.js

@@ -0,0 +1,10 @@
+var TA = require('../');
+var test = require('tape');
+
+test('tiny u8a test', function (t) {
+    var ua = new(TA.Uint8Array)(5);
+    t.equal(ua.length, 5);
+    ua[1] = 256 + 55;
+    t.equal(ua[1], 55);
+    t.end();
+});

package/node_modules/unique-stream/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Eugene Ware
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/unique-stream/README.md

@@ -0,0 +1,134 @@
+# unique-stream
+
+node.js through stream that emits a unique stream of objects based on criteria
+
+[![Build Status](https://travis-ci.org/eugeneware/unique-stream.svg?branch=master)](https://travis-ci.org/eugeneware/unique-stream)
+[![Coverage Status](https://coveralls.io/repos/eugeneware/unique-stream/badge.svg?branch=master&service=github)](https://coveralls.io/github/eugeneware/unique-stream?branch=master)
+
+## Installation
+
+Install via [npm](https://www.npmjs.com/):
+
+```
+$ npm install unique-stream
+```
+
+## Examples
+
+### Dedupe a ReadStream based on JSON.stringify:
+
+``` js
+var unique = require('unique-stream')
+  , Stream = require('stream');
+
+// return a stream of 3 identical objects
+function makeStreamOfObjects() {
+  var s = new Stream;
+  s.readable = true;
+  var count = 3;
+  for (var i = 0; i < 3; i++) {
+    setImmediate(function () {
+      s.emit('data', { name: 'Bob', number: 123 });
+      --count || end();
+    });
+  }
+
+  function end() {
+    s.emit('end');
+  }
+
+  return s;
+}
+
+// Will only print out one object as the rest are dupes. (Uses JSON.stringify)
+makeStreamOfObjects()
+  .pipe(unique())
+  .on('data', console.log);
+
+```
+
+### Dedupe a ReadStream based on an object property:
+
+``` js
+// Use name as the key field to dedupe on. Will only print one object
+makeStreamOfObjects()
+  .pipe(unique('name'))
+  .on('data', console.log);
+```
+
+### Dedupe a ReadStream based on a custom function:
+
+``` js
+// Use a custom function to dedupe on. Use the 'number' field. Will only print one object.
+makeStreamOfObjects()
+  .pipe(function (data) {
+    return data.number;
+  })
+  .on('data', console.log);
+```
+
+## Dedupe multiple streams
+
+The reason I wrote this was to dedupe multiple object streams:
+
+``` js
+var aggregator = unique();
+
+// Stream 1
+makeStreamOfObjects()
+  .pipe(aggregator);
+
+// Stream 2
+makeStreamOfObjects()
+  .pipe(aggregator);
+
+// Stream 3
+makeStreamOfObjects()
+  .pipe(aggregator);
+
+aggregator.on('data', console.log);
+```
+
+## Use a custom store to record keys that have been encountered
+
+By default a set is used to store keys encountered so far, in order to check new ones for
+uniqueness. You can supply your own store instead, providing it supports the add(key) and 
+has(key) methods. This could allow you to use a persistent store so that already encountered
+objects are not re-streamed when node is reloaded.
+
+``` js
+var keyStore = {
+  store: {},
+
+  add: function(key) {
+    this.store[key] = true;
+  },
+
+  has: function(key) {
+    return this.store[key] !== undefined;
+  }
+};
+    
+makeStreamOfObjects()
+  .pipe(unique('name', keyStore))
+  .on('data', console.log);
+```
+
+## Contributing
+
+unique-stream is an **OPEN Open Source Project**. This means that:
+
+> Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.
+
+See the [CONTRIBUTING.md](https://github.com/eugeneware/unique-stream/blob/master/CONTRIBUTING.md) file for more details.
+
+### Contributors
+
+unique-stream is only possible due to the excellent work of the following contributors:
+
+<table><tbody>
+<tr><th align="left">Eugene Ware</th><td><a href="https://github.com/eugeneware">GitHub/eugeneware</a></td></tr>
+<tr><th align="left">Craig Ambrose</th><td><a href="https://github.com/craigambrose">GitHub/craigambrose</a></td></tr>
+<tr><th align="left">Shinnosuke Watanabe</th><td><a href="https://github.com/shinnn">GitHub/shinnn</a></td></tr>
+<tr><th align="left">Rouven Weßling</th><td><a href="https://github.com/realityking">GitHub/realityking</a></td></tr>
+</tbody></table>

package/node_modules/unique-stream/index.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var filter = require('through2-filter').obj;
+var stringify = require("json-stable-stringify-without-jsonify");
+
+var ES6Set;
+if (typeof global.Set === 'function') {
+  ES6Set = global.Set;
+} else {
+  ES6Set = function() {
+    this.keys = [];
+    this.has = function(val) {
+      return this.keys.indexOf(val) !== -1;
+    },
+    this.add = function(val) {
+      this.keys.push(val);
+    }
+  }
+}
+
+function prop(propName) {
+  return function (data) {
+    return data[propName];
+  };
+}
+
+module.exports = unique;
+function unique(propName, keyStore) {
+  keyStore = keyStore || new ES6Set();
+
+  var keyfn = stringify;
+  if (typeof propName === 'string') {
+    keyfn = prop(propName);
+  } else if (typeof propName === 'function') {
+    keyfn = propName;
+  }
+
+  return filter(function (data) {
+    var key = keyfn(data);
+
+    if (keyStore.has(key)) {
+      return false;
+    }
+
+    keyStore.add(key);
+    return true;
+  });
+}

package/node_modules/unique-stream/node_modules/through2/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+**Copyright (c) Rod Vagg (the "Original Author") and additional contributors**
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/unique-stream/node_modules/through2/README.md

@@ -0,0 +1,134 @@
+# through2
+
+[![NPM](https://nodei.co/npm/through2.png?downloads&downloadRank)](https://nodei.co/npm/through2/)
+
+**A tiny wrapper around Node streams.Transform (Streams2/3) to avoid explicit subclassing noise**
+
+Inspired by [Dominic Tarr](https://github.com/dominictarr)'s [through](https://github.com/dominictarr/through) in that it's so much easier to make a stream out of a function than it is to set up the prototype chain properly: `through(function (chunk) { ... })`.
+
+Note: As 2.x.x this module starts using **Streams3** instead of Stream2. To continue using a Streams2 version use `npm install through2@0` to fetch the latest version of 0.x.x. More information about Streams2 vs Streams3 and recommendations see the article **[Why I don't use Node's core 'stream' module](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html)**.
+
+```js
+fs.createReadStream('ex.txt')
+  .pipe(through2(function (chunk, enc, callback) {
+    for (var i = 0; i < chunk.length; i++)
+      if (chunk[i] == 97)
+        chunk[i] = 122 // swap 'a' for 'z'
+
+    this.push(chunk)
+
+    callback()
+   }))
+  .pipe(fs.createWriteStream('out.txt'))
+  .on('finish', () => doSomethingSpecial())
+```
+
+Or object streams:
+
+```js
+var all = []
+
+fs.createReadStream('data.csv')
+  .pipe(csv2())
+  .pipe(through2.obj(function (chunk, enc, callback) {
+    var data = {
+        name    : chunk[0]
+      , address : chunk[3]
+      , phone   : chunk[10]
+    }
+    this.push(data)
+
+    callback()
+  }))
+  .on('data', (data) => {
+    all.push(data)
+  })
+  .on('end', () => {
+    doSomethingSpecial(all)
+  })
+```
+
+Note that `through2.obj(fn)` is a convenience wrapper around `through2({ objectMode: true }, fn)`.
+
+## API
+
+<b><code>through2([ options, ] [ transformFunction ] [, flushFunction ])</code></b>
+
+Consult the **[stream.Transform](http://nodejs.org/docs/latest/api/stream.html#stream_class_stream_transform)** documentation for the exact rules of the `transformFunction` (i.e. `this._transform`) and the optional `flushFunction` (i.e. `this._flush`).
+
+### options
+
+The options argument is optional and is passed straight through to `stream.Transform`. So you can use `objectMode:true` if you are processing non-binary streams (or just use `through2.obj()`).
+
+The `options` argument is first, unlike standard convention, because if I'm passing in an anonymous function then I'd prefer for the options argument to not get lost at the end of the call:
+
+```js
+fs.createReadStream('/tmp/important.dat')
+  .pipe(through2({ objectMode: true, allowHalfOpen: false },
+    (chunk, enc, cb) => {
+      cb(null, 'wut?') // note we can use the second argument on the callback
+                       // to provide data as an alternative to this.push('wut?')
+    }
+  )
+  .pipe(fs.createWriteStream('/tmp/wut.txt'))
+```
+
+### transformFunction
+
+The `transformFunction` must have the following signature: `function (chunk, encoding, callback) {}`. A minimal implementation should call the `callback` function to indicate that the transformation is done, even if that transformation means discarding the chunk.
+
+To queue a new chunk, call `this.push(chunk)`&mdash;this can be called as many times as required before the `callback()` if you have multiple pieces to send on.
+
+Alternatively, you may use `callback(err, chunk)` as shorthand for emitting a single chunk or an error.
+
+If you **do not provide a `transformFunction`** then you will get a simple pass-through stream.
+
+### flushFunction
+
+The optional `flushFunction` is provided as the last argument (2nd or 3rd, depending on whether you've supplied options) is called just prior to the stream ending. Can be used to finish up any processing that may be in progress.
+
+```js
+fs.createReadStream('/tmp/important.dat')
+  .pipe(through2(
+    (chunk, enc, cb) => cb(null, chunk), // transform is a noop
+    function (cb) { // flush function
+      this.push('tacking on an extra buffer to the end');
+      cb();
+    }
+  ))
+  .pipe(fs.createWriteStream('/tmp/wut.txt'));
+```
+
+<b><code>through2.ctor([ options, ] transformFunction[, flushFunction ])</code></b>
+
+Instead of returning a `stream.Transform` instance, `through2.ctor()` returns a **constructor** for a custom Transform. This is useful when you want to use the same transform logic in multiple instances.
+
+```js
+var FToC = through2.ctor({objectMode: true}, function (record, encoding, callback) {
+  if (record.temp != null && record.unit == "F") {
+    record.temp = ( ( record.temp - 32 ) * 5 ) / 9
+    record.unit = "C"
+  }
+  this.push(record)
+  callback()
+})
+
+// Create instances of FToC like so:
+var converter = new FToC()
+// Or:
+var converter = FToC()
+// Or specify/override options when you instantiate, if you prefer:
+var converter = FToC({objectMode: true})
+```
+
+## See Also
+
+  - [through2-map](https://github.com/brycebaril/through2-map) - Array.prototype.map analog for streams.
+  - [through2-filter](https://github.com/brycebaril/through2-filter) - Array.prototype.filter analog for streams.
+  - [through2-reduce](https://github.com/brycebaril/through2-reduce) - Array.prototype.reduce analog for streams.
+  - [through2-spy](https://github.com/brycebaril/through2-spy) - Wrapper for simple stream.PassThrough spies.
+  - the [mississippi stream utility collection](https://github.com/maxogden/mississippi) includes `through2` as well as many more useful stream modules similar to this one
+
+## License
+
+**through2** is Copyright (c) Rod Vagg [@rvagg](https://twitter.com/rvagg) and additional contributors and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.

package/node_modules/unique-stream/node_modules/through2/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "through2",
+  "version": "2.0.5",
+  "description": "A tiny wrapper around Node streams2 Transform to avoid explicit subclassing noise",
+  "main": "through2.js",
+  "scripts": {
+    "test": "node test/test.js | faucet"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rvagg/through2.git"
+  },
+  "keywords": [
+    "stream",
+    "streams2",
+    "through",
+    "transform"
+  ],
+  "author": "Rod Vagg <r@va.gg> (https://github.com/rvagg)",
+  "license": "MIT",
+  "dependencies": {
+    "readable-stream": "~2.3.6",
+    "xtend": "~4.0.1"
+  },
+  "devDependencies": {
+    "bl": "~2.0.1",
+    "faucet": "0.0.1",
+    "nyc": "~13.1.0",
+    "safe-buffer": "~5.1.2",
+    "stream-spigot": "~3.0.6",
+    "tape": "~4.9.1"
+  }
+}

package/node_modules/unique-stream/node_modules/through2/through2.js

@@ -0,0 +1,96 @@
+var Transform = require('readable-stream').Transform
+  , inherits  = require('util').inherits
+  , xtend     = require('xtend')
+
+function DestroyableTransform(opts) {
+  Transform.call(this, opts)
+  this._destroyed = false
+}
+
+inherits(DestroyableTransform, Transform)
+
+DestroyableTransform.prototype.destroy = function(err) {
+  if (this._destroyed) return
+  this._destroyed = true
+  
+  var self = this
+  process.nextTick(function() {
+    if (err)
+      self.emit('error', err)
+    self.emit('close')
+  })
+}
+
+// a noop _transform function
+function noop (chunk, enc, callback) {
+  callback(null, chunk)
+}
+
+
+// create a new export function, used by both the main export and
+// the .ctor export, contains common logic for dealing with arguments
+function through2 (construct) {
+  return function (options, transform, flush) {
+    if (typeof options == 'function') {
+      flush     = transform
+      transform = options
+      options   = {}
+    }
+
+    if (typeof transform != 'function')
+      transform = noop
+
+    if (typeof flush != 'function')
+      flush = null
+
+    return construct(options, transform, flush)
+  }
+}
+
+
+// main export, just make me a transform stream!
+module.exports = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(options)
+
+  t2._transform = transform
+
+  if (flush)
+    t2._flush = flush
+
+  return t2
+})
+
+
+// make me a reusable prototype that I can `new`, or implicitly `new`
+// with a constructor call
+module.exports.ctor = through2(function (options, transform, flush) {
+  function Through2 (override) {
+    if (!(this instanceof Through2))
+      return new Through2(override)
+
+    this.options = xtend(options, override)
+
+    DestroyableTransform.call(this, this.options)
+  }
+
+  inherits(Through2, DestroyableTransform)
+
+  Through2.prototype._transform = transform
+
+  if (flush)
+    Through2.prototype._flush = flush
+
+  return Through2
+})
+
+
+module.exports.obj = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(xtend({ objectMode: true, highWaterMark: 16 }, options))
+
+  t2._transform = transform
+
+  if (flush)
+    t2._flush = flush
+
+  return t2
+})

package/node_modules/unique-stream/node_modules/through2-filter/LICENSE

@@ -0,0 +1,9 @@
+(The MIT License)
+
+Copyright (c) Bryce B. Baril <bryce@ravenwall.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/unique-stream/node_modules/through2-filter/README.md

@@ -0,0 +1,79 @@
+through2-filter
+===============
+
+[![NPM](https://nodei.co/npm/through2-filter.png)](https://nodei.co/npm/through2-filter/)
+
+This is a super thin wrapper around [through2](http://npm.im/through2) that works like `Array.prototype.filter` but for streams.
+
+For when through2 is just too verbose :wink:
+
+Note you will **NOT** be able to alter the content of the chunks. This is intended for filtering only. If you want to modify the stream content, use either `through2` or `through2-map`.
+
+```js
+var filter = require("through2-filter")
+
+var skip = filter(function (chunk) {
+  // skip buffers longer than 100
+  return chunk.length < 100
+})
+
+// vs. with through2:
+var skip = through2(function (chunk, encoding, callback) {
+  // skip buffers longer than 100
+  if (chunk.length < 100) this.push(chunk)
+  return callback()
+})
+
+// Then use your filter:
+source.pipe(skip).pipe(sink)
+
+// Additionally accepts `wantStrings` argument to conver buffers into strings
+var alphanum = new RegExp("^[A-Za-z0-1]+$")
+var scrub = filter({wantStrings: true}, function (str) {
+  return alphanum.exec(str)
+})
+
+// Works like `Array.prototype.filter` meaning you can specify a function that
+// takes up to two* arguments: fn(element, index)
+var skip10 = filter(function (element, index) {
+  return index > 10
+})
+```
+
+*Differences from `Array.prototype.filter`:
+  * No third `array` callback argument. That would require realizing the entire stream, which is generally counter-productive to stream operations.
+  * `Array.prototype.filter` doesn't modify the source Array, which is somewhat nonsensical when applied to streams.
+
+API
+---
+
+`require("through2-filter")([options], fn)`
+---
+
+Create a `through2-filter` instance that will call `fn(chunk)`. If `fn(chunk)` returns "true" the chunk will be passed downstream. Otherwise it will be dropped.
+
+`require("through2-filter").ctor([options], fn)`
+---
+
+Create a `through2-filter` Type that can be instantiated via `new Type()` or `Type()` to create reusable spies.
+
+`require("through2-filter").obj([options], fn)`
+---
+
+Create a `through2-filter` that defaults to `objectMode = true`.
+
+`require("through2-filter").objCtor([options], fn)`
+---
+
+Create a `through2-filter` Type that defaults to `objectMode = true`.
+
+Options
+-------
+
+  * wantStrings: Automatically call chunk.toString() for the super lazy.
+  * all other through2 options
+
+LICENSE
+=======
+
+MIT