postdoc 0.2.0.beta4 → 0.2.0

data/node_modules/es6-promise/lib/es6-promise/asap.js

@@ -1,119 +0,0 @@
-let len = 0;
-let vertxNext;
-let customSchedulerFn;
-
-export var asap = function asap(callback, arg) {
-  queue[len] = callback;
-  queue[len + 1] = arg;
-  len += 2;
-  if (len === 2) {
-    // If len is 2, that means that we need to schedule an async flush.
-    // If additional callbacks are queued before the queue is flushed, they
-    // will be processed by this flush that we are scheduling.
-    if (customSchedulerFn) {
-      customSchedulerFn(flush);
-    } else {
-      scheduleFlush();
-    }
-  }
-}
-
-export function setScheduler(scheduleFn) {
-  customSchedulerFn = scheduleFn;
-}
-
-export function setAsap(asapFn) {
-  asap = asapFn;
-}
-
-const browserWindow = (typeof window !== 'undefined') ? window : undefined;
-const browserGlobal = browserWindow || {};
-const BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-const isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
-
-// test for web worker but not in IE10
-const isWorker = typeof Uint8ClampedArray !== 'undefined' &&
-  typeof importScripts !== 'undefined' &&
-  typeof MessageChannel !== 'undefined';
-
-// node
-function useNextTick() {
-  // node version 0.10.x displays a deprecation warning when nextTick is used recursively
-  // see https://github.com/cujojs/when/issues/410 for details
-  return () => process.nextTick(flush);
-}
-
-// vertx
-function useVertxTimer() {
-  if (typeof vertxNext !== 'undefined') {
-    return function() {
-      vertxNext(flush);
-    };
-  }
-
-  return useSetTimeout();
-}
-
-function useMutationObserver() {
-  let iterations = 0;
-  const observer = new BrowserMutationObserver(flush);
-  const node = document.createTextNode('');
-  observer.observe(node, { characterData: true });
-
-  return () => {
-    node.data = (iterations = ++iterations % 2);
-  };
-}
-
-// web worker
-function useMessageChannel() {
-  const channel = new MessageChannel();
-  channel.port1.onmessage = flush;
-  return () => channel.port2.postMessage(0);
-}
-
-function useSetTimeout() {
-  // Store setTimeout reference so es6-promise will be unaffected by
-  // other code modifying setTimeout (like sinon.useFakeTimers())
-  const globalSetTimeout = setTimeout;
-  return () => globalSetTimeout(flush, 1);
-}
-
-const queue = new Array(1000);
-function flush() {
-  for (let i = 0; i < len; i+=2) {
-    let callback = queue[i];
-    let arg = queue[i+1];
-
-    callback(arg);
-
-    queue[i] = undefined;
-    queue[i+1] = undefined;
-  }
-
-  len = 0;
-}
-
-function attemptVertx() {
-  try {
-    const vertx = Function('return this')().require('vertx');
-    vertxNext = vertx.runOnLoop || vertx.runOnContext;
-    return useVertxTimer();
-  } catch(e) {
-    return useSetTimeout();
-  }
-}
-
-let scheduleFlush;
-// Decide what async method to use to triggering processing of queued callbacks:
-if (isNode) {
-  scheduleFlush = useNextTick();
-} else if (BrowserMutationObserver) {
-  scheduleFlush = useMutationObserver();
-} else if (isWorker) {
-  scheduleFlush = useMessageChannel();
-} else if (browserWindow === undefined && typeof require === 'function') {
-  scheduleFlush = attemptVertx();
-} else {
-  scheduleFlush = useSetTimeout();
-}

data/node_modules/es6-promise/lib/es6-promise/enumerator.js

@@ -1,113 +0,0 @@
-import {
-  isArray,
-  isMaybeThenable
-} from './utils';
-import {
-  noop,
-  reject,
-  fulfill,
-  subscribe,
-  FULFILLED,
-  REJECTED,
-  PENDING,
-  getThen,
-  handleMaybeThenable
-} from './-internal';
-
-import then from './then';
-import Promise from './promise';
-import originalResolve from './promise/resolve';
-import originalThen from './then';
-import { makePromise, PROMISE_ID } from './-internal';
-
-function validationError() {
-  return new Error('Array Methods must be provided an Array');
-};
-
-export default class Enumerator {
-  constructor(Constructor, input) {
-    this._instanceConstructor = Constructor;
-    this.promise = new Constructor(noop);
-
-    if (!this.promise[PROMISE_ID]) {
-      makePromise(this.promise);
-    }
-
-    if (isArray(input)) {
-      this.length     = input.length;
-      this._remaining = input.length;
-
-      this._result = new Array(this.length);
-
-      if (this.length === 0) {
-        fulfill(this.promise, this._result);
-      } else {
-        this.length = this.length || 0;
-        this._enumerate(input);
-        if (this._remaining === 0) {
-          fulfill(this.promise, this._result);
-        }
-      }
-    } else {
-      reject(this.promise, validationError());
-    }
-  }
-  _enumerate(input) {
-    for (let i = 0; this._state === PENDING && i < input.length; i++) {
-      this._eachEntry(input[i], i);
-    }
-  }
-
-  _eachEntry(entry, i) {
-    let c = this._instanceConstructor;
-    let { resolve } = c;
-
-    if (resolve === originalResolve) {
-      let then = getThen(entry);
-
-      if (then === originalThen &&
-        entry._state !== PENDING) {
-        this._settledAt(entry._state, i, entry._result);
-      } else if (typeof then !== 'function') {
-        this._remaining--;
-        this._result[i] = entry;
-      } else if (c === Promise) {
-        let promise = new c(noop);
-        handleMaybeThenable(promise, entry, then);
-        this._willSettleAt(promise, i);
-      } else {
-        this._willSettleAt(new c(resolve => resolve(entry)), i);
-      }
-    } else {
-      this._willSettleAt(resolve(entry), i);
-    }
-  }
-
-  _settledAt(state, i, value) {
-    let { promise } = this;
-
-    if (promise._state === PENDING) {
-      this._remaining--;
-
-      if (state === REJECTED) {
-        reject(promise, value);
-      } else {
-        this._result[i] = value;
-      }
-    }
-
-    if (this._remaining === 0) {
-      fulfill(promise, this._result);
-    }
-  }
-
-  _willSettleAt(promise, i) {
-    let enumerator = this;
-
-    subscribe(
-      promise, undefined,
-      value => enumerator._settledAt(FULFILLED, i, value),
-      reason => enumerator._settledAt(REJECTED, i, reason)
-    );
-  }
-};

data/node_modules/es6-promise/lib/es6-promise/polyfill.js

@@ -1,35 +0,0 @@
-/*global self*/
-import Promise from './promise';
-
-export default function polyfill() {
-  let local;
-
-  if (typeof global !== 'undefined') {
-    local = global;
-  } else if (typeof self !== 'undefined') {
-    local = self;
-  } else {
-    try {
-      local = Function('return this')();
-    } catch (e) {
-      throw new Error('polyfill failed because global object is unavailable in this environment');
-    }
-  }
-
-  let P = local.Promise;
-
-  if (P) {
-    var promiseToString = null;
-    try {
-      promiseToString = Object.prototype.toString.call(P.resolve());
-    } catch(e) {
-      // silently ignored
-    }
-
-    if (promiseToString === '[object Promise]' && !P.cast){
-      return;
-    }
-  }
-
-  local.Promise = Promise;
-}

data/node_modules/es6-promise/lib/es6-promise/promise/all.js

@@ -1,52 +0,0 @@
-import Enumerator from '../enumerator';
-
-/**
-  `Promise.all` accepts an array of promises, and returns a new promise which
-  is fulfilled with an array of fulfillment values for the passed promises, or
-  rejected with the reason of the first passed promise to be rejected. It casts all
-  elements of the passed iterable to promises as it runs this algorithm.
-
-  Example:
-
-  ```javascript
-  let promise1 = resolve(1);
-  let promise2 = resolve(2);
-  let promise3 = resolve(3);
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // The array here would be [ 1, 2, 3 ];
-  });
-  ```
-
-  If any of the `promises` given to `all` are rejected, the first promise
-  that is rejected will be given as an argument to the returned promises's
-  rejection handler. For example:
-
-  Example:
-
-  ```javascript
-  let promise1 = resolve(1);
-  let promise2 = reject(new Error("2"));
-  let promise3 = reject(new Error("3"));
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // Code here never runs because there are rejected promises!
-  }, function(error) {
-    // error.message === "2"
-  });
-  ```
-
-  @method all
-  @static
-  @param {Array} entries array of promises
-  @param {String} label optional string for labeling the promise.
-  Useful for tooling.
-  @return {Promise} promise that is fulfilled when all `promises` have been
-  fulfilled, or rejected if any of them become rejected.
-  @static
-*/
-export default function all(entries) {
-  return new Enumerator(this, entries).promise;
-}

data/node_modules/es6-promise/lib/es6-promise/promise/race.js

@@ -1,84 +0,0 @@
-import {
-  isArray
-} from "../utils";
-
-/**
-  `Promise.race` returns a new promise which is settled in the same way as the
-  first passed promise to settle.
-
-  Example:
-
-  ```javascript
-  let promise1 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 1');
-    }, 200);
-  });
-
-  let promise2 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 2');
-    }, 100);
-  });
-
-  Promise.race([promise1, promise2]).then(function(result){
-    // result === 'promise 2' because it was resolved before promise1
-    // was resolved.
-  });
-  ```
-
-  `Promise.race` is deterministic in that only the state of the first
-  settled promise matters. For example, even if other promises given to the
-  `promises` array argument are resolved, but the first settled promise has
-  become rejected before the other promises became fulfilled, the returned
-  promise will become rejected:
-
-  ```javascript
-  let promise1 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 1');
-    }, 200);
-  });
-
-  let promise2 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      reject(new Error('promise 2'));
-    }, 100);
-  });
-
-  Promise.race([promise1, promise2]).then(function(result){
-    // Code here never runs
-  }, function(reason){
-    // reason.message === 'promise 2' because promise 2 became rejected before
-    // promise 1 became fulfilled
-  });
-  ```
-
-  An example real-world use case is implementing timeouts:
-
-  ```javascript
-  Promise.race([ajax('foo.json'), timeout(5000)])
-  ```
-
-  @method race
-  @static
-  @param {Array} promises array of promises to observe
-  Useful for tooling.
-  @return {Promise} a promise which settles in the same way as the first passed
-  promise to settle.
-*/
-export default function race(entries) {
-  /*jshint validthis:true */
-  let Constructor = this;
-
-  if (!isArray(entries)) {
-    return new Constructor((_, reject) => reject(new TypeError('You must pass an array to race.')));
-  } else {
-    return new Constructor((resolve, reject) => {
-      let length = entries.length;
-      for (let i = 0; i < length; i++) {
-        Constructor.resolve(entries[i]).then(resolve, reject);
-      }
-    });
-  }
-}

data/node_modules/es6-promise/lib/es6-promise/promise/reject.js

@@ -1,46 +0,0 @@
-import {
-  noop,
-  reject as _reject
-} from '../-internal';
-
-/**
-  `Promise.reject` returns a promise rejected with the passed `reason`.
-  It is shorthand for the following:
-
-  ```javascript
-  let promise = new Promise(function(resolve, reject){
-    reject(new Error('WHOOPS'));
-  });
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  let promise = Promise.reject(new Error('WHOOPS'));
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  @method reject
-  @static
-  @param {Any} reason value that the returned promise will be rejected with.
-  Useful for tooling.
-  @return {Promise} a promise rejected with the given `reason`.
-*/
-export default function reject(reason) {
-  /*jshint validthis:true */
-  let Constructor = this;
-  let promise = new Constructor(noop);
-  _reject(promise, reason);
-  return promise;
-}

data/node_modules/es6-promise/lib/es6-promise/promise/resolve.js

@@ -1,48 +0,0 @@
-import {
-  noop,
-  resolve as _resolve
-} from '../-internal';
-
-/**
-  `Promise.resolve` returns a promise that will become resolved with the
-  passed `value`. It is shorthand for the following:
-
-  ```javascript
-  let promise = new Promise(function(resolve, reject){
-    resolve(1);
-  });
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
-
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  let promise = Promise.resolve(1);
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
-
-  @method resolve
-  @static
-  @param {Any} value value that the returned promise will be resolved with
-  Useful for tooling.
-  @return {Promise} a promise that will become fulfilled with the given
-  `value`
-*/
-export default function resolve(object) {
-  /*jshint validthis:true */
-  let Constructor = this;
-
-  if (object && typeof object === 'object' && object.constructor === Constructor) {
-    return object;
-  }
-
-  let promise = new Constructor(noop);
-  _resolve(promise, object);
-  return promise;
-}