t-tasks 0.9.6 → 1.0.0-beta.1

package/dist/t-tasks.cjs.development.js

@@ -1,2049 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-(function (Just) {
-  /**
-   * Standalone Just value extractor
-   *
-   * Userful for passing as a function to collection transformers
-   *
-   * @template R underlying value type
-   * @param just Just instance
-   * @returns underlying value
-   */
-  function just(just) {
-    return just.just;
-  }
-
-  Just.just = just;
-})(exports.Just || (exports.Just = {}));
-
-(function (Maybe) {
-  /**
-   * Non-empty monad constructor
-   *
-   * @template R underlying type
-   * @param value underlying value
-   * @returns 'just value'
-   */
-  function just(value) {
-    return new JustClass(value);
-  }
-
-  Maybe.just = just;
-  /**
-   * Empty monad constructor
-   *
-   * @returns 'nothing'
-   */
-
-  function nothing() {
-    return staticNothing;
-  }
-
-  Maybe.nothing = nothing;
-
-  function fromOptional(value) {
-    return typeof value !== 'undefined' ? Maybe.just(value) : Maybe.nothing();
-  }
-
-  Maybe.fromOptional = fromOptional;
-
-  function fromNullable(value) {
-    return Maybe.fromOptional(value).chain(function (v) {
-      return v !== null ? Maybe.just(v) : Maybe.nothing();
-    });
-  }
-
-  Maybe.fromNullable = fromNullable;
-  /**
-   * Standalone type guard for 'just'
-   *
-   * Userful for passing as a predicate to collection transformers
-   *
-   * @template R underlying value type
-   * @param maybe Maybe instance
-   * @returns 'true' in case wrapped value exists (and resolves argument type to be 'just')
-   */
-
-  function isJust(maybe) {
-    return maybe.isJust();
-  }
-
-  Maybe.isJust = isJust;
-  /**
-   * Standalone type guard for 'nothing'
-   *
-   * Userful for passing as a predicate to collection transformers
-   *
-   * @template R underlying value type
-   * @param maybe Maybe instance
-   * @returns 'true' in case wrapped value is 'nothing' (and resolves argument type to be 'nothing')
-   */
-
-  function isNothing(maybe) {
-    return maybe.isNothing();
-  }
-
-  Maybe.isNothing = isNothing;
-  /**
-   * Standalone list predicate
-   *
-   * @param maybes a list of Maybe
-   * @returns true in case every list element is Just
-   */
-
-  function everyJust(maybes) {
-    return maybes.every(Maybe.isJust);
-  }
-
-  Maybe.everyJust = everyJust;
-  /**
-   * Standalone list predicate
-   *
-   * @param maybes a list of Maybe
-   * @returns true in case al east one list element is Just
-   */
-
-  function someJust(maybes) {
-    return maybes.some(Maybe.isJust);
-  }
-
-  Maybe.someJust = someJust;
-  /**
-   * Standalone list predicate
-   *
-   * @param maybes a list of Maybe
-   * @returns true in case every list element is Nothing
-   */
-
-  function everyNothing(maybes) {
-    return maybes.every(Maybe.isNothing);
-  }
-
-  Maybe.everyNothing = everyNothing;
-  /**
-   * Standalone list predicate
-   *
-   * @param maybes a list of Maybe
-   * @returns true in case at least one list element is Nothing
-   */
-
-  function someNothing(maybes) {
-    return maybes.some(Maybe.isNothing);
-  }
-
-  Maybe.someNothing = someNothing;
-})(exports.Maybe || (exports.Maybe = {})); /// --------------------------------------------------------------------------------------
-/// Private section
-/// --------------------------------------------------------------------------------------
-
-
-var JustClass = /*#__PURE__*/function () {
-  function JustClass(just) {
-    this.just = just;
-  }
-
-  var _proto = JustClass.prototype;
-
-  _proto.tap = function tap(op) {
-    op(this.just);
-    return this;
-  };
-
-  _proto.orTap = function orTap() {
-    return this;
-  };
-
-  _proto.map = function map(op) {
-    return exports.Maybe.just(op(this.just));
-  };
-
-  _proto.orMap = function orMap() {
-    return this;
-  };
-
-  _proto.chain = function chain(op) {
-    return op(this.just);
-  };
-
-  _proto.orChain = function orChain() {
-    return this;
-  };
-
-  _proto.isJust = function isJust() {
-    return true;
-  };
-
-  _proto.isNothing = function isNothing() {
-    return false;
-  };
-
-  _proto.matchTap = function matchTap(op) {
-    return this.tap(op.just);
-  };
-
-  _proto.matchMap = function matchMap(op) {
-    return this.map(op.just);
-  };
-
-  _proto.matchChain = function matchChain(op) {
-    return this.chain(op.just);
-  };
-
-  return JustClass;
-}();
-
-var NothingClass = /*#__PURE__*/function () {
-  function NothingClass() {}
-
-  var _proto2 = NothingClass.prototype;
-
-  _proto2.tap = function tap() {
-    return this;
-  };
-
-  _proto2.orTap = function orTap(op) {
-    op();
-    return this;
-  };
-
-  _proto2.map = function map() {
-    return this;
-  };
-
-  _proto2.orMap = function orMap(op) {
-    return exports.Maybe.just(op());
-  };
-
-  _proto2.chain = function chain() {
-    return this;
-  };
-
-  _proto2.orChain = function orChain(op) {
-    return op();
-  };
-
-  _proto2.isJust = function isJust() {
-    return false;
-  };
-
-  _proto2.isNothing = function isNothing() {
-    return true;
-  };
-
-  _proto2.matchTap = function matchTap(op) {
-    return this.orTap(op.nothing);
-  };
-
-  _proto2.matchMap = function matchMap(op) {
-    return this.orMap(op.nothing);
-  };
-
-  _proto2.matchChain = function matchChain(op) {
-    return this.orChain(op.nothing);
-  };
-
-  return NothingClass;
-}();
-
-var staticNothing = /*#__PURE__*/new NothingClass();
-
-(function (Right) {
-  /**
-   * Standalone Right value extractor
-   *
-   * Userful for passing as a function to collection transformers
-   *
-   * @template R underlying value type
-   * @template L underlying error type
-   * @param right Right instance
-   * @returns underlying value
-   */
-  function right(right) {
-    return right.right;
-  }
-
-  Right.right = right;
-})(exports.Right || (exports.Right = {}));
-
-(function (Left) {
-  /**
-   * Standalone Left error extractor
-   *
-   * Userful for passing as a function to collection transformers
-   *
-   * @template R underlying value type
-   * @template L underlying error type
-   * @param left Left instance
-   * @returns underlying error
-   */
-  function left(left) {
-    return left.left;
-  }
-
-  Left.left = left;
-})(exports.Left || (exports.Left = {}));
-
-(function (Either) {
-  /**
-   * Right monad constructor
-   *
-   * @template R underlying value type
-   * @param value underlying value
-   * @returns 'right value'
-   */
-  function right(value) {
-    return new RightClass(value);
-  }
-
-  Either.right = right;
-  /**
-   * Left monad constructor
-   *
-   * @template L underlying error type
-   * @param error underlying error
-   * @returns 'left error'
-   */
-
-  function left(error) {
-    return new LeftClass(error);
-  }
-
-  Either.left = left;
-
-  function fromOptional(value, error) {
-    return typeof value !== 'undefined' ? Either.right(value) : Either.left(error);
-  }
-
-  Either.fromOptional = fromOptional;
-
-  function fromNullable(value, error) {
-    return Either.fromOptional(value, error).chain(function (v) {
-      return v !== null ? Either.right(value) : Either.left(error);
-    });
-  }
-
-  Either.fromNullable = fromNullable;
-  /**
-   * Standalone type guard for 'right'
-   *
-   * Userful for passing as a predicate to collection transformers
-   *
-   * @template R underlying value type
-   * @param either Either instance
-   * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')
-   */
-
-  function isRight(either) {
-    return either.isRight();
-  }
-
-  Either.isRight = isRight;
-  /**
-   * Standalone type guard for 'left'
-   *
-   * Userful for passing as a predicate to collection transformers
-   *
-   * @template R underlying value type
-   * @param either Either instance
-   * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')
-   */
-
-  function isLeft(either) {
-    return either.isLeft();
-  }
-
-  Either.isLeft = isLeft;
-  /**
-   * Standalone list predicate
-   *
-   * @param eithers a list of Either
-   * @returns true in case every list element is Right
-   */
-
-  function everyRight(eithers) {
-    return eithers.every(Either.isRight);
-  }
-
-  Either.everyRight = everyRight;
-  /**
-   * Standalone list predicate
-   *
-   * @param eithers a list of Either
-   * @returns true in case at least one list element is Right
-   */
-
-  function someRight(eithers) {
-    return eithers.some(Either.isRight);
-  }
-
-  Either.someRight = someRight;
-  /**
-   * Standalone list predicate
-   *
-   * @param eithers a list of Either
-   * @returns true in case every list element is Left
-   */
-
-  function everyLeft(eithers) {
-    return eithers.every(Either.isLeft);
-  }
-
-  Either.everyLeft = everyLeft;
-  /**
-   * Standalone list predicate
-   *
-   * @param eithers a list of Either
-   * @returns true in case at least one list element is Left
-   */
-
-  function someLeft(eithers) {
-    return eithers.some(Either.isLeft);
-  }
-
-  Either.someLeft = someLeft;
-})(exports.Either || (exports.Either = {})); /// --------------------------------------------------------------------------------------
-/// Private section
-/// --------------------------------------------------------------------------------------
-
-
-var RightClass = /*#__PURE__*/function () {
-  function RightClass(right) {
-    this.right = right;
-  }
-
-  var _proto = RightClass.prototype;
-
-  _proto.tap = function tap(op) {
-    op(this.right);
-    return this;
-  };
-
-  _proto.orTap = function orTap() {
-    return this;
-  };
-
-  _proto.map = function map(op) {
-    return exports.Either.right(op(this.right));
-  };
-
-  _proto.orMap = function orMap() {
-    return this;
-  };
-
-  _proto.chain = function chain(op) {
-    return op(this.right);
-  };
-
-  _proto.orChain = function orChain() {
-    return this;
-  };
-
-  _proto.isRight = function isRight() {
-    return true;
-  };
-
-  _proto.isLeft = function isLeft() {
-    return false;
-  };
-
-  _proto.matchTap = function matchTap(op) {
-    return this.tap(op.right);
-  };
-
-  _proto.matchMap = function matchMap(op) {
-    return this.map(op.right);
-  };
-
-  _proto.matchChain = function matchChain(op) {
-    return this.chain(op.right);
-  };
-
-  return RightClass;
-}();
-
-var LeftClass = /*#__PURE__*/function () {
-  function LeftClass(left) {
-    this.left = left;
-  }
-
-  var _proto2 = LeftClass.prototype;
-
-  _proto2.tap = function tap() {
-    return this;
-  };
-
-  _proto2.orTap = function orTap(op) {
-    op(this.left);
-    return this;
-  };
-
-  _proto2.map = function map() {
-    return this;
-  };
-
-  _proto2.orMap = function orMap(op) {
-    return exports.Either.right(op(this.left));
-  };
-
-  _proto2.chain = function chain() {
-    return this;
-  };
-
-  _proto2.orChain = function orChain(op) {
-    return op(this.left);
-  };
-
-  _proto2.isRight = function isRight() {
-    return false;
-  };
-
-  _proto2.isLeft = function isLeft() {
-    return true;
-  };
-
-  _proto2.matchTap = function matchTap(op) {
-    return this.orTap(op.left);
-  };
-
-  _proto2.matchMap = function matchMap(op) {
-    return this.orMap(op.left);
-  };
-
-  _proto2.matchChain = function matchChain(op) {
-    return this.orChain(op.left);
-  };
-
-  return LeftClass;
-}();
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-        args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-
-      _next(undefined);
-    });
-  };
-}
-
-function createCommonjsModule(fn, module) {
-	return module = { exports: {} }, fn(module, module.exports), module.exports;
-}
-
-var runtime_1 = createCommonjsModule(function (module) {
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var runtime = (function (exports) {
-
-  var Op = Object.prototype;
-  var hasOwn = Op.hasOwnProperty;
-  var undefined$1; // More compressible than void 0.
-  var $Symbol = typeof Symbol === "function" ? Symbol : {};
-  var iteratorSymbol = $Symbol.iterator || "@@iterator";
-  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
-  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-
-  function define(obj, key, value) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-    return obj[key];
-  }
-  try {
-    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
-    define({}, "");
-  } catch (err) {
-    define = function(obj, key, value) {
-      return obj[key] = value;
-    };
-  }
-
-  function wrap(innerFn, outerFn, self, tryLocsList) {
-    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
-    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
-    var generator = Object.create(protoGenerator.prototype);
-    var context = new Context(tryLocsList || []);
-
-    // The ._invoke method unifies the implementations of the .next,
-    // .throw, and .return methods.
-    generator._invoke = makeInvokeMethod(innerFn, self, context);
-
-    return generator;
-  }
-  exports.wrap = wrap;
-
-  // Try/catch helper to minimize deoptimizations. Returns a completion
-  // record like context.tryEntries[i].completion. This interface could
-  // have been (and was previously) designed to take a closure to be
-  // invoked without arguments, but in all the cases we care about we
-  // already have an existing method we want to call, so there's no need
-  // to create a new function object. We can even get away with assuming
-  // the method takes exactly one argument, since that happens to be true
-  // in every case, so we don't have to touch the arguments object. The
-  // only additional allocation required is the completion record, which
-  // has a stable shape and so hopefully should be cheap to allocate.
-  function tryCatch(fn, obj, arg) {
-    try {
-      return { type: "normal", arg: fn.call(obj, arg) };
-    } catch (err) {
-      return { type: "throw", arg: err };
-    }
-  }
-
-  var GenStateSuspendedStart = "suspendedStart";
-  var GenStateSuspendedYield = "suspendedYield";
-  var GenStateExecuting = "executing";
-  var GenStateCompleted = "completed";
-
-  // Returning this object from the innerFn has the same effect as
-  // breaking out of the dispatch switch statement.
-  var ContinueSentinel = {};
-
-  // Dummy constructor functions that we use as the .constructor and
-  // .constructor.prototype properties for functions that return Generator
-  // objects. For full spec compliance, you may wish to configure your
-  // minifier not to mangle the names of these two functions.
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-
-  // This is a polyfill for %IteratorPrototype% for environments that
-  // don't natively support it.
-  var IteratorPrototype = {};
-  IteratorPrototype[iteratorSymbol] = function () {
-    return this;
-  };
-
-  var getProto = Object.getPrototypeOf;
-  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-  if (NativeIteratorPrototype &&
-      NativeIteratorPrototype !== Op &&
-      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
-    // This environment has a native %IteratorPrototype%; use it instead
-    // of the polyfill.
-    IteratorPrototype = NativeIteratorPrototype;
-  }
-
-  var Gp = GeneratorFunctionPrototype.prototype =
-    Generator.prototype = Object.create(IteratorPrototype);
-  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
-  GeneratorFunctionPrototype.constructor = GeneratorFunction;
-  GeneratorFunction.displayName = define(
-    GeneratorFunctionPrototype,
-    toStringTagSymbol,
-    "GeneratorFunction"
-  );
-
-  // Helper for defining the .next, .throw, and .return methods of the
-  // Iterator interface in terms of a single ._invoke method.
-  function defineIteratorMethods(prototype) {
-    ["next", "throw", "return"].forEach(function(method) {
-      define(prototype, method, function(arg) {
-        return this._invoke(method, arg);
-      });
-    });
-  }
-
-  exports.isGeneratorFunction = function(genFun) {
-    var ctor = typeof genFun === "function" && genFun.constructor;
-    return ctor
-      ? ctor === GeneratorFunction ||
-        // For the native GeneratorFunction constructor, the best we can
-        // do is to check its .name property.
-        (ctor.displayName || ctor.name) === "GeneratorFunction"
-      : false;
-  };
-
-  exports.mark = function(genFun) {
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-    } else {
-      genFun.__proto__ = GeneratorFunctionPrototype;
-      define(genFun, toStringTagSymbol, "GeneratorFunction");
-    }
-    genFun.prototype = Object.create(Gp);
-    return genFun;
-  };
-
-  // Within the body of any async function, `await x` is transformed to
-  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
-  // `hasOwn.call(value, "__await")` to determine if the yielded value is
-  // meant to be awaited.
-  exports.awrap = function(arg) {
-    return { __await: arg };
-  };
-
-  function AsyncIterator(generator, PromiseImpl) {
-    function invoke(method, arg, resolve, reject) {
-      var record = tryCatch(generator[method], generator, arg);
-      if (record.type === "throw") {
-        reject(record.arg);
-      } else {
-        var result = record.arg;
-        var value = result.value;
-        if (value &&
-            typeof value === "object" &&
-            hasOwn.call(value, "__await")) {
-          return PromiseImpl.resolve(value.__await).then(function(value) {
-            invoke("next", value, resolve, reject);
-          }, function(err) {
-            invoke("throw", err, resolve, reject);
-          });
-        }
-
-        return PromiseImpl.resolve(value).then(function(unwrapped) {
-          // When a yielded Promise is resolved, its final value becomes
-          // the .value of the Promise<{value,done}> result for the
-          // current iteration.
-          result.value = unwrapped;
-          resolve(result);
-        }, function(error) {
-          // If a rejected Promise was yielded, throw the rejection back
-          // into the async generator function so it can be handled there.
-          return invoke("throw", error, resolve, reject);
-        });
-      }
-    }
-
-    var previousPromise;
-
-    function enqueue(method, arg) {
-      function callInvokeWithMethodAndArg() {
-        return new PromiseImpl(function(resolve, reject) {
-          invoke(method, arg, resolve, reject);
-        });
-      }
-
-      return previousPromise =
-        // If enqueue has been called before, then we want to wait until
-        // all previous Promises have been resolved before calling invoke,
-        // so that results are always delivered in the correct order. If
-        // enqueue has not been called before, then it is important to
-        // call invoke immediately, without waiting on a callback to fire,
-        // so that the async generator function has the opportunity to do
-        // any necessary setup in a predictable way. This predictability
-        // is why the Promise constructor synchronously invokes its
-        // executor callback, and why async functions synchronously
-        // execute code before the first await. Since we implement simple
-        // async functions in terms of async generators, it is especially
-        // important to get this right, even though it requires care.
-        previousPromise ? previousPromise.then(
-          callInvokeWithMethodAndArg,
-          // Avoid propagating failures to Promises returned by later
-          // invocations of the iterator.
-          callInvokeWithMethodAndArg
-        ) : callInvokeWithMethodAndArg();
-    }
-
-    // Define the unified helper method that is used to implement .next,
-    // .throw, and .return (see defineIteratorMethods).
-    this._invoke = enqueue;
-  }
-
-  defineIteratorMethods(AsyncIterator.prototype);
-  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
-    return this;
-  };
-  exports.AsyncIterator = AsyncIterator;
-
-  // Note that simple async functions are implemented on top of
-  // AsyncIterator objects; they just return a Promise for the value of
-  // the final result produced by the iterator.
-  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-    if (PromiseImpl === void 0) PromiseImpl = Promise;
-
-    var iter = new AsyncIterator(
-      wrap(innerFn, outerFn, self, tryLocsList),
-      PromiseImpl
-    );
-
-    return exports.isGeneratorFunction(outerFn)
-      ? iter // If outerFn is a generator, return the full iterator.
-      : iter.next().then(function(result) {
-          return result.done ? result.value : iter.next();
-        });
-  };
-
-  function makeInvokeMethod(innerFn, self, context) {
-    var state = GenStateSuspendedStart;
-
-    return function invoke(method, arg) {
-      if (state === GenStateExecuting) {
-        throw new Error("Generator is already running");
-      }
-
-      if (state === GenStateCompleted) {
-        if (method === "throw") {
-          throw arg;
-        }
-
-        // Be forgiving, per 25.3.3.3.3 of the spec:
-        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
-        return doneResult();
-      }
-
-      context.method = method;
-      context.arg = arg;
-
-      while (true) {
-        var delegate = context.delegate;
-        if (delegate) {
-          var delegateResult = maybeInvokeDelegate(delegate, context);
-          if (delegateResult) {
-            if (delegateResult === ContinueSentinel) continue;
-            return delegateResult;
-          }
-        }
-
-        if (context.method === "next") {
-          // Setting context._sent for legacy support of Babel's
-          // function.sent implementation.
-          context.sent = context._sent = context.arg;
-
-        } else if (context.method === "throw") {
-          if (state === GenStateSuspendedStart) {
-            state = GenStateCompleted;
-            throw context.arg;
-          }
-
-          context.dispatchException(context.arg);
-
-        } else if (context.method === "return") {
-          context.abrupt("return", context.arg);
-        }
-
-        state = GenStateExecuting;
-
-        var record = tryCatch(innerFn, self, context);
-        if (record.type === "normal") {
-          // If an exception is thrown from innerFn, we leave state ===
-          // GenStateExecuting and loop back for another invocation.
-          state = context.done
-            ? GenStateCompleted
-            : GenStateSuspendedYield;
-
-          if (record.arg === ContinueSentinel) {
-            continue;
-          }
-
-          return {
-            value: record.arg,
-            done: context.done
-          };
-
-        } else if (record.type === "throw") {
-          state = GenStateCompleted;
-          // Dispatch the exception by looping back around to the
-          // context.dispatchException(context.arg) call above.
-          context.method = "throw";
-          context.arg = record.arg;
-        }
-      }
-    };
-  }
-
-  // Call delegate.iterator[context.method](context.arg) and handle the
-  // result, either by returning a { value, done } result from the
-  // delegate iterator, or by modifying context.method and context.arg,
-  // setting context.delegate to null, and returning the ContinueSentinel.
-  function maybeInvokeDelegate(delegate, context) {
-    var method = delegate.iterator[context.method];
-    if (method === undefined$1) {
-      // A .throw or .return when the delegate iterator has no .throw
-      // method always terminates the yield* loop.
-      context.delegate = null;
-
-      if (context.method === "throw") {
-        // Note: ["return"] must be used for ES3 parsing compatibility.
-        if (delegate.iterator["return"]) {
-          // If the delegate iterator has a return method, give it a
-          // chance to clean up.
-          context.method = "return";
-          context.arg = undefined$1;
-          maybeInvokeDelegate(delegate, context);
-
-          if (context.method === "throw") {
-            // If maybeInvokeDelegate(context) changed context.method from
-            // "return" to "throw", let that override the TypeError below.
-            return ContinueSentinel;
-          }
-        }
-
-        context.method = "throw";
-        context.arg = new TypeError(
-          "The iterator does not provide a 'throw' method");
-      }
-
-      return ContinueSentinel;
-    }
-
-    var record = tryCatch(method, delegate.iterator, context.arg);
-
-    if (record.type === "throw") {
-      context.method = "throw";
-      context.arg = record.arg;
-      context.delegate = null;
-      return ContinueSentinel;
-    }
-
-    var info = record.arg;
-
-    if (! info) {
-      context.method = "throw";
-      context.arg = new TypeError("iterator result is not an object");
-      context.delegate = null;
-      return ContinueSentinel;
-    }
-
-    if (info.done) {
-      // Assign the result of the finished delegate to the temporary
-      // variable specified by delegate.resultName (see delegateYield).
-      context[delegate.resultName] = info.value;
-
-      // Resume execution at the desired location (see delegateYield).
-      context.next = delegate.nextLoc;
-
-      // If context.method was "throw" but the delegate handled the
-      // exception, let the outer generator proceed normally. If
-      // context.method was "next", forget context.arg since it has been
-      // "consumed" by the delegate iterator. If context.method was
-      // "return", allow the original .return call to continue in the
-      // outer generator.
-      if (context.method !== "return") {
-        context.method = "next";
-        context.arg = undefined$1;
-      }
-
-    } else {
-      // Re-yield the result returned by the delegate method.
-      return info;
-    }
-
-    // The delegate iterator is finished, so forget it and continue with
-    // the outer generator.
-    context.delegate = null;
-    return ContinueSentinel;
-  }
-
-  // Define Generator.prototype.{next,throw,return} in terms of the
-  // unified ._invoke helper method.
-  defineIteratorMethods(Gp);
-
-  define(Gp, toStringTagSymbol, "Generator");
-
-  // A Generator should always return itself as the iterator object when the
-  // @@iterator function is called on it. Some browsers' implementations of the
-  // iterator prototype chain incorrectly implement this, causing the Generator
-  // object to not be returned from this call. This ensures that doesn't happen.
-  // See https://github.com/facebook/regenerator/issues/274 for more details.
-  Gp[iteratorSymbol] = function() {
-    return this;
-  };
-
-  Gp.toString = function() {
-    return "[object Generator]";
-  };
-
-  function pushTryEntry(locs) {
-    var entry = { tryLoc: locs[0] };
-
-    if (1 in locs) {
-      entry.catchLoc = locs[1];
-    }
-
-    if (2 in locs) {
-      entry.finallyLoc = locs[2];
-      entry.afterLoc = locs[3];
-    }
-
-    this.tryEntries.push(entry);
-  }
-
-  function resetTryEntry(entry) {
-    var record = entry.completion || {};
-    record.type = "normal";
-    delete record.arg;
-    entry.completion = record;
-  }
-
-  function Context(tryLocsList) {
-    // The root entry object (effectively a try statement without a catch
-    // or a finally block) gives us a place to store values thrown from
-    // locations where there is no enclosing try statement.
-    this.tryEntries = [{ tryLoc: "root" }];
-    tryLocsList.forEach(pushTryEntry, this);
-    this.reset(true);
-  }
-
-  exports.keys = function(object) {
-    var keys = [];
-    for (var key in object) {
-      keys.push(key);
-    }
-    keys.reverse();
-
-    // Rather than returning an object with a next method, we keep
-    // things simple and return the next function itself.
-    return function next() {
-      while (keys.length) {
-        var key = keys.pop();
-        if (key in object) {
-          next.value = key;
-          next.done = false;
-          return next;
-        }
-      }
-
-      // To avoid creating an additional object, we just hang the .value
-      // and .done properties off the next function object itself. This
-      // also ensures that the minifier will not anonymize the function.
-      next.done = true;
-      return next;
-    };
-  };
-
-  function values(iterable) {
-    if (iterable) {
-      var iteratorMethod = iterable[iteratorSymbol];
-      if (iteratorMethod) {
-        return iteratorMethod.call(iterable);
-      }
-
-      if (typeof iterable.next === "function") {
-        return iterable;
-      }
-
-      if (!isNaN(iterable.length)) {
-        var i = -1, next = function next() {
-          while (++i < iterable.length) {
-            if (hasOwn.call(iterable, i)) {
-              next.value = iterable[i];
-              next.done = false;
-              return next;
-            }
-          }
-
-          next.value = undefined$1;
-          next.done = true;
-
-          return next;
-        };
-
-        return next.next = next;
-      }
-    }
-
-    // Return an iterator with no values.
-    return { next: doneResult };
-  }
-  exports.values = values;
-
-  function doneResult() {
-    return { value: undefined$1, done: true };
-  }
-
-  Context.prototype = {
-    constructor: Context,
-
-    reset: function(skipTempReset) {
-      this.prev = 0;
-      this.next = 0;
-      // Resetting context._sent for legacy support of Babel's
-      // function.sent implementation.
-      this.sent = this._sent = undefined$1;
-      this.done = false;
-      this.delegate = null;
-
-      this.method = "next";
-      this.arg = undefined$1;
-
-      this.tryEntries.forEach(resetTryEntry);
-
-      if (!skipTempReset) {
-        for (var name in this) {
-          // Not sure about the optimal order of these conditions:
-          if (name.charAt(0) === "t" &&
-              hasOwn.call(this, name) &&
-              !isNaN(+name.slice(1))) {
-            this[name] = undefined$1;
-          }
-        }
-      }
-    },
-
-    stop: function() {
-      this.done = true;
-
-      var rootEntry = this.tryEntries[0];
-      var rootRecord = rootEntry.completion;
-      if (rootRecord.type === "throw") {
-        throw rootRecord.arg;
-      }
-
-      return this.rval;
-    },
-
-    dispatchException: function(exception) {
-      if (this.done) {
-        throw exception;
-      }
-
-      var context = this;
-      function handle(loc, caught) {
-        record.type = "throw";
-        record.arg = exception;
-        context.next = loc;
-
-        if (caught) {
-          // If the dispatched exception was caught by a catch block,
-          // then let that catch block handle the exception normally.
-          context.method = "next";
-          context.arg = undefined$1;
-        }
-
-        return !! caught;
-      }
-
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        var record = entry.completion;
-
-        if (entry.tryLoc === "root") {
-          // Exception thrown outside of any try block that could handle
-          // it, so set the completion value of the entire function to
-          // throw the exception.
-          return handle("end");
-        }
-
-        if (entry.tryLoc <= this.prev) {
-          var hasCatch = hasOwn.call(entry, "catchLoc");
-          var hasFinally = hasOwn.call(entry, "finallyLoc");
-
-          if (hasCatch && hasFinally) {
-            if (this.prev < entry.catchLoc) {
-              return handle(entry.catchLoc, true);
-            } else if (this.prev < entry.finallyLoc) {
-              return handle(entry.finallyLoc);
-            }
-
-          } else if (hasCatch) {
-            if (this.prev < entry.catchLoc) {
-              return handle(entry.catchLoc, true);
-            }
-
-          } else if (hasFinally) {
-            if (this.prev < entry.finallyLoc) {
-              return handle(entry.finallyLoc);
-            }
-
-          } else {
-            throw new Error("try statement without catch or finally");
-          }
-        }
-      }
-    },
-
-    abrupt: function(type, arg) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc <= this.prev &&
-            hasOwn.call(entry, "finallyLoc") &&
-            this.prev < entry.finallyLoc) {
-          var finallyEntry = entry;
-          break;
-        }
-      }
-
-      if (finallyEntry &&
-          (type === "break" ||
-           type === "continue") &&
-          finallyEntry.tryLoc <= arg &&
-          arg <= finallyEntry.finallyLoc) {
-        // Ignore the finally entry if control is not jumping to a
-        // location outside the try/catch block.
-        finallyEntry = null;
-      }
-
-      var record = finallyEntry ? finallyEntry.completion : {};
-      record.type = type;
-      record.arg = arg;
-
-      if (finallyEntry) {
-        this.method = "next";
-        this.next = finallyEntry.finallyLoc;
-        return ContinueSentinel;
-      }
-
-      return this.complete(record);
-    },
-
-    complete: function(record, afterLoc) {
-      if (record.type === "throw") {
-        throw record.arg;
-      }
-
-      if (record.type === "break" ||
-          record.type === "continue") {
-        this.next = record.arg;
-      } else if (record.type === "return") {
-        this.rval = this.arg = record.arg;
-        this.method = "return";
-        this.next = "end";
-      } else if (record.type === "normal" && afterLoc) {
-        this.next = afterLoc;
-      }
-
-      return ContinueSentinel;
-    },
-
-    finish: function(finallyLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.finallyLoc === finallyLoc) {
-          this.complete(entry.completion, entry.afterLoc);
-          resetTryEntry(entry);
-          return ContinueSentinel;
-        }
-      }
-    },
-
-    "catch": function(tryLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc === tryLoc) {
-          var record = entry.completion;
-          if (record.type === "throw") {
-            var thrown = record.arg;
-            resetTryEntry(entry);
-          }
-          return thrown;
-        }
-      }
-
-      // The context.catch method must only be called with a location
-      // argument that corresponds to a known catch block.
-      throw new Error("illegal catch attempt");
-    },
-
-    delegateYield: function(iterable, resultName, nextLoc) {
-      this.delegate = {
-        iterator: values(iterable),
-        resultName: resultName,
-        nextLoc: nextLoc
-      };
-
-      if (this.method === "next") {
-        // Deliberately forget the last sent value so that we don't
-        // accidentally pass it on to the delegate.
-        this.arg = undefined$1;
-      }
-
-      return ContinueSentinel;
-    }
-  };
-
-  // Regardless of whether this script is executing as a CommonJS module
-  // or not, return the runtime object so that we can declare the variable
-  // regeneratorRuntime in the outer scope, which allows this module to be
-  // injected easily by `bin/regenerator --include-runtime script.js`.
-  return exports;
-
-}(
-  // If this script is executing as a CommonJS module, use module.exports
-  // as the regeneratorRuntime namespace. Otherwise create a new empty
-  // object. Either way, the resulting object will be used to initialize
-  // the regeneratorRuntime variable at the top of this file.
-   module.exports 
-));
-
-try {
-  regeneratorRuntime = runtime;
-} catch (accidentalStrictMode) {
-  // This module should not be running in strict mode, so the above
-  // assignment should always work unless something is misconfigured. Just
-  // in case runtime.js accidentally runs in strict mode, we can escape
-  // strict mode using a global Function call. This could conceivably fail
-  // if a Content Security Policy forbids using Function, but in that case
-  // the proper solution is to fix the accidental strict mode problem. If
-  // you've misconfigured your bundler to force strict mode and applied a
-  // CSP to forbid Function, and you're not willing to fix either of those
-  // problems, please detail your unique predicament in a GitHub issue.
-  Function("r", "regeneratorRuntime = r")(runtime);
-}
-});
-
-(function (Task) {
-  /**
-   * Custom task monad constructor
-   *
-   * @template R returned task's resolve type
-   * @param invoke promise defining task execution
-   * @param cancel cancelation function
-   * @returns task resolving to resolve value of invoke
-   *
-   * @note low-level primitive for creating custom tasks, not intended for general use
-   */
-  function create(invoke, cancel) {
-    return new TaskClass(invoke, cancel);
-  }
-
-  Task.create = create;
-  /**
-   * Invariant task constructor creating resolved task from plain value
-   *
-   * @template R returned task's resolve type
-   * @param value value to be returned upon awaiting
-   * @returns task resolving to specified value
-   */
-
-  function resolved(value) {
-    return Task.create(Promise.resolve(exports.Maybe.just(exports.Either.right(value))), function () {});
-  }
-
-  Task.resolved = resolved;
-  /**
-   * Invariant task constructor creating rejected task from error value
-   *
-   * @template R returned task's resolve type
-   * @param error error to be returned upon awaiting
-   * @returns task resolving to specified value
-   */
-
-  function rejected(error) {
-    return Task.create(Promise.resolve(exports.Maybe.just(exports.Either.left(error))), function () {});
-  }
-
-  Task.rejected = rejected;
-  /**
-   * Invariant task constructor creating canceled task
-   *
-   * @template R returned task's resolve type
-   * @returns task resolving to specified value
-   */
-
-  function canceled() {
-    return Task.create(Promise.resolve(exports.Maybe.nothing()), function () {});
-  }
-
-  Task.canceled = canceled;
-  /**
-   * Lift from promise to task resolving to that promise result
-   *
-   * Userfull for converting promises to tasks
-   * If converted task is canceled or failed externally return value will be ignored without side-effects
-   * All tasks are no-trowing by default, any occured errors are returned as Left<any>
-   *
-   * @template R returned task resolve type
-   * @param promise promise to be resolved
-   * @returns task resolving to specified promise value
-   *
-   * @example
-   * ```typescript
-   * const task = Task.fromPromise(someAsyncOperation('someData')).map((result) => result.length);
-   * ```
-   */
-
-  function fromPromise(promise) {
-    var _resolver = resolver(),
-        resolve = _resolver[0],
-        setResolve = _resolver[1];
-
-    return Task.create(new Promise(function (_resolve) {
-      setResolve(_resolve);
-      promise.then(exports.Either.right, exports.Either.left).then(exports.Maybe.just).then(resolve);
-    }), function (error) {
-      return resolve(error.map(exports.Either.left));
-    });
-  }
-
-  Task.fromPromise = fromPromise;
-  /**
-   * Lift from sync function to task resolving to said function result
-   *
-   * Generally, functions are not considered tasks as they cannot be interrupted in any way
-   * However there may be cases when impure function performs actions leading to cancelling or failing the task they are called from
-   * Without such wrapper such cases would lead to ignoring said cancelation and continuilg task chain
-   * This function is mostly used internally and is not expected to be widely used except of some edge scenarios
-   *
-   * If converted task is canceled or failed externally return value will be ignored without side-effects
-   * All tasks are no-trowing by default, any occured errors are returned as Left<any>
-   *
-   * @template R returned task resolve type
-   * @param producer function to be wrapped to a task
-   * @param cancelRef reference object allowing to set cancelation function prior to invoking function
-   * @returns task resolving to the specified function's result
-   *
-   * @example
-   * ```typescript
-   * const cancelRef = { cancel: () => {} };
-   *
-   * const task = Task.fromFunction(() => someFunction('someData'), cancelRef).map((result) => result.length);
-   * ```
-   */
-
-  function fromFunction(producer, cancelRef) {
-    var _resolver2 = resolver(),
-        resolve = _resolver2[0],
-        setResolve = _resolver2[1];
-
-    var cancel = function cancel(error) {
-      return resolve(error.map(exports.Either.left));
-    };
-
-    cancelRef.cancel = cancel;
-    return Task.create(new Promise(function (_resolve) {
-      setResolve(_resolve);
-
-      try {
-        resolve(exports.Maybe.just(exports.Either.right(producer())));
-      } catch (e) {
-        resolve(exports.Maybe.just(exports.Either.left(e)));
-      }
-    }), cancel);
-  }
-
-  Task.fromFunction = fromFunction;
-  /**
-   * Convinience shortcut for yielding async functions as tasks
-   *
-   * @template R returned generator resolve type
-   * @param promise promise to be resolved
-   * @returns generator to be be used with yield*
-   */
-
-  function promiseGenerator(promise) {
-    return Task.fromPromise(promise).generator();
-  }
-
-  Task.promiseGenerator = promiseGenerator;
-  /**
-   * Lift from function returning value/promise to function returning task resolving to that value
-   *
-   * Userfull for converting exising async functions to task functions for further use
-   *
-   * @template A returned function's argument types
-   * @template R returned function's result task's resolve type
-   * @param promiseFunction function returning promise or plain value to be resolved
-   * @returns task function wrapping specified promise function
-   * @see Task.fromPromise
-   *
-   * @example
-   * ```typescript
-   * const taskFunction = liftPromiseFunction(someAsyncOperation);
-   *
-   * const task = taskFunction('someData').map((result) => result.length);
-   * ```
-   */
-
-  function lift(promiseFunction) {
-    return function () {
-      return Task.fromPromise(promiseFunction.apply(void 0, arguments));
-    };
-  }
-
-  Task.lift = lift;
-  /**
-   * Create compound task from generator function
-   *
-   * Applying yield to task within the generator function awaits the task and returns underlying value in case of success
-   * However the convinient option for typescript is to use ```yield* task.generator()``` as othervise one may have to deal with union types
-   *
-   * In case of failure an error is thrown and may be caught by try-catch
-   *
-   * If error is not caught the task is interrupted and returns 'just left error' immediately. In case of cancelation the task is interrupted and returns 'nothing' immediately
-   *
-   * @template TT yielded task type
-   * @template R returned task resolve type
-   * @param taskGeneratorFunction task generator function
-   * @returns task resolving to generator's return type
-   *
-   * @note compound task execution is interrupted only at yield statements, so despite returning immediately any promise-based chains would continue running until the first yield
-   * @note due to type unpredictability you HAVE to use ```.generator()``` together with yield* to avoid type issues, despite the fact that task may be yielded directly
-   *
-   * @example
-   * ```typescript
-   * const task = Task.generate(function*() {
-   *   try {
-   *     const value1 = yield* delayedValueTask('data', 400).generator();
-   *
-   *     const value2 = yield* delayedValueTask(value1.length, 300).generator();
-   *
-   *     return value2;
-   *   } catch (e) {
-   *     return -1;
-   *   }
-   * });
-   * ```
-   */
-
-  function generate(taskGeneratorFunction) {
-    var generator = taskGeneratorFunction();
-
-    var sequentor = function sequentor(next) {
-      return next.done ? Task.resolved(next.value) : next.value.matchChain({
-        resolved: function resolved(value) {
-          return sequentor(generator.next(value));
-        },
-        rejected: function rejected(error) {
-          return sequentor(generator["throw"](error));
-        },
-        canceled: Task.canceled
-      });
-    };
-
-    return Task.resolved(undefined).chain(function () {
-      return sequentor(generator.next());
-    });
-  }
-
-  Task.generate = generate;
-  /**
-   * Generic timeout task
-   *
-   * Usefull for creating delays in task chains or implementing limiting tasks
-   *
-   * @param delay duration in ms after that the task resolves to void
-   * @returns task resolving to void (undefined) after specified delay
-   *
-   * @example
-   * ```typescript
-   * const delayedValueTask = <T>(value: T, delay: number) => Task.timeout(delay).map(() => value);
-   * // ... //
-   * const value = yield* delayedValueTask(42, 1000).generator();
-   *
-   * console.log("It's past 1 second and here's a value:", value)
-   * ```
-   */
-
-  function timeout(delay) {
-    return fromCallback(function (resolve) {
-      return setTimeout(function () {
-        return resolve();
-      }, delay);
-    }, clearTimeout);
-  }
-
-  Task.timeout = timeout;
-  /**
-   * Generic callback task
-   *
-   * Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFuction
-   *
-   * @param create task body with success and error callbacks
-   * @param cancel cancelation function intended for stopping task execution
-   * @returns task resolving to success value
-   *
-   * @example
-   * ```typescript
-   * export function timeout(delay: number) {
-   *   return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);
-   * }
-   * ```
-   */
-
-  function fromCallback(create, cancel) {
-    var handler;
-
-    var _resolver3 = resolver(),
-        resolve = _resolver3[0],
-        setResolve = _resolver3[1];
-
-    return Task.create(new Promise(function (_resolve) {
-      setResolve(_resolve);
-      handler = create(function (r) {
-        return resolve(exports.Maybe.just(exports.Either.right(r)));
-      }, function (e) {
-        return resolve(exports.Maybe.just(exports.Either.left(e)));
-      });
-    }), function (error) {
-      resolve(error.map(exports.Either.left));
-      cancel(handler);
-    });
-  }
-
-  Task.fromCallback = fromCallback;
-  /**
-   * Start multiple tasks one after another
-   *
-   * @param taskFunctions list of task functions (without arguments)
-   * @returns composite task invoring every task in order and resolving to the list of results
-   */
-
-  function sequence(taskFunctions) {
-    return Array.from(taskFunctions).reduce(function (prev, taskFunction) {
-      return prev.chain(function (list) {
-        return taskFunction().map(function (value) {
-          return list.concat(value);
-        });
-      });
-    }, Task.resolved([]));
-  }
-
-  Task.sequence = sequence;
-  /**
-   * Execute all tasks in parallel and return list of results
-   *
-   * Resulting task resolves when all tasks are resolved, returning list of tasks results maintaining result order
-   * In case of failure (external or internal) resulting task is immediately immediately rejected with that error and all pending tasks are canceled
-   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks
-   *
-   * @note direct equivalent of Promise.all
-   *
-   * @template T underlying task type
-   * @param tasks iterable of tasks to execute
-   * @retuirns task resolving to the list of results
-   */
-
-  function all(tasks) {
-    var _resolver4 = resolver(),
-        resolve = _resolver4[0],
-        setResolve = _resolver4[1];
-
-    var taskArray = Array.from(tasks);
-
-    var cancel = function cancel(error) {
-      return taskArray.forEach(function (task) {
-        return task._cancel(error);
-      });
-    };
-
-    var list = taskArray.map(exports.Maybe.nothing);
-
-    var _resolved = function resolved(value, i) {
-      list[i] = exports.Maybe.just(value);
-
-      if (exports.Maybe.everyJust(list)) {
-        resolve(exports.Maybe.just(exports.Either.right(list.map(exports.Just.just))));
-      }
-    };
-
-    var _rejected = function rejected(error) {
-      resolve(error.map(exports.Either.left));
-      cancel(error);
-    };
-
-    return Task.create(new Promise(function (_resolve) {
-      setResolve(_resolve);
-      taskArray.map(function (task, i) {
-        return task.matchTap({
-          resolved: function resolved(value) {
-            return _resolved(value, i);
-          },
-          rejected: function rejected(error) {
-            return _rejected(exports.Maybe.just(error));
-          },
-          canceled: function canceled() {
-            return _rejected(exports.Maybe.nothing());
-          }
-        });
-      });
-    }), cancel);
-  }
-
-  Task.all = all;
-  /**
-   * Execute all tasks in parallel and return the result of the first successful one
-   *
-   * Resulting task resolves when the first tasks is successfuly resolved, returning it's result
-   * In case of external task rejecttion all tasks are rejected with that error and resulting task is rejected with an array of errors
-   * In case of internal task rejection the execution is continued untill fthe first task resolves succesfully or all the tasks are rejected this way resulting task is rejected with an array of errors
-   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks
-   *
-   * @note direct equivalent of Promise.any
-   *
-   * @template T underlying task type
-   * @param tasks iterable of tasks to execute
-   * @retuirns task resolving to the result of first successfull task
-   */
-
-  function any(tasks) {
-    var _resolver5 = resolver(),
-        resolve = _resolver5[0],
-        setResolve = _resolver5[1];
-
-    var taskArray = Array.from(tasks);
-
-    var cancel = function cancel(error) {
-      return taskArray.forEach(function (task) {
-        return task._cancel(error);
-      });
-    };
-
-    var list = taskArray.map(exports.Maybe.nothing);
-
-    var _resolved2 = function resolved(value) {
-      resolve(value.map(exports.Either.right));
-      cancel(exports.Maybe.nothing());
-    };
-
-    var _rejected2 = function rejected(error, i) {
-      list[i] = exports.Maybe.just(error);
-
-      if (exports.Maybe.everyJust(list)) {
-        resolve(exports.Maybe.just(exports.Either.left(list.map(exports.Just.just))));
-      }
-    };
-
-    return Task.create(new Promise(function (_resolve) {
-      setResolve(_resolve);
-      taskArray.map(function (task, i) {
-        return task.matchTap({
-          resolved: function resolved(value) {
-            return _resolved2(exports.Maybe.just(value));
-          },
-          rejected: function rejected(error) {
-            return _rejected2(error, i);
-          },
-          canceled: function canceled() {
-            return _resolved2(exports.Maybe.nothing());
-          }
-        });
-      });
-    }), cancel);
-  }
-
-  Task.any = any;
-  /**
-   * Limit task execution based on another task
-   *
-   * If the second task resolves sooner than the first, resulting task is canceled
-   * Otherwise the resulting task resolves together with the first one
-   *
-   * @param task task to limit
-   * @param limitTask limiting task
-   * @returns task limites according to limitTask
-   */
-
-  function limit(task, limitTask) {
-    return Task.any([task, limitTask.chain(Task.canceled)]).chainRejected(function (errors) {
-      return Task.rejected(errors[0]);
-    });
-  }
-
-  Task.limit = limit;
-  /**
-   * Repeat task untill successful
-   *
-   * Given task is re-generated in case of failure (both external and internal)
-   * Resulting task is still cancelable by standard means
-   *
-   * @param taskFunction task preoducing function
-   */
-
-  function repeat(taskFunction) {
-    var sequentor = function sequentor() {
-      return taskFunction().chainRejected(sequentor);
-    };
-
-    return sequentor();
-  }
-
-  Task.repeat = repeat;
-})(exports.Task || (exports.Task = {}));
-
-var resolver = function resolver() {
-  var stub = function stub(_) {};
-
-  var globalResolve = stub;
-
-  var resolve = function resolve(value) {
-    var r = globalResolve;
-    globalResolve = stub;
-    r(value);
-  };
-
-  var setResolve = function setResolve(value) {
-    globalResolve = value;
-  };
-
-  return [resolve, setResolve];
-};
-
-function chainTaskMaybe(_task, op) {
-  var globalCancel = {
-    cancel: _task._cancel
-  };
-  return exports.Task.create(_task._invoke.then( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(result) {
-      var _Task$fromFunction, invoke2, cancel2, produced, _produced$just$right, invoke3, cancel3;
-
-      return runtime_1.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _Task$fromFunction = exports.Task.fromFunction(function () {
-                return op(result);
-              }, globalCancel), invoke2 = _Task$fromFunction._invoke, cancel2 = _Task$fromFunction._cancel;
-              globalCancel.cancel = cancel2;
-              _context.next = 5;
-              return invoke2;
-
-            case 5:
-              produced = _context.sent;
-
-              if (!produced.isNothing()) {
-                _context.next = 8;
-                break;
-              }
-
-              return _context.abrupt("return", exports.Maybe.nothing());
-
-            case 8:
-              if (!produced.just.isLeft()) {
-                _context.next = 10;
-                break;
-              }
-
-              return _context.abrupt("return", exports.Maybe.just(exports.Either.left(produced.just.left)));
-
-            case 10:
-              _produced$just$right = produced.just.right, invoke3 = _produced$just$right._invoke, cancel3 = _produced$just$right._cancel;
-              globalCancel.cancel = cancel3;
-              return _context.abrupt("return", invoke3);
-
-            case 15:
-              _context.prev = 15;
-              _context.t0 = _context["catch"](0);
-              return _context.abrupt("return", exports.Maybe.just(exports.Either.left(_context.t0)));
-
-            case 18:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee, null, [[0, 15]]);
-    }));
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }()), function (error) {
-    return globalCancel.cancel(error);
-  });
-}
-
-function chainTaskEither(_task, op) {
-  return chainTaskMaybe(_task, function (maybe) {
-    return maybe.map(op).orMap(exports.Task.canceled).just;
-  });
-}
-
-function mapTaskMaybe(_task, op) {
-  return chainTaskMaybe(_task, function (maybe) {
-    return op(maybe).matchMap({
-      just: function just(either) {
-        return either.matchMap({
-          right: exports.Task.resolved,
-          left: exports.Task.rejected
-        }).right;
-      },
-      nothing: exports.Task.canceled
-    }).just;
-  });
-}
-
-function mapTaskEither(_task, op) {
-  return mapTaskMaybe(_task, function (maybe) {
-    return maybe.map(op);
-  });
-}
-
-function tapTaskMaybe(_task, op) {
-  return mapTaskMaybe(_task, function (value) {
-    op(value);
-    return value;
-  });
-}
-
-function tapTaskEither(_task, op) {
-  return tapTaskMaybe(_task, function (maybe) {
-    return maybe.tap(op);
-  });
-}
-
-var TaskClass = /*#__PURE__*/function () {
-  function TaskClass(_invoke, _cancel) {
-    this._invoke = _invoke;
-    this._cancel = _cancel;
-  }
-
-  var _proto = TaskClass.prototype;
-
-  _proto.tapCanceled = function tapCanceled(op) {
-    return tapTaskMaybe(this, function (maybe) {
-      return maybe.orTap(op);
-    });
-  };
-
-  _proto.tapRejected = function tapRejected(op) {
-    return tapTaskEither(this, function (either) {
-      return either.orTap(op);
-    });
-  };
-
-  _proto.tap = function tap(op) {
-    return tapTaskEither(this, function (either) {
-      return either.tap(op);
-    });
-  };
-
-  _proto.mapCanceled = function mapCanceled(op) {
-    return mapTaskMaybe(this, function (maybe) {
-      return maybe.orMap(function () {
-        return exports.Either.right(op());
-      });
-    });
-  };
-
-  _proto.mapRejected = function mapRejected(op) {
-    return mapTaskEither(this, function (either) {
-      return either.orMap(op);
-    });
-  };
-
-  _proto.map = function map(op) {
-    return mapTaskEither(this, function (either) {
-      return either.map(op);
-    });
-  };
-
-  _proto.chainCanceled = function chainCanceled(op) {
-    var mapEither = function mapEither(either) {
-      return either.map(exports.Task.resolved).orMap(exports.Task.rejected).right;
-    };
-
-    return chainTaskMaybe(this, function (maybe) {
-      return maybe.map(mapEither).orMap(op).just;
-    });
-  };
-
-  _proto.chainRejected = function chainRejected(op) {
-    return chainTaskEither(this, function (either) {
-      return either.map(exports.Task.resolved).orMap(op).right;
-    });
-  };
-
-  _proto.chain = function chain(op) {
-    return chainTaskEither(this, function (either) {
-      return either.map(op).orMap(exports.Task.rejected).right;
-    });
-  };
-
-  _proto.resolve = function resolve() {
-    return this._invoke;
-  };
-
-  _proto.cancel = function cancel() {
-    return this._cancel(exports.Maybe.nothing());
-  };
-
-  _proto.reject = function reject(error) {
-    return this._cancel(exports.Maybe.just(error));
-  };
-
-  _proto.generator = function generator() {
-    return /*#__PURE__*/runtime_1.mark(function _callee2(task) {
-      return runtime_1.wrap(function _callee2$(_context2) {
-        while (1) {
-          switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.next = 2;
-              return task;
-
-            case 2:
-              return _context2.abrupt("return", _context2.sent);
-
-            case 3:
-            case "end":
-              return _context2.stop();
-          }
-        }
-      }, _callee2);
-    })(this);
-  };
-
-  _proto.matchTap = function matchTap(op) {
-    return tapTaskMaybe(this, function (maybe) {
-      return maybe.matchTap({
-        just: function just(either) {
-          return either.matchTap({
-            right: op.resolved,
-            left: op.rejected
-          });
-        },
-        nothing: op.canceled
-      });
-    });
-  };
-
-  _proto.matchMap = function matchMap(op) {
-    return mapTaskMaybe(this, function (maybe) {
-      return maybe.matchMap({
-        just: function just(either) {
-          return either.matchMap({
-            right: op.resolved,
-            left: op.rejected
-          });
-        },
-        nothing: function nothing() {
-          return exports.Either.right(op.canceled());
-        }
-      });
-    });
-  };
-
-  _proto.matchChain = function matchChain(op) {
-    return chainTaskMaybe(this, function (maybe) {
-      return maybe.matchMap({
-        just: function just(either) {
-          return either.matchMap({
-            right: op.resolved,
-            left: op.rejected
-          }).right;
-        },
-        nothing: op.canceled
-      }).just;
-    });
-  };
-
-  return TaskClass;
-}();
-//# sourceMappingURL=t-tasks.cjs.development.js.map