feat: docker compose maybe

node_modules/any-promise/.jshintrc

@@ -0,0 +1,4 @@
+{
+  "node":true,
+  "strict":true
+}

node_modules/any-promise/.npmignore

@@ -0,0 +1,7 @@
+.git*
+test/
+test-browser/
+build/
+.travis.yml
+*.swp
+Makefile

node_modules/any-promise/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2014-2016 Kevin Beaty
+
+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.

node_modules/any-promise/README.md

@@ -0,0 +1,161 @@
+## Any Promise
+
+[![Build Status](https://secure.travis-ci.org/kevinbeaty/any-promise.svg)](http://travis-ci.org/kevinbeaty/any-promise)
+
+Let your library support any ES 2015 (ES6) compatible `Promise` and leave the choice to application authors. The application can *optionally* register its preferred `Promise` implementation and it will be exported when requiring `any-promise` from library code.
+
+If no preference is registered, defaults to the global `Promise` for newer Node.js versions. The browser version defaults to the window `Promise`, so polyfill or register as necessary.
+
+### Usage with global Promise:
+
+Assuming the global `Promise` is the desired implementation:
+
+```bash
+# Install any libraries depending on any-promise
+$ npm install mz
+```
+
+The installed libraries will use global Promise by default.
+
+```js
+// in library
+var Promise = require('any-promise')  // the global Promise
+
+function promiseReturningFunction(){
+    return new Promise(function(resolve, reject){...})
+}
+```
+
+### Usage with registration:
+
+Assuming `bluebird` is the desired Promise implementation:
+
+```bash
+# Install preferred promise library
+$ npm install bluebird
+# Install any-promise to allow registration
+$ npm install any-promise
+# Install any libraries you would like to use depending on any-promise
+$ npm install mz
+```
+
+Register your preference in the application entry point before any other `require` of packages that load `any-promise`:
+
+```javascript
+// top of application index.js or other entry point
+require('any-promise/register/bluebird')
+
+// -or- Equivalent to above, but allows customization of Promise library
+require('any-promise/register')('bluebird', {Promise: require('bluebird')})
+```
+
+Now that the implementation is registered, you can use any package depending on `any-promise`:
+
+
+```javascript
+var fsp = require('mz/fs') // mz/fs will use registered bluebird promises
+var Promise = require('any-promise')  // the registered bluebird promise 
+```
+
+It is safe to call `register` multiple times, but it must always be with the same implementation.
+
+Again, registration is *optional*. It should only be called by the application user if overriding the global `Promise` implementation is desired.
+
+### Optional Application Registration
+
+As an application author, you can *optionally* register a preferred `Promise` implementation on application startup (before any call to `require('any-promise')`:
+
+You must register your preference before any call to `require('any-promise')` (by you or required packages), and only one implementation can be registered. Typically, this registration would occur at the top of the application entry point.
+
+
+#### Registration shortcuts
+
+If you are using a known `Promise` implementation, you can register your preference with a shortcut:
+
+
+```js
+require('any-promise/register/bluebird')
+// -or-
+import 'any-promise/register/q';
+```
+
+Shortcut registration is the preferred registration method as it works in the browser and Node.js. It is also convenient for using with `import` and many test runners, that offer a `--require` flag:
+
+```
+$ ava --require=any-promise/register/bluebird test.js
+```
+
+Current known implementations include `bluebird`, `q`, `when`, `rsvp`, `es6-promise`, `promise`, `native-promise-only`, `pinkie`, `vow` and `lie`. If you are not using a known implementation, you can use another registration method described below.
+
+
+#### Basic Registration
+
+As an alternative to registration shortcuts, you can call the `register` function with the preferred `Promise` implementation. The benefit of this approach is that a `Promise` library can be required by name without being a known implementation.  This approach does NOT work in the browser. To use `any-promise` in the browser use either registration shortcuts or specify the `Promise` constructor using advanced registration (see below).
+
+```javascript
+require('any-promise/register')('when')
+// -or- require('any-promise/register')('any other ES6 compatible library (known or otherwise)')
+```
+
+This registration method will try to detect the `Promise` constructor from requiring the specified implementation.  If you would like to specify your own constructor, see advanced registration.
+
+
+#### Advanced Registration
+
+To use the browser version, you should either install a polyfill or explicitly register the `Promise` constructor:
+
+```javascript
+require('any-promise/register')('bluebird', {Promise: require('bluebird')})
+```
+
+This could also be used for registering a custom `Promise` implementation or subclass.
+
+Your preference will be registered globally, allowing a single registration even if multiple versions of `any-promise` are installed in the NPM dependency tree or are using multiple bundled JavaScript files in the browser. You can bypass this global registration in options:
+
+
+```javascript
+require('../register')('es6-promise', {Promise: require('es6-promise').Promise, global: false})
+```
+
+### Library Usage
+
+To use any `Promise` constructor, simply require it:
+
+```javascript
+var Promise = require('any-promise');
+
+return Promise
+  .all([xf, f, init, coll])
+  .then(fn);
+
+
+return new Promise(function(resolve, reject){
+  try {
+    resolve(item);
+  } catch(e){
+    reject(e);
+  }
+});
+
+```
+
+Except noted below, libraries using `any-promise` should only use [documented](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) functions as there is no guarantee which implementation will be chosen by the application author.  Libraries should never call `register`, only the application user should call if desired.
+
+
+#### Advanced Library Usage
+
+If your library needs to branch code based on the registered implementation, you can retrieve it using `var impl = require('any-promise/implementation')`, where `impl` will be the package name (`"bluebird"`, `"when"`, etc.) if registered, `"global.Promise"` if using the global version on Node.js, or `"window.Promise"` if using the browser version. You should always include a default case, as there is no guarantee what package may be registered.
+
+
+### Support for old Node.js versions
+
+Node.js versions prior to `v0.12` may have contained buggy versions of the global `Promise`. For this reason, the global `Promise` is not loaded automatically for these old versions.  If using `any-promise` in Node.js versions versions `<= v0.12`, the user should register a desired implementation.
+
+If an implementation is not registered, `any-promise` will attempt to discover an installed `Promise` implementation.  If no implementation can be found, an error will be thrown on `require('any-promise')`.  While the auto-discovery usually avoids errors, it is non-deterministic. It is recommended that the user always register a preferred implementation for older Node.js versions.
+
+This auto-discovery is only available for Node.jS versions prior to `v0.12`. Any newer versions will always default to the global `Promise` implementation.
+
+### Related
+
+- [any-observable](https://github.com/sindresorhus/any-observable) - `any-promise` for Observables.
+

node_modules/any-promise/implementation.d.ts

@@ -0,0 +1,3 @@
+declare var implementation: string;
+
+export = implementation;

node_modules/any-promise/implementation.js

@@ -0,0 +1 @@
+module.exports = require('./register')().implementation

node_modules/any-promise/index.d.ts

@@ -0,0 +1,73 @@
+declare class Promise <R> implements Promise.Thenable <R> {
+  /**
+   * If you call resolve in the body of the callback passed to the constructor,
+   * your promise is fulfilled with result object passed to resolve.
+   * If you call reject your promise is rejected with the object passed to resolve.
+   * For consistency and debugging (eg stack traces), obj should be an instanceof Error.
+   * Any errors thrown in the constructor callback will be implicitly passed to reject().
+   */
+  constructor (callback: (resolve : (value?: R | Promise.Thenable<R>) => void, reject: (error?: any) => void) => void);
+
+  /**
+   * onFulfilled is called when/if "promise" resolves. onRejected is called when/if "promise" rejects.
+   * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called.
+   * Both callbacks have a single parameter , the fulfillment value or rejection reason.
+   * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve.
+   * If an error is thrown in the callback, the returned promise rejects with that error.
+   *
+   * @param onFulfilled called when/if "promise" resolves
+   * @param onRejected called when/if "promise" rejects
+   */
+  then <U> (onFulfilled?: (value: R) => U | Promise.Thenable<U>, onRejected?: (error: any) => U | Promise.Thenable<U>): Promise<U>;
+  then <U> (onFulfilled?: (value: R) => U | Promise.Thenable<U>, onRejected?: (error: any) => void): Promise<U>;
+
+  /**
+   * Sugar for promise.then(undefined, onRejected)
+   *
+   * @param onRejected called when/if "promise" rejects
+   */
+  catch <U> (onRejected?: (error: any) => U | Promise.Thenable<U>): Promise<U>;
+
+  /**
+   * Make a new promise from the thenable.
+   * A thenable is promise-like in as far as it has a "then" method.
+   */
+  static resolve (): Promise<void>;
+  static resolve <R> (value: R | Promise.Thenable<R>): Promise<R>;
+
+  /**
+   * Make a promise that rejects to obj. For consistency and debugging (eg stack traces), obj should be an instanceof Error
+   */
+  static reject <R> (error: any): Promise<R>;
+
+  /**
+   * Make a promise that fulfills when every item in the array fulfills, and rejects if (and when) any item rejects.
+   * the array passed to all can be a mixture of promise-like objects and other objects.
+   * The fulfillment value is an array (in order) of fulfillment values. The rejection value is the first rejection value.
+   */
+  static all <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>, T4 | Promise.Thenable <T4>, T5 | Promise.Thenable<T5>, T6 | Promise.Thenable<T6>, T7 | Promise.Thenable<T7>, T8 | Promise.Thenable<T8>, T9 | Promise.Thenable<T9>, T10 | Promise.Thenable<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+  static all <T1, T2, T3, T4, T5, T6, T7, T8, T9> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>, T4 | Promise.Thenable <T4>, T5 | Promise.Thenable<T5>, T6 | Promise.Thenable<T6>, T7 | Promise.Thenable<T7>, T8 | Promise.Thenable<T8>, T9 | Promise.Thenable<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+  static all <T1, T2, T3, T4, T5, T6, T7, T8> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>, T4 | Promise.Thenable <T4>, T5 | Promise.Thenable<T5>, T6 | Promise.Thenable<T6>, T7 | Promise.Thenable<T7>, T8 | Promise.Thenable<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+  static all <T1, T2, T3, T4, T5, T6, T7> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>, T4 | Promise.Thenable <T4>, T5 | Promise.Thenable<T5>, T6 | Promise.Thenable<T6>, T7 | Promise.Thenable<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>;
+  static all <T1, T2, T3, T4, T5, T6> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>, T4 | Promise.Thenable <T4>, T5 | Promise.Thenable<T5>, T6 | Promise.Thenable<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>;
+  static all <T1, T2, T3, T4, T5> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>, T4 | Promise.Thenable <T4>, T5 | Promise.Thenable<T5>]): Promise<[T1, T2, T3, T4, T5]>;
+  static all <T1, T2, T3, T4> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>, T4 | Promise.Thenable <T4>]): Promise<[T1, T2, T3, T4]>;
+  static all <T1, T2, T3> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>, T3 | Promise.Thenable<T3>]): Promise<[T1, T2, T3]>;
+  static all <T1, T2> (values: [T1 | Promise.Thenable<T1>, T2 | Promise.Thenable<T2>]): Promise<[T1, T2]>;
+  static all <T1> (values: [T1 | Promise.Thenable<T1>]): Promise<[T1]>;
+  static all <TAll> (values: Array<TAll | Promise.Thenable<TAll>>): Promise<TAll[]>;
+
+  /**
+   * Make a Promise that fulfills when any item fulfills, and rejects if any item rejects.
+   */
+  static race <R> (promises: (R | Promise.Thenable<R>)[]): Promise<R>;
+}
+
+declare namespace Promise {
+  export interface Thenable <R> {
+    then <U> (onFulfilled?: (value: R) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+    then <U> (onFulfilled?: (value: R) => U | Thenable<U>, onRejected?: (error: any) => void): Thenable<U>;
+  }
+}
+
+export = Promise;

node_modules/any-promise/index.js

@@ -0,0 +1 @@
+module.exports = require('./register')().Promise

node_modules/any-promise/loader.js

@@ -0,0 +1,78 @@
+"use strict"
+    // global key for user preferred registration
+var REGISTRATION_KEY = '@@any-promise/REGISTRATION',
+    // Prior registration (preferred or detected)
+    registered = null
+
+/**
+ * Registers the given implementation.  An implementation must
+ * be registered prior to any call to `require("any-promise")`,
+ * typically on application load.
+ *
+ * If called with no arguments, will return registration in
+ * following priority:
+ *
+ * For Node.js:
+ *
+ * 1. Previous registration
+ * 2. global.Promise if node.js version >= 0.12
+ * 3. Auto detected promise based on first sucessful require of
+ *    known promise libraries. Note this is a last resort, as the
+ *    loaded library is non-deterministic. node.js >= 0.12 will
+ *    always use global.Promise over this priority list.
+ * 4. Throws error.
+ *
+ * For Browser:
+ *
+ * 1. Previous registration
+ * 2. window.Promise
+ * 3. Throws error.
+ *
+ * Options:
+ *
+ * Promise: Desired Promise constructor
+ * global: Boolean - Should the registration be cached in a global variable to
+ * allow cross dependency/bundle registration?  (default true)
+ */
+module.exports = function(root, loadImplementation){
+  return function register(implementation, opts){
+    implementation = implementation || null
+    opts = opts || {}
+    // global registration unless explicitly  {global: false} in options (default true)
+    var registerGlobal = opts.global !== false;
+
+    // load any previous global registration
+    if(registered === null && registerGlobal){
+      registered = root[REGISTRATION_KEY] || null
+    }
+
+    if(registered !== null
+        && implementation !== null
+        && registered.implementation !== implementation){
+      // Throw error if attempting to redefine implementation
+      throw new Error('any-promise already defined as "'+registered.implementation+
+        '".  You can only register an implementation before the first '+
+        ' call to require("any-promise") and an implementation cannot be changed')
+    }
+
+    if(registered === null){
+      // use provided implementation
+      if(implementation !== null && typeof opts.Promise !== 'undefined'){
+        registered = {
+          Promise: opts.Promise,
+          implementation: implementation
+        }
+      } else {
+        // require implementation if implementation is specified but not provided
+        registered = loadImplementation(implementation)
+      }
+
+      if(registerGlobal){
+        // register preference globally in case multiple installations
+        root[REGISTRATION_KEY] = registered
+      }
+    }
+
+    return registered
+  }
+}

node_modules/any-promise/optional.js

@@ -0,0 +1,6 @@
+"use strict";
+try {
+  module.exports = require('./register')().Promise || null
+} catch(e) {
+  module.exports = null
+}

node_modules/any-promise/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "any-promise",
+  "version": "1.3.0",
+  "description": "Resolve any installed ES6 compatible promise",
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "browser": {
+    "./register.js": "./register-shim.js"
+  },
+  "scripts": {
+    "test": "ava"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kevinbeaty/any-promise"
+  },
+  "keywords": [
+    "promise",
+    "es6"
+  ],
+  "author": "Kevin Beaty",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kevinbeaty/any-promise/issues"
+  },
+  "homepage": "http://github.com/kevinbeaty/any-promise",
+  "dependencies": {},
+  "devDependencies": {
+    "ava": "^0.14.0",
+    "bluebird": "^3.0.0",
+    "es6-promise": "^3.0.0",
+    "is-promise": "^2.0.0",
+    "lie": "^3.0.0",
+    "mocha": "^2.0.0",
+    "native-promise-only": "^0.8.0",
+    "phantomjs-prebuilt": "^2.0.0",
+    "pinkie": "^2.0.0",
+    "promise": "^7.0.0",
+    "q": "^1.0.0",
+    "rsvp": "^3.0.0",
+    "vow": "^0.4.0",
+    "when": "^3.0.0",
+    "zuul": "^3.0.0"
+  }
+}

node_modules/any-promise/register-shim.js

@@ -0,0 +1,18 @@
+"use strict";
+module.exports = require('./loader')(window, loadImplementation)
+
+/**
+ * Browser specific loadImplementation.  Always uses `window.Promise`
+ *
+ * To register a custom implementation, must register with `Promise` option.
+ */
+function loadImplementation(){
+  if(typeof window.Promise === 'undefined'){
+    throw new Error("any-promise browser requires a polyfill or explicit registration"+
+      " e.g: require('any-promise/register/bluebird')")
+  }
+  return {
+    Promise: window.Promise,
+    implementation: 'window.Promise'
+  }
+}

node_modules/any-promise/register.d.ts

@@ -0,0 +1,17 @@
+import Promise = require('./index');
+
+declare function register (module?: string, options?: register.Options): register.Register;
+
+declare namespace register {
+  export interface Register {
+    Promise: typeof Promise;
+    implementation: string;
+  }
+
+  export interface Options {
+      Promise?: typeof Promise;
+      global?: boolean
+  }
+}
+
+export = register;

node_modules/any-promise/register.js

@@ -0,0 +1,94 @@
+"use strict"
+module.exports = require('./loader')(global, loadImplementation);
+
+/**
+ * Node.js version of loadImplementation.
+ *
+ * Requires the given implementation and returns the registration
+ * containing {Promise, implementation}
+ *
+ * If implementation is undefined or global.Promise, loads it
+ * Otherwise uses require
+ */
+function loadImplementation(implementation){
+  var impl = null
+
+  if(shouldPreferGlobalPromise(implementation)){
+    // if no implementation or env specified use global.Promise
+    impl = {
+      Promise: global.Promise,
+      implementation: 'global.Promise'
+    }
+  } else if(implementation){
+    // if implementation specified, require it
+    var lib = require(implementation)
+    impl = {
+      Promise: lib.Promise || lib,
+      implementation: implementation
+    }
+  } else {
+    // try to auto detect implementation. This is non-deterministic
+    // and should prefer other branches, but this is our last chance
+    // to load something without throwing error
+    impl = tryAutoDetect()
+  }
+
+  if(impl === null){
+    throw new Error('Cannot find any-promise implementation nor'+
+      ' global.Promise. You must install polyfill or call'+
+      ' require("any-promise/register") with your preferred'+
+      ' implementation, e.g. require("any-promise/register/bluebird")'+
+      ' on application load prior to any require("any-promise").')
+  }
+
+  return impl
+}
+
+/**
+ * Determines if the global.Promise should be preferred if an implementation
+ * has not been registered.
+ */
+function shouldPreferGlobalPromise(implementation){
+  if(implementation){
+    return implementation === 'global.Promise'
+  } else if(typeof global.Promise !== 'undefined'){
+    // Load global promise if implementation not specified
+    // Versions < 0.11 did not have global Promise
+    // Do not use for version < 0.12 as version 0.11 contained buggy versions
+    var version = (/v(\d+)\.(\d+)\.(\d+)/).exec(process.version)
+    return !(version && +version[1] == 0 && +version[2] < 12)
+  }
+
+  // do not have global.Promise or another implementation was specified
+  return false
+}
+
+/**
+ * Look for common libs as last resort there is no guarantee that
+ * this will return a desired implementation or even be deterministic.
+ * The priority is also nearly arbitrary. We are only doing this
+ * for older versions of Node.js <0.12 that do not have a reasonable
+ * global.Promise implementation and we the user has not registered
+ * the preference. This preserves the behavior of any-promise <= 0.1
+ * and may be deprecated or removed in the future
+ */
+function tryAutoDetect(){
+  var libs = [
+      "es6-promise",
+      "promise",
+      "native-promise-only",
+      "bluebird",
+      "rsvp",
+      "when",
+      "q",
+      "pinkie",
+      "lie",
+      "vow"]
+  var i = 0, len = libs.length
+  for(; i < len; i++){
+    try {
+      return loadImplementation(libs[i])
+    } catch(e){}
+  }
+  return null
+}

node_modules/any-promise/register/bluebird.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/bluebird.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('bluebird', {Promise: require('bluebird')})

node_modules/any-promise/register/es6-promise.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/es6-promise.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('es6-promise', {Promise: require('es6-promise').Promise})

node_modules/any-promise/register/lie.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/lie.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('lie', {Promise: require('lie')})

node_modules/any-promise/register/native-promise-only.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/native-promise-only.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('native-promise-only', {Promise: require('native-promise-only')})

node_modules/any-promise/register/pinkie.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/pinkie.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('pinkie', {Promise: require('pinkie')})

node_modules/any-promise/register/promise.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/promise.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('promise', {Promise: require('promise')})

node_modules/any-promise/register/q.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/q.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('q', {Promise: require('q').Promise})

node_modules/any-promise/register/rsvp.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/rsvp.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('rsvp', {Promise: require('rsvp').Promise})

node_modules/any-promise/register/vow.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/vow.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('vow', {Promise: require('vow').Promise})

node_modules/any-promise/register/when.d.ts

@@ -0,0 +1 @@
+export {}

node_modules/any-promise/register/when.js

@@ -0,0 +1,2 @@
+'use strict';
+require('../register')('when', {Promise: require('when').Promise})